1 /* 2 * Copyright (C) 2007 Alexey Proskuryakov <ap (at) nypop.com>. 3 * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. 4 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) 5 * Copyright (C) 2009 Jeff Schiller <codedread (at) gmail.com> 6 * Copyright (C) Research In Motion Limited 2010. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #ifndef CSSPrimitiveValueMappings_h 31 #define CSSPrimitiveValueMappings_h 32 33 #include "CSSValueKeywords.h" 34 #include "core/css/CSSCalculationValue.h" 35 #include "core/css/CSSPrimitiveValue.h" 36 #include "core/css/CSSReflectionDirection.h" 37 #include "core/platform/graphics/FontDescription.h" 38 #include "core/platform/graphics/FontSmoothingMode.h" 39 #include "core/platform/graphics/GraphicsTypes.h" 40 #include "core/platform/Length.h" 41 #include "core/platform/ThemeTypes.h" 42 #include "core/platform/graphics/Path.h" 43 #include "core/platform/graphics/TextRenderingMode.h" 44 #include "core/platform/text/TextDirection.h" 45 #include "core/platform/text/UnicodeBidi.h" 46 #include "core/platform/text/WritingMode.h" 47 #include "core/rendering/style/LineClampValue.h" 48 #include "core/rendering/style/RenderStyleConstants.h" 49 #include "core/rendering/style/SVGRenderStyleDefs.h" 50 #include "wtf/MathExtras.h" 51 52 namespace WebCore { 53 54 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i) 55 : CSSValue(PrimitiveClass) 56 { 57 m_primitiveUnitType = CSS_NUMBER; 58 m_value.num = static_cast<double>(i); 59 } 60 61 template<> inline CSSPrimitiveValue::operator short() const 62 { 63 if (m_primitiveUnitType == CSS_NUMBER) 64 return clampTo<short>(m_value.num); 65 66 ASSERT_NOT_REACHED(); 67 return 0; 68 } 69 70 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i) 71 : CSSValue(PrimitiveClass) 72 { 73 m_primitiveUnitType = CSS_NUMBER; 74 m_value.num = static_cast<double>(i); 75 } 76 77 template<> inline CSSPrimitiveValue::operator unsigned short() const 78 { 79 if (m_primitiveUnitType == CSS_NUMBER) 80 return clampTo<unsigned short>(m_value.num); 81 82 ASSERT_NOT_REACHED(); 83 return 0; 84 } 85 86 template<> inline CSSPrimitiveValue::operator int() const 87 { 88 if (m_primitiveUnitType == CSS_NUMBER) 89 return clampTo<int>(m_value.num); 90 91 ASSERT_NOT_REACHED(); 92 return 0; 93 } 94 95 template<> inline CSSPrimitiveValue::operator unsigned() const 96 { 97 if (m_primitiveUnitType == CSS_NUMBER) 98 return clampTo<unsigned>(m_value.num); 99 100 ASSERT_NOT_REACHED(); 101 return 0; 102 } 103 104 105 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i) 106 : CSSValue(PrimitiveClass) 107 { 108 m_primitiveUnitType = CSS_NUMBER; 109 m_value.num = static_cast<double>(i); 110 } 111 112 template<> inline CSSPrimitiveValue::operator float() const 113 { 114 if (m_primitiveUnitType == CSS_NUMBER) 115 return clampTo<float>(m_value.num); 116 117 ASSERT_NOT_REACHED(); 118 return 0.0f; 119 } 120 121 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i) 122 : CSSValue(PrimitiveClass) 123 { 124 m_primitiveUnitType = i.isPercentage() ? CSS_PERCENTAGE : CSS_NUMBER; 125 m_value.num = static_cast<double>(i.value()); 126 } 127 128 template<> inline CSSPrimitiveValue::operator LineClampValue() const 129 { 130 if (m_primitiveUnitType == CSS_NUMBER) 131 return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount); 132 133 if (m_primitiveUnitType == CSS_PERCENTAGE) 134 return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage); 135 136 ASSERT_NOT_REACHED(); 137 return LineClampValue(); 138 } 139 140 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e) 141 : CSSValue(PrimitiveClass) 142 { 143 m_primitiveUnitType = CSS_VALUE_ID; 144 switch (e) { 145 case ReflectionAbove: 146 m_value.valueID = CSSValueAbove; 147 break; 148 case ReflectionBelow: 149 m_value.valueID = CSSValueBelow; 150 break; 151 case ReflectionLeft: 152 m_value.valueID = CSSValueLeft; 153 break; 154 case ReflectionRight: 155 m_value.valueID = CSSValueRight; 156 } 157 } 158 159 template<> inline CSSPrimitiveValue::operator CSSReflectionDirection() const 160 { 161 ASSERT(isValueID()); 162 switch (m_value.valueID) { 163 case CSSValueAbove: 164 return ReflectionAbove; 165 case CSSValueBelow: 166 return ReflectionBelow; 167 case CSSValueLeft: 168 return ReflectionLeft; 169 case CSSValueRight: 170 return ReflectionRight; 171 default: 172 break; 173 } 174 175 ASSERT_NOT_REACHED(); 176 return ReflectionBelow; 177 } 178 179 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan) 180 : CSSValue(PrimitiveClass) 181 { 182 m_primitiveUnitType = CSS_VALUE_ID; 183 switch (columnSpan) { 184 case ColumnSpanAll: 185 m_value.valueID = CSSValueAll; 186 break; 187 case ColumnSpanNone: 188 m_value.valueID = CSSValueNone; 189 break; 190 } 191 } 192 193 template<> inline CSSPrimitiveValue::operator ColumnSpan() const 194 { 195 // Map 1 to none for compatibility reasons. 196 if (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1) 197 return ColumnSpanNone; 198 199 ASSERT(isValueID()); 200 switch (m_value.valueID) { 201 case CSSValueAll: 202 return ColumnSpanAll; 203 case CSSValueNone: 204 return ColumnSpanNone; 205 default: 206 break; 207 } 208 209 ASSERT_NOT_REACHED(); 210 return ColumnSpanNone; 211 } 212 213 214 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value) 215 : CSSValue(PrimitiveClass) 216 { 217 m_primitiveUnitType = CSS_VALUE_ID; 218 switch (value) { 219 case PrintColorAdjustExact: 220 m_value.valueID = CSSValueExact; 221 break; 222 case PrintColorAdjustEconomy: 223 m_value.valueID = CSSValueEconomy; 224 break; 225 } 226 } 227 228 template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const 229 { 230 ASSERT(isValueID()); 231 switch (m_value.valueID) { 232 case CSSValueEconomy: 233 return PrintColorAdjustEconomy; 234 case CSSValueExact: 235 return PrintColorAdjustExact; 236 default: 237 break; 238 } 239 240 ASSERT_NOT_REACHED(); 241 return PrintColorAdjustEconomy; 242 } 243 244 245 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e) 246 : CSSValue(PrimitiveClass) 247 { 248 m_primitiveUnitType = CSS_VALUE_ID; 249 switch (e) { 250 case BNONE: 251 m_value.valueID = CSSValueNone; 252 break; 253 case BHIDDEN: 254 m_value.valueID = CSSValueHidden; 255 break; 256 case INSET: 257 m_value.valueID = CSSValueInset; 258 break; 259 case GROOVE: 260 m_value.valueID = CSSValueGroove; 261 break; 262 case RIDGE: 263 m_value.valueID = CSSValueRidge; 264 break; 265 case OUTSET: 266 m_value.valueID = CSSValueOutset; 267 break; 268 case DOTTED: 269 m_value.valueID = CSSValueDotted; 270 break; 271 case DASHED: 272 m_value.valueID = CSSValueDashed; 273 break; 274 case SOLID: 275 m_value.valueID = CSSValueSolid; 276 break; 277 case DOUBLE: 278 m_value.valueID = CSSValueDouble; 279 break; 280 } 281 } 282 283 template<> inline CSSPrimitiveValue::operator EBorderStyle() const 284 { 285 ASSERT(isValueID()); 286 if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style 287 return DOTTED; 288 return (EBorderStyle)(m_value.valueID - CSSValueNone); 289 } 290 291 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const 292 { 293 if (m_value.valueID == CSSValueAuto) 294 return AUTO_ON; 295 return AUTO_OFF; 296 } 297 298 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e) 299 : CSSValue(PrimitiveClass) 300 { 301 m_primitiveUnitType = CSS_VALUE_ID; 302 switch (e) { 303 case CompositeClear: 304 m_value.valueID = CSSValueClear; 305 break; 306 case CompositeCopy: 307 m_value.valueID = CSSValueCopy; 308 break; 309 case CompositeSourceOver: 310 m_value.valueID = CSSValueSourceOver; 311 break; 312 case CompositeSourceIn: 313 m_value.valueID = CSSValueSourceIn; 314 break; 315 case CompositeSourceOut: 316 m_value.valueID = CSSValueSourceOut; 317 break; 318 case CompositeSourceAtop: 319 m_value.valueID = CSSValueSourceAtop; 320 break; 321 case CompositeDestinationOver: 322 m_value.valueID = CSSValueDestinationOver; 323 break; 324 case CompositeDestinationIn: 325 m_value.valueID = CSSValueDestinationIn; 326 break; 327 case CompositeDestinationOut: 328 m_value.valueID = CSSValueDestinationOut; 329 break; 330 case CompositeDestinationAtop: 331 m_value.valueID = CSSValueDestinationAtop; 332 break; 333 case CompositeXOR: 334 m_value.valueID = CSSValueXor; 335 break; 336 case CompositePlusDarker: 337 m_value.valueID = CSSValuePlusDarker; 338 break; 339 case CompositePlusLighter: 340 m_value.valueID = CSSValuePlusLighter; 341 break; 342 case CompositeDifference: 343 ASSERT_NOT_REACHED(); 344 break; 345 } 346 } 347 348 template<> inline CSSPrimitiveValue::operator CompositeOperator() const 349 { 350 ASSERT(isValueID()); 351 switch (m_value.valueID) { 352 case CSSValueClear: 353 return CompositeClear; 354 case CSSValueCopy: 355 return CompositeCopy; 356 case CSSValueSourceOver: 357 return CompositeSourceOver; 358 case CSSValueSourceIn: 359 return CompositeSourceIn; 360 case CSSValueSourceOut: 361 return CompositeSourceOut; 362 case CSSValueSourceAtop: 363 return CompositeSourceAtop; 364 case CSSValueDestinationOver: 365 return CompositeDestinationOver; 366 case CSSValueDestinationIn: 367 return CompositeDestinationIn; 368 case CSSValueDestinationOut: 369 return CompositeDestinationOut; 370 case CSSValueDestinationAtop: 371 return CompositeDestinationAtop; 372 case CSSValueXor: 373 return CompositeXOR; 374 case CSSValuePlusDarker: 375 return CompositePlusDarker; 376 case CSSValuePlusLighter: 377 return CompositePlusLighter; 378 default: 379 break; 380 } 381 382 ASSERT_NOT_REACHED(); 383 return CompositeClear; 384 } 385 386 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e) 387 : CSSValue(PrimitiveClass) 388 { 389 m_primitiveUnitType = CSS_VALUE_ID; 390 switch (e) { 391 case NoControlPart: 392 m_value.valueID = CSSValueNone; 393 break; 394 case CheckboxPart: 395 m_value.valueID = CSSValueCheckbox; 396 break; 397 case RadioPart: 398 m_value.valueID = CSSValueRadio; 399 break; 400 case PushButtonPart: 401 m_value.valueID = CSSValuePushButton; 402 break; 403 case SquareButtonPart: 404 m_value.valueID = CSSValueSquareButton; 405 break; 406 case ButtonPart: 407 m_value.valueID = CSSValueButton; 408 break; 409 case ButtonBevelPart: 410 m_value.valueID = CSSValueButtonBevel; 411 break; 412 case InnerSpinButtonPart: 413 m_value.valueID = CSSValueInnerSpinButton; 414 break; 415 case ListboxPart: 416 m_value.valueID = CSSValueListbox; 417 break; 418 case ListItemPart: 419 m_value.valueID = CSSValueListitem; 420 break; 421 case MediaEnterFullscreenButtonPart: 422 m_value.valueID = CSSValueMediaEnterFullscreenButton; 423 break; 424 case MediaExitFullscreenButtonPart: 425 m_value.valueID = CSSValueMediaExitFullscreenButton; 426 break; 427 case MediaPlayButtonPart: 428 m_value.valueID = CSSValueMediaPlayButton; 429 break; 430 case MediaOverlayPlayButtonPart: 431 m_value.valueID = CSSValueMediaOverlayPlayButton; 432 break; 433 case MediaMuteButtonPart: 434 m_value.valueID = CSSValueMediaMuteButton; 435 break; 436 case MediaSeekBackButtonPart: 437 m_value.valueID = CSSValueMediaSeekBackButton; 438 break; 439 case MediaSeekForwardButtonPart: 440 m_value.valueID = CSSValueMediaSeekForwardButton; 441 break; 442 case MediaRewindButtonPart: 443 m_value.valueID = CSSValueMediaRewindButton; 444 break; 445 case MediaReturnToRealtimeButtonPart: 446 m_value.valueID = CSSValueMediaReturnToRealtimeButton; 447 break; 448 case MediaToggleClosedCaptionsButtonPart: 449 m_value.valueID = CSSValueMediaToggleClosedCaptionsButton; 450 break; 451 case MediaSliderPart: 452 m_value.valueID = CSSValueMediaSlider; 453 break; 454 case MediaSliderThumbPart: 455 m_value.valueID = CSSValueMediaSliderthumb; 456 break; 457 case MediaVolumeSliderContainerPart: 458 m_value.valueID = CSSValueMediaVolumeSliderContainer; 459 break; 460 case MediaVolumeSliderPart: 461 m_value.valueID = CSSValueMediaVolumeSlider; 462 break; 463 case MediaVolumeSliderMuteButtonPart: 464 m_value.valueID = CSSValueMediaVolumeSliderMuteButton; 465 break; 466 case MediaVolumeSliderThumbPart: 467 m_value.valueID = CSSValueMediaVolumeSliderthumb; 468 break; 469 case MediaControlsBackgroundPart: 470 m_value.valueID = CSSValueMediaControlsBackground; 471 break; 472 case MediaControlsFullscreenBackgroundPart: 473 m_value.valueID = CSSValueMediaControlsFullscreenBackground; 474 break; 475 case MediaFullScreenVolumeSliderPart: 476 m_value.valueID = CSSValueMediaFullscreenVolumeSlider; 477 break; 478 case MediaFullScreenVolumeSliderThumbPart: 479 m_value.valueID = CSSValueMediaFullscreenVolumeSliderThumb; 480 break; 481 case MediaCurrentTimePart: 482 m_value.valueID = CSSValueMediaCurrentTimeDisplay; 483 break; 484 case MediaTimeRemainingPart: 485 m_value.valueID = CSSValueMediaTimeRemainingDisplay; 486 break; 487 case MenulistPart: 488 m_value.valueID = CSSValueMenulist; 489 break; 490 case MenulistButtonPart: 491 m_value.valueID = CSSValueMenulistButton; 492 break; 493 case MenulistTextPart: 494 m_value.valueID = CSSValueMenulistText; 495 break; 496 case MenulistTextFieldPart: 497 m_value.valueID = CSSValueMenulistTextfield; 498 break; 499 case MeterPart: 500 m_value.valueID = CSSValueMeter; 501 break; 502 case RelevancyLevelIndicatorPart: 503 m_value.valueID = CSSValueRelevancyLevelIndicator; 504 break; 505 case ContinuousCapacityLevelIndicatorPart: 506 m_value.valueID = CSSValueContinuousCapacityLevelIndicator; 507 break; 508 case DiscreteCapacityLevelIndicatorPart: 509 m_value.valueID = CSSValueDiscreteCapacityLevelIndicator; 510 break; 511 case RatingLevelIndicatorPart: 512 m_value.valueID = CSSValueRatingLevelIndicator; 513 break; 514 case ProgressBarPart: 515 m_value.valueID = CSSValueProgressBar; 516 break; 517 case ProgressBarValuePart: 518 m_value.valueID = CSSValueProgressBarValue; 519 break; 520 case SliderHorizontalPart: 521 m_value.valueID = CSSValueSliderHorizontal; 522 break; 523 case SliderVerticalPart: 524 m_value.valueID = CSSValueSliderVertical; 525 break; 526 case SliderThumbHorizontalPart: 527 m_value.valueID = CSSValueSliderthumbHorizontal; 528 break; 529 case SliderThumbVerticalPart: 530 m_value.valueID = CSSValueSliderthumbVertical; 531 break; 532 case CaretPart: 533 m_value.valueID = CSSValueCaret; 534 break; 535 case SearchFieldPart: 536 m_value.valueID = CSSValueSearchfield; 537 break; 538 case SearchFieldDecorationPart: 539 m_value.valueID = CSSValueSearchfieldDecoration; 540 break; 541 case SearchFieldResultsDecorationPart: 542 m_value.valueID = CSSValueSearchfieldResultsDecoration; 543 break; 544 case SearchFieldCancelButtonPart: 545 m_value.valueID = CSSValueSearchfieldCancelButton; 546 break; 547 case TextFieldPart: 548 m_value.valueID = CSSValueTextfield; 549 break; 550 case TextAreaPart: 551 m_value.valueID = CSSValueTextarea; 552 break; 553 case CapsLockIndicatorPart: 554 m_value.valueID = CSSValueCapsLockIndicator; 555 break; 556 case InputSpeechButtonPart: 557 #if ENABLE(INPUT_SPEECH) 558 m_value.valueID = CSSValueWebkitInputSpeechButton; 559 #endif 560 break; 561 } 562 } 563 564 template<> inline CSSPrimitiveValue::operator ControlPart() const 565 { 566 ASSERT(isValueID()); 567 if (m_value.valueID == CSSValueNone) 568 return NoControlPart; 569 return ControlPart(m_value.valueID - CSSValueCheckbox + 1); 570 } 571 572 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e) 573 : CSSValue(PrimitiveClass) 574 { 575 m_primitiveUnitType = CSS_VALUE_ID; 576 switch (e) { 577 case BackfaceVisibilityVisible: 578 m_value.valueID = CSSValueVisible; 579 break; 580 case BackfaceVisibilityHidden: 581 m_value.valueID = CSSValueHidden; 582 break; 583 } 584 } 585 586 template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const 587 { 588 ASSERT(isValueID()); 589 switch (m_value.valueID) { 590 case CSSValueVisible: 591 return BackfaceVisibilityVisible; 592 case CSSValueHidden: 593 return BackfaceVisibilityHidden; 594 default: 595 break; 596 } 597 598 ASSERT_NOT_REACHED(); 599 return BackfaceVisibilityHidden; 600 } 601 602 603 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e) 604 : CSSValue(PrimitiveClass) 605 { 606 m_primitiveUnitType = CSS_VALUE_ID; 607 switch (e) { 608 case ScrollBackgroundAttachment: 609 m_value.valueID = CSSValueScroll; 610 break; 611 case LocalBackgroundAttachment: 612 m_value.valueID = CSSValueLocal; 613 break; 614 case FixedBackgroundAttachment: 615 m_value.valueID = CSSValueFixed; 616 break; 617 } 618 } 619 620 template<> inline CSSPrimitiveValue::operator EFillAttachment() const 621 { 622 ASSERT(isValueID()); 623 switch (m_value.valueID) { 624 case CSSValueScroll: 625 return ScrollBackgroundAttachment; 626 case CSSValueLocal: 627 return LocalBackgroundAttachment; 628 case CSSValueFixed: 629 return FixedBackgroundAttachment; 630 default: 631 break; 632 } 633 634 ASSERT_NOT_REACHED(); 635 return ScrollBackgroundAttachment; 636 } 637 638 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e) 639 : CSSValue(PrimitiveClass) 640 { 641 m_primitiveUnitType = CSS_VALUE_ID; 642 switch (e) { 643 case BorderFillBox: 644 m_value.valueID = CSSValueBorderBox; 645 break; 646 case PaddingFillBox: 647 m_value.valueID = CSSValuePaddingBox; 648 break; 649 case ContentFillBox: 650 m_value.valueID = CSSValueContentBox; 651 break; 652 case TextFillBox: 653 m_value.valueID = CSSValueText; 654 break; 655 } 656 } 657 658 template<> inline CSSPrimitiveValue::operator EFillBox() const 659 { 660 ASSERT(isValueID()); 661 switch (m_value.valueID) { 662 case CSSValueBorder: 663 case CSSValueBorderBox: 664 return BorderFillBox; 665 case CSSValuePadding: 666 case CSSValuePaddingBox: 667 return PaddingFillBox; 668 case CSSValueContent: 669 case CSSValueContentBox: 670 return ContentFillBox; 671 case CSSValueText: 672 case CSSValueWebkitText: 673 return TextFillBox; 674 default: 675 break; 676 } 677 678 ASSERT_NOT_REACHED(); 679 return BorderFillBox; 680 } 681 682 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e) 683 : CSSValue(PrimitiveClass) 684 { 685 m_primitiveUnitType = CSS_VALUE_ID; 686 switch (e) { 687 case RepeatFill: 688 m_value.valueID = CSSValueRepeat; 689 break; 690 case NoRepeatFill: 691 m_value.valueID = CSSValueNoRepeat; 692 break; 693 case RoundFill: 694 m_value.valueID = CSSValueRound; 695 break; 696 case SpaceFill: 697 m_value.valueID = CSSValueSpace; 698 break; 699 } 700 } 701 702 template<> inline CSSPrimitiveValue::operator EFillRepeat() const 703 { 704 ASSERT(isValueID()); 705 switch (m_value.valueID) { 706 case CSSValueRepeat: 707 return RepeatFill; 708 case CSSValueNoRepeat: 709 return NoRepeatFill; 710 case CSSValueRound: 711 return RoundFill; 712 case CSSValueSpace: 713 return SpaceFill; 714 default: 715 break; 716 } 717 718 ASSERT_NOT_REACHED(); 719 return RepeatFill; 720 } 721 722 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e) 723 : CSSValue(PrimitiveClass) 724 { 725 m_primitiveUnitType = CSS_VALUE_ID; 726 switch (e) { 727 case Start: 728 m_value.valueID = CSSValueStart; 729 break; 730 case Center: 731 m_value.valueID = CSSValueCenter; 732 break; 733 case End: 734 m_value.valueID = CSSValueEnd; 735 break; 736 case Justify: 737 m_value.valueID = CSSValueJustify; 738 break; 739 } 740 } 741 742 template<> inline CSSPrimitiveValue::operator EBoxPack() const 743 { 744 ASSERT(isValueID()); 745 switch (m_value.valueID) { 746 case CSSValueStart: 747 return Start; 748 case CSSValueEnd: 749 return End; 750 case CSSValueCenter: 751 return Center; 752 case CSSValueJustify: 753 return Justify; 754 default: 755 break; 756 } 757 758 ASSERT_NOT_REACHED(); 759 return Justify; 760 } 761 762 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e) 763 : CSSValue(PrimitiveClass) 764 { 765 m_primitiveUnitType = CSS_VALUE_ID; 766 switch (e) { 767 case BSTRETCH: 768 m_value.valueID = CSSValueStretch; 769 break; 770 case BSTART: 771 m_value.valueID = CSSValueStart; 772 break; 773 case BCENTER: 774 m_value.valueID = CSSValueCenter; 775 break; 776 case BEND: 777 m_value.valueID = CSSValueEnd; 778 break; 779 case BBASELINE: 780 m_value.valueID = CSSValueBaseline; 781 break; 782 } 783 } 784 785 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const 786 { 787 ASSERT(isValueID()); 788 switch (m_value.valueID) { 789 case CSSValueStretch: 790 return BSTRETCH; 791 case CSSValueStart: 792 return BSTART; 793 case CSSValueEnd: 794 return BEND; 795 case CSSValueCenter: 796 return BCENTER; 797 case CSSValueBaseline: 798 return BBASELINE; 799 default: 800 break; 801 } 802 803 ASSERT_NOT_REACHED(); 804 return BSTRETCH; 805 } 806 807 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e) 808 : CSSValue(PrimitiveClass) 809 { 810 m_primitiveUnitType = CSS_VALUE_ID; 811 switch (e) { 812 case DSLICE: 813 m_value.valueID = CSSValueSlice; 814 break; 815 case DCLONE: 816 m_value.valueID = CSSValueClone; 817 break; 818 } 819 } 820 821 template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const 822 { 823 ASSERT(isValueID()); 824 switch (m_value.valueID) { 825 case CSSValueSlice: 826 return DSLICE; 827 case CSSValueClone: 828 return DCLONE; 829 default: 830 break; 831 } 832 833 ASSERT_NOT_REACHED(); 834 return DSLICE; 835 } 836 837 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e) 838 : CSSValue(PrimitiveClass) 839 { 840 m_primitiveUnitType = CSS_VALUE_ID; 841 switch (e) { 842 case TopEdge: 843 m_value.valueID = CSSValueTop; 844 break; 845 case RightEdge: 846 m_value.valueID = CSSValueRight; 847 break; 848 case BottomEdge: 849 m_value.valueID = CSSValueBottom; 850 break; 851 case LeftEdge: 852 m_value.valueID = CSSValueLeft; 853 break; 854 } 855 } 856 857 template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const 858 { 859 ASSERT(isValueID()); 860 switch (m_value.valueID) { 861 case CSSValueTop: 862 return TopEdge; 863 case CSSValueRight: 864 return RightEdge; 865 case CSSValueBottom: 866 return BottomEdge; 867 case CSSValueLeft: 868 return LeftEdge; 869 default: 870 break; 871 } 872 873 ASSERT_NOT_REACHED(); 874 return TopEdge; 875 } 876 877 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e) 878 : CSSValue(PrimitiveClass) 879 { 880 m_primitiveUnitType = CSS_VALUE_ID; 881 switch (e) { 882 case BORDER_BOX: 883 m_value.valueID = CSSValueBorderBox; 884 break; 885 case CONTENT_BOX: 886 m_value.valueID = CSSValueContentBox; 887 break; 888 } 889 } 890 891 template<> inline CSSPrimitiveValue::operator EBoxSizing() const 892 { 893 ASSERT(isValueID()); 894 switch (m_value.valueID) { 895 case CSSValueBorderBox: 896 return BORDER_BOX; 897 case CSSValueContentBox: 898 return CONTENT_BOX; 899 default: 900 break; 901 } 902 903 ASSERT_NOT_REACHED(); 904 return BORDER_BOX; 905 } 906 907 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e) 908 : CSSValue(PrimitiveClass) 909 { 910 m_primitiveUnitType = CSS_VALUE_ID; 911 switch (e) { 912 case BNORMAL: 913 m_value.valueID = CSSValueNormal; 914 break; 915 case BREVERSE: 916 m_value.valueID = CSSValueReverse; 917 break; 918 } 919 } 920 921 template<> inline CSSPrimitiveValue::operator EBoxDirection() const 922 { 923 ASSERT(isValueID()); 924 switch (m_value.valueID) { 925 case CSSValueNormal: 926 return BNORMAL; 927 case CSSValueReverse: 928 return BREVERSE; 929 default: 930 break; 931 } 932 933 ASSERT_NOT_REACHED(); 934 return BNORMAL; 935 } 936 937 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e) 938 : CSSValue(PrimitiveClass) 939 { 940 m_primitiveUnitType = CSS_VALUE_ID; 941 switch (e) { 942 case SINGLE: 943 m_value.valueID = CSSValueSingle; 944 break; 945 case MULTIPLE: 946 m_value.valueID = CSSValueMultiple; 947 break; 948 } 949 } 950 951 template<> inline CSSPrimitiveValue::operator EBoxLines() const 952 { 953 ASSERT(isValueID()); 954 switch (m_value.valueID) { 955 case CSSValueSingle: 956 return SINGLE; 957 case CSSValueMultiple: 958 return MULTIPLE; 959 default: 960 break; 961 } 962 963 ASSERT_NOT_REACHED(); 964 return SINGLE; 965 } 966 967 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e) 968 : CSSValue(PrimitiveClass) 969 { 970 m_primitiveUnitType = CSS_VALUE_ID; 971 switch (e) { 972 case HORIZONTAL: 973 m_value.valueID = CSSValueHorizontal; 974 break; 975 case VERTICAL: 976 m_value.valueID = CSSValueVertical; 977 break; 978 } 979 } 980 981 template<> inline CSSPrimitiveValue::operator EBoxOrient() const 982 { 983 ASSERT(isValueID()); 984 switch (m_value.valueID) { 985 case CSSValueHorizontal: 986 case CSSValueInlineAxis: 987 return HORIZONTAL; 988 case CSSValueVertical: 989 case CSSValueBlockAxis: 990 return VERTICAL; 991 default: 992 break; 993 } 994 995 ASSERT_NOT_REACHED(); 996 return HORIZONTAL; 997 } 998 999 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e) 1000 : CSSValue(PrimitiveClass) 1001 { 1002 m_primitiveUnitType = CSS_VALUE_ID; 1003 switch (e) { 1004 case CAPLEFT: 1005 m_value.valueID = CSSValueLeft; 1006 break; 1007 case CAPRIGHT: 1008 m_value.valueID = CSSValueRight; 1009 break; 1010 case CAPTOP: 1011 m_value.valueID = CSSValueTop; 1012 break; 1013 case CAPBOTTOM: 1014 m_value.valueID = CSSValueBottom; 1015 break; 1016 } 1017 } 1018 1019 template<> inline CSSPrimitiveValue::operator ECaptionSide() const 1020 { 1021 ASSERT(isValueID()); 1022 switch (m_value.valueID) { 1023 case CSSValueLeft: 1024 return CAPLEFT; 1025 case CSSValueRight: 1026 return CAPRIGHT; 1027 case CSSValueTop: 1028 return CAPTOP; 1029 case CSSValueBottom: 1030 return CAPBOTTOM; 1031 default: 1032 break; 1033 } 1034 1035 ASSERT_NOT_REACHED(); 1036 return CAPTOP; 1037 } 1038 1039 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e) 1040 : CSSValue(PrimitiveClass) 1041 { 1042 m_primitiveUnitType = CSS_VALUE_ID; 1043 switch (e) { 1044 case CNONE: 1045 m_value.valueID = CSSValueNone; 1046 break; 1047 case CLEFT: 1048 m_value.valueID = CSSValueLeft; 1049 break; 1050 case CRIGHT: 1051 m_value.valueID = CSSValueRight; 1052 break; 1053 case CBOTH: 1054 m_value.valueID = CSSValueBoth; 1055 break; 1056 } 1057 } 1058 1059 template<> inline CSSPrimitiveValue::operator EClear() const 1060 { 1061 ASSERT(isValueID()); 1062 switch (m_value.valueID) { 1063 case CSSValueNone: 1064 return CNONE; 1065 case CSSValueLeft: 1066 return CLEFT; 1067 case CSSValueRight: 1068 return CRIGHT; 1069 case CSSValueBoth: 1070 return CBOTH; 1071 default: 1072 break; 1073 } 1074 1075 ASSERT_NOT_REACHED(); 1076 return CNONE; 1077 } 1078 1079 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e) 1080 : CSSValue(PrimitiveClass) 1081 { 1082 m_primitiveUnitType = CSS_VALUE_ID; 1083 switch (e) { 1084 case CURSOR_AUTO: 1085 m_value.valueID = CSSValueAuto; 1086 break; 1087 case CURSOR_CROSS: 1088 m_value.valueID = CSSValueCrosshair; 1089 break; 1090 case CURSOR_DEFAULT: 1091 m_value.valueID = CSSValueDefault; 1092 break; 1093 case CURSOR_POINTER: 1094 m_value.valueID = CSSValuePointer; 1095 break; 1096 case CURSOR_MOVE: 1097 m_value.valueID = CSSValueMove; 1098 break; 1099 case CURSOR_CELL: 1100 m_value.valueID = CSSValueCell; 1101 break; 1102 case CURSOR_VERTICAL_TEXT: 1103 m_value.valueID = CSSValueVerticalText; 1104 break; 1105 case CURSOR_CONTEXT_MENU: 1106 m_value.valueID = CSSValueContextMenu; 1107 break; 1108 case CURSOR_ALIAS: 1109 m_value.valueID = CSSValueAlias; 1110 break; 1111 case CURSOR_COPY: 1112 m_value.valueID = CSSValueCopy; 1113 break; 1114 case CURSOR_NONE: 1115 m_value.valueID = CSSValueNone; 1116 break; 1117 case CURSOR_PROGRESS: 1118 m_value.valueID = CSSValueProgress; 1119 break; 1120 case CURSOR_NO_DROP: 1121 m_value.valueID = CSSValueNoDrop; 1122 break; 1123 case CURSOR_NOT_ALLOWED: 1124 m_value.valueID = CSSValueNotAllowed; 1125 break; 1126 case CURSOR_WEBKIT_ZOOM_IN: 1127 m_value.valueID = CSSValueWebkitZoomIn; 1128 break; 1129 case CURSOR_WEBKIT_ZOOM_OUT: 1130 m_value.valueID = CSSValueWebkitZoomOut; 1131 break; 1132 case CURSOR_E_RESIZE: 1133 m_value.valueID = CSSValueEResize; 1134 break; 1135 case CURSOR_NE_RESIZE: 1136 m_value.valueID = CSSValueNeResize; 1137 break; 1138 case CURSOR_NW_RESIZE: 1139 m_value.valueID = CSSValueNwResize; 1140 break; 1141 case CURSOR_N_RESIZE: 1142 m_value.valueID = CSSValueNResize; 1143 break; 1144 case CURSOR_SE_RESIZE: 1145 m_value.valueID = CSSValueSeResize; 1146 break; 1147 case CURSOR_SW_RESIZE: 1148 m_value.valueID = CSSValueSwResize; 1149 break; 1150 case CURSOR_S_RESIZE: 1151 m_value.valueID = CSSValueSResize; 1152 break; 1153 case CURSOR_W_RESIZE: 1154 m_value.valueID = CSSValueWResize; 1155 break; 1156 case CURSOR_EW_RESIZE: 1157 m_value.valueID = CSSValueEwResize; 1158 break; 1159 case CURSOR_NS_RESIZE: 1160 m_value.valueID = CSSValueNsResize; 1161 break; 1162 case CURSOR_NESW_RESIZE: 1163 m_value.valueID = CSSValueNeswResize; 1164 break; 1165 case CURSOR_NWSE_RESIZE: 1166 m_value.valueID = CSSValueNwseResize; 1167 break; 1168 case CURSOR_COL_RESIZE: 1169 m_value.valueID = CSSValueColResize; 1170 break; 1171 case CURSOR_ROW_RESIZE: 1172 m_value.valueID = CSSValueRowResize; 1173 break; 1174 case CURSOR_TEXT: 1175 m_value.valueID = CSSValueText; 1176 break; 1177 case CURSOR_WAIT: 1178 m_value.valueID = CSSValueWait; 1179 break; 1180 case CURSOR_HELP: 1181 m_value.valueID = CSSValueHelp; 1182 break; 1183 case CURSOR_ALL_SCROLL: 1184 m_value.valueID = CSSValueAllScroll; 1185 break; 1186 case CURSOR_WEBKIT_GRAB: 1187 m_value.valueID = CSSValueWebkitGrab; 1188 break; 1189 case CURSOR_WEBKIT_GRABBING: 1190 m_value.valueID = CSSValueWebkitGrabbing; 1191 break; 1192 } 1193 } 1194 1195 template<> inline CSSPrimitiveValue::operator ECursor() const 1196 { 1197 ASSERT(isValueID()); 1198 if (m_value.valueID == CSSValueCopy) 1199 return CURSOR_COPY; 1200 if (m_value.valueID == CSSValueNone) 1201 return CURSOR_NONE; 1202 return static_cast<ECursor>(m_value.valueID - CSSValueAuto); 1203 } 1204 1205 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e) 1206 : CSSValue(PrimitiveClass) 1207 { 1208 m_primitiveUnitType = CSS_VALUE_ID; 1209 switch (e) { 1210 case INLINE: 1211 m_value.valueID = CSSValueInline; 1212 break; 1213 case BLOCK: 1214 m_value.valueID = CSSValueBlock; 1215 break; 1216 case LIST_ITEM: 1217 m_value.valueID = CSSValueListItem; 1218 break; 1219 case RUN_IN: 1220 m_value.valueID = CSSValueRunIn; 1221 break; 1222 case COMPACT: 1223 m_value.valueID = CSSValueCompact; 1224 break; 1225 case INLINE_BLOCK: 1226 m_value.valueID = CSSValueInlineBlock; 1227 break; 1228 case TABLE: 1229 m_value.valueID = CSSValueTable; 1230 break; 1231 case INLINE_TABLE: 1232 m_value.valueID = CSSValueInlineTable; 1233 break; 1234 case TABLE_ROW_GROUP: 1235 m_value.valueID = CSSValueTableRowGroup; 1236 break; 1237 case TABLE_HEADER_GROUP: 1238 m_value.valueID = CSSValueTableHeaderGroup; 1239 break; 1240 case TABLE_FOOTER_GROUP: 1241 m_value.valueID = CSSValueTableFooterGroup; 1242 break; 1243 case TABLE_ROW: 1244 m_value.valueID = CSSValueTableRow; 1245 break; 1246 case TABLE_COLUMN_GROUP: 1247 m_value.valueID = CSSValueTableColumnGroup; 1248 break; 1249 case TABLE_COLUMN: 1250 m_value.valueID = CSSValueTableColumn; 1251 break; 1252 case TABLE_CELL: 1253 m_value.valueID = CSSValueTableCell; 1254 break; 1255 case TABLE_CAPTION: 1256 m_value.valueID = CSSValueTableCaption; 1257 break; 1258 case BOX: 1259 m_value.valueID = CSSValueWebkitBox; 1260 break; 1261 case INLINE_BOX: 1262 m_value.valueID = CSSValueWebkitInlineBox; 1263 break; 1264 case FLEX: 1265 m_value.valueID = CSSValueFlex; 1266 break; 1267 case INLINE_FLEX: 1268 m_value.valueID = CSSValueInlineFlex; 1269 break; 1270 case GRID: 1271 m_value.valueID = CSSValueGrid; 1272 break; 1273 case INLINE_GRID: 1274 m_value.valueID = CSSValueInlineGrid; 1275 break; 1276 case LAZY_BLOCK: 1277 m_value.valueID = CSSValueLazyBlock; 1278 break; 1279 case NONE: 1280 m_value.valueID = CSSValueNone; 1281 break; 1282 } 1283 } 1284 1285 template<> inline CSSPrimitiveValue::operator EDisplay() const 1286 { 1287 ASSERT(isValueID()); 1288 if (m_value.valueID == CSSValueNone) 1289 return NONE; 1290 1291 if (m_value.valueID == CSSValueWebkitFlex) 1292 return FLEX; 1293 if (m_value.valueID == CSSValueWebkitInlineFlex) 1294 return INLINE_FLEX; 1295 1296 EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline); 1297 ASSERT(display >= INLINE && display <= NONE); 1298 return display; 1299 } 1300 1301 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e) 1302 : CSSValue(PrimitiveClass) 1303 { 1304 m_primitiveUnitType = CSS_VALUE_ID; 1305 switch (e) { 1306 case SHOW: 1307 m_value.valueID = CSSValueShow; 1308 break; 1309 case HIDE: 1310 m_value.valueID = CSSValueHide; 1311 break; 1312 } 1313 } 1314 1315 template<> inline CSSPrimitiveValue::operator EEmptyCell() const 1316 { 1317 ASSERT(isValueID()); 1318 switch (m_value.valueID) { 1319 case CSSValueShow: 1320 return SHOW; 1321 case CSSValueHide: 1322 return HIDE; 1323 default: 1324 break; 1325 } 1326 1327 ASSERT_NOT_REACHED(); 1328 return SHOW; 1329 } 1330 1331 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignItems e) 1332 : CSSValue(PrimitiveClass) 1333 { 1334 m_primitiveUnitType = CSS_VALUE_ID; 1335 switch (e) { 1336 case AlignAuto: 1337 m_value.valueID = CSSValueAuto; 1338 break; 1339 case AlignFlexStart: 1340 m_value.valueID = CSSValueFlexStart; 1341 break; 1342 case AlignFlexEnd: 1343 m_value.valueID = CSSValueFlexEnd; 1344 break; 1345 case AlignCenter: 1346 m_value.valueID = CSSValueCenter; 1347 break; 1348 case AlignStretch: 1349 m_value.valueID = CSSValueStretch; 1350 break; 1351 case AlignBaseline: 1352 m_value.valueID = CSSValueBaseline; 1353 break; 1354 } 1355 } 1356 1357 template<> inline CSSPrimitiveValue::operator EAlignItems() const 1358 { 1359 ASSERT(isValueID()); 1360 switch (m_value.valueID) { 1361 case CSSValueAuto: 1362 return AlignAuto; 1363 case CSSValueFlexStart: 1364 return AlignFlexStart; 1365 case CSSValueFlexEnd: 1366 return AlignFlexEnd; 1367 case CSSValueCenter: 1368 return AlignCenter; 1369 case CSSValueStretch: 1370 return AlignStretch; 1371 case CSSValueBaseline: 1372 return AlignBaseline; 1373 default: 1374 break; 1375 } 1376 1377 ASSERT_NOT_REACHED(); 1378 return AlignFlexStart; 1379 } 1380 1381 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e) 1382 : CSSValue(PrimitiveClass) 1383 { 1384 m_primitiveUnitType = CSS_VALUE_ID; 1385 switch (e) { 1386 case JustifyFlexStart: 1387 m_value.valueID = CSSValueFlexStart; 1388 break; 1389 case JustifyFlexEnd: 1390 m_value.valueID = CSSValueFlexEnd; 1391 break; 1392 case JustifyCenter: 1393 m_value.valueID = CSSValueCenter; 1394 break; 1395 case JustifySpaceBetween: 1396 m_value.valueID = CSSValueSpaceBetween; 1397 break; 1398 case JustifySpaceAround: 1399 m_value.valueID = CSSValueSpaceAround; 1400 break; 1401 } 1402 } 1403 1404 template<> inline CSSPrimitiveValue::operator EJustifyContent() const 1405 { 1406 ASSERT(isValueID()); 1407 switch (m_value.valueID) { 1408 case CSSValueFlexStart: 1409 return JustifyFlexStart; 1410 case CSSValueFlexEnd: 1411 return JustifyFlexEnd; 1412 case CSSValueCenter: 1413 return JustifyCenter; 1414 case CSSValueSpaceBetween: 1415 return JustifySpaceBetween; 1416 case CSSValueSpaceAround: 1417 return JustifySpaceAround; 1418 default: 1419 break; 1420 } 1421 1422 ASSERT_NOT_REACHED(); 1423 return JustifyFlexStart; 1424 } 1425 1426 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e) 1427 : CSSValue(PrimitiveClass) 1428 { 1429 m_primitiveUnitType = CSS_VALUE_ID; 1430 switch (e) { 1431 case FlowRow: 1432 m_value.valueID = CSSValueRow; 1433 break; 1434 case FlowRowReverse: 1435 m_value.valueID = CSSValueRowReverse; 1436 break; 1437 case FlowColumn: 1438 m_value.valueID = CSSValueColumn; 1439 break; 1440 case FlowColumnReverse: 1441 m_value.valueID = CSSValueColumnReverse; 1442 break; 1443 } 1444 } 1445 1446 template<> inline CSSPrimitiveValue::operator EFlexDirection() const 1447 { 1448 ASSERT(isValueID()); 1449 switch (m_value.valueID) { 1450 case CSSValueRow: 1451 return FlowRow; 1452 case CSSValueRowReverse: 1453 return FlowRowReverse; 1454 case CSSValueColumn: 1455 return FlowColumn; 1456 case CSSValueColumnReverse: 1457 return FlowColumnReverse; 1458 default: 1459 break; 1460 } 1461 1462 ASSERT_NOT_REACHED(); 1463 return FlowRow; 1464 } 1465 1466 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e) 1467 : CSSValue(PrimitiveClass) 1468 { 1469 m_primitiveUnitType = CSS_VALUE_ID; 1470 switch (e) { 1471 case AlignContentFlexStart: 1472 m_value.valueID = CSSValueFlexStart; 1473 break; 1474 case AlignContentFlexEnd: 1475 m_value.valueID = CSSValueFlexEnd; 1476 break; 1477 case AlignContentCenter: 1478 m_value.valueID = CSSValueCenter; 1479 break; 1480 case AlignContentSpaceBetween: 1481 m_value.valueID = CSSValueSpaceBetween; 1482 break; 1483 case AlignContentSpaceAround: 1484 m_value.valueID = CSSValueSpaceAround; 1485 break; 1486 case AlignContentStretch: 1487 m_value.valueID = CSSValueStretch; 1488 break; 1489 } 1490 } 1491 1492 template<> inline CSSPrimitiveValue::operator EAlignContent() const 1493 { 1494 ASSERT(isValueID()); 1495 switch (m_value.valueID) { 1496 case CSSValueFlexStart: 1497 return AlignContentFlexStart; 1498 case CSSValueFlexEnd: 1499 return AlignContentFlexEnd; 1500 case CSSValueCenter: 1501 return AlignContentCenter; 1502 case CSSValueSpaceBetween: 1503 return AlignContentSpaceBetween; 1504 case CSSValueSpaceAround: 1505 return AlignContentSpaceAround; 1506 case CSSValueStretch: 1507 return AlignContentStretch; 1508 default: 1509 break; 1510 } 1511 1512 ASSERT_NOT_REACHED(); 1513 return AlignContentStretch; 1514 } 1515 1516 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e) 1517 : CSSValue(PrimitiveClass) 1518 { 1519 m_primitiveUnitType = CSS_VALUE_ID; 1520 switch (e) { 1521 case FlexNoWrap: 1522 m_value.valueID = CSSValueNowrap; 1523 break; 1524 case FlexWrap: 1525 m_value.valueID = CSSValueWrap; 1526 break; 1527 case FlexWrapReverse: 1528 m_value.valueID = CSSValueWrapReverse; 1529 break; 1530 } 1531 } 1532 1533 template<> inline CSSPrimitiveValue::operator EFlexWrap() const 1534 { 1535 ASSERT(isValueID()); 1536 switch (m_value.valueID) { 1537 case CSSValueNowrap: 1538 return FlexNoWrap; 1539 case CSSValueWrap: 1540 return FlexWrap; 1541 case CSSValueWrapReverse: 1542 return FlexWrapReverse; 1543 default: 1544 break; 1545 } 1546 1547 ASSERT_NOT_REACHED(); 1548 return FlexNoWrap; 1549 } 1550 1551 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e) 1552 : CSSValue(PrimitiveClass) 1553 { 1554 m_primitiveUnitType = CSS_VALUE_ID; 1555 switch (e) { 1556 case NoFloat: 1557 m_value.valueID = CSSValueNone; 1558 break; 1559 case LeftFloat: 1560 m_value.valueID = CSSValueLeft; 1561 break; 1562 case RightFloat: 1563 m_value.valueID = CSSValueRight; 1564 break; 1565 } 1566 } 1567 1568 template<> inline CSSPrimitiveValue::operator EFloat() const 1569 { 1570 ASSERT(isValueID()); 1571 switch (m_value.valueID) { 1572 case CSSValueLeft: 1573 return LeftFloat; 1574 case CSSValueRight: 1575 return RightFloat; 1576 case CSSValueNone: 1577 case CSSValueCenter: // Non-standard CSS value. 1578 return NoFloat; 1579 default: 1580 break; 1581 } 1582 1583 ASSERT_NOT_REACHED(); 1584 return NoFloat; 1585 } 1586 1587 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e) 1588 : CSSValue(PrimitiveClass) 1589 { 1590 m_primitiveUnitType = CSS_VALUE_ID; 1591 switch (e) { 1592 case LineBreakAuto: 1593 m_value.valueID = CSSValueAuto; 1594 break; 1595 case LineBreakLoose: 1596 m_value.valueID = CSSValueLoose; 1597 break; 1598 case LineBreakNormal: 1599 m_value.valueID = CSSValueNormal; 1600 break; 1601 case LineBreakStrict: 1602 m_value.valueID = CSSValueStrict; 1603 break; 1604 case LineBreakAfterWhiteSpace: 1605 m_value.valueID = CSSValueAfterWhiteSpace; 1606 break; 1607 } 1608 } 1609 1610 template<> inline CSSPrimitiveValue::operator LineBreak() const 1611 { 1612 ASSERT(isValueID()); 1613 switch (m_value.valueID) { 1614 case CSSValueAuto: 1615 return LineBreakAuto; 1616 case CSSValueLoose: 1617 return LineBreakLoose; 1618 case CSSValueNormal: 1619 return LineBreakNormal; 1620 case CSSValueStrict: 1621 return LineBreakStrict; 1622 case CSSValueAfterWhiteSpace: 1623 return LineBreakAfterWhiteSpace; 1624 default: 1625 break; 1626 } 1627 1628 ASSERT_NOT_REACHED(); 1629 return LineBreakAuto; 1630 } 1631 1632 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e) 1633 : CSSValue(PrimitiveClass) 1634 { 1635 m_primitiveUnitType = CSS_VALUE_ID; 1636 switch (e) { 1637 case OUTSIDE: 1638 m_value.valueID = CSSValueOutside; 1639 break; 1640 case INSIDE: 1641 m_value.valueID = CSSValueInside; 1642 break; 1643 } 1644 } 1645 1646 template<> inline CSSPrimitiveValue::operator EListStylePosition() const 1647 { 1648 ASSERT(isValueID()); 1649 switch (m_value.valueID) { 1650 case CSSValueOutside: 1651 return OUTSIDE; 1652 case CSSValueInside: 1653 return INSIDE; 1654 default: 1655 break; 1656 } 1657 1658 ASSERT_NOT_REACHED(); 1659 return OUTSIDE; 1660 } 1661 1662 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e) 1663 : CSSValue(PrimitiveClass) 1664 { 1665 m_primitiveUnitType = CSS_VALUE_ID; 1666 switch (e) { 1667 case Afar: 1668 m_value.valueID = CSSValueAfar; 1669 break; 1670 case Amharic: 1671 m_value.valueID = CSSValueAmharic; 1672 break; 1673 case AmharicAbegede: 1674 m_value.valueID = CSSValueAmharicAbegede; 1675 break; 1676 case ArabicIndic: 1677 m_value.valueID = CSSValueArabicIndic; 1678 break; 1679 case Armenian: 1680 m_value.valueID = CSSValueArmenian; 1681 break; 1682 case Asterisks: 1683 m_value.valueID = CSSValueAsterisks; 1684 break; 1685 case BinaryListStyle: 1686 m_value.valueID = CSSValueBinary; 1687 break; 1688 case Bengali: 1689 m_value.valueID = CSSValueBengali; 1690 break; 1691 case Cambodian: 1692 m_value.valueID = CSSValueCambodian; 1693 break; 1694 case Circle: 1695 m_value.valueID = CSSValueCircle; 1696 break; 1697 case CjkEarthlyBranch: 1698 m_value.valueID = CSSValueCjkEarthlyBranch; 1699 break; 1700 case CjkHeavenlyStem: 1701 m_value.valueID = CSSValueCjkHeavenlyStem; 1702 break; 1703 case CJKIdeographic: 1704 m_value.valueID = CSSValueCjkIdeographic; 1705 break; 1706 case DecimalLeadingZero: 1707 m_value.valueID = CSSValueDecimalLeadingZero; 1708 break; 1709 case DecimalListStyle: 1710 m_value.valueID = CSSValueDecimal; 1711 break; 1712 case Devanagari: 1713 m_value.valueID = CSSValueDevanagari; 1714 break; 1715 case Disc: 1716 m_value.valueID = CSSValueDisc; 1717 break; 1718 case Ethiopic: 1719 m_value.valueID = CSSValueEthiopic; 1720 break; 1721 case EthiopicAbegede: 1722 m_value.valueID = CSSValueEthiopicAbegede; 1723 break; 1724 case EthiopicAbegedeAmEt: 1725 m_value.valueID = CSSValueEthiopicAbegedeAmEt; 1726 break; 1727 case EthiopicAbegedeGez: 1728 m_value.valueID = CSSValueEthiopicAbegedeGez; 1729 break; 1730 case EthiopicAbegedeTiEr: 1731 m_value.valueID = CSSValueEthiopicAbegedeTiEr; 1732 break; 1733 case EthiopicAbegedeTiEt: 1734 m_value.valueID = CSSValueEthiopicAbegedeTiEt; 1735 break; 1736 case EthiopicHalehameAaEr: 1737 m_value.valueID = CSSValueEthiopicHalehameAaEr; 1738 break; 1739 case EthiopicHalehameAaEt: 1740 m_value.valueID = CSSValueEthiopicHalehameAaEt; 1741 break; 1742 case EthiopicHalehameAmEt: 1743 m_value.valueID = CSSValueEthiopicHalehameAmEt; 1744 break; 1745 case EthiopicHalehameGez: 1746 m_value.valueID = CSSValueEthiopicHalehameGez; 1747 break; 1748 case EthiopicHalehameOmEt: 1749 m_value.valueID = CSSValueEthiopicHalehameOmEt; 1750 break; 1751 case EthiopicHalehameSidEt: 1752 m_value.valueID = CSSValueEthiopicHalehameSidEt; 1753 break; 1754 case EthiopicHalehameSoEt: 1755 m_value.valueID = CSSValueEthiopicHalehameSoEt; 1756 break; 1757 case EthiopicHalehameTiEr: 1758 m_value.valueID = CSSValueEthiopicHalehameTiEr; 1759 break; 1760 case EthiopicHalehameTiEt: 1761 m_value.valueID = CSSValueEthiopicHalehameTiEt; 1762 break; 1763 case EthiopicHalehameTig: 1764 m_value.valueID = CSSValueEthiopicHalehameTig; 1765 break; 1766 case Footnotes: 1767 m_value.valueID = CSSValueFootnotes; 1768 break; 1769 case Georgian: 1770 m_value.valueID = CSSValueGeorgian; 1771 break; 1772 case Gujarati: 1773 m_value.valueID = CSSValueGujarati; 1774 break; 1775 case Gurmukhi: 1776 m_value.valueID = CSSValueGurmukhi; 1777 break; 1778 case Hangul: 1779 m_value.valueID = CSSValueHangul; 1780 break; 1781 case HangulConsonant: 1782 m_value.valueID = CSSValueHangulConsonant; 1783 break; 1784 case Hebrew: 1785 m_value.valueID = CSSValueHebrew; 1786 break; 1787 case Hiragana: 1788 m_value.valueID = CSSValueHiragana; 1789 break; 1790 case HiraganaIroha: 1791 m_value.valueID = CSSValueHiraganaIroha; 1792 break; 1793 case Kannada: 1794 m_value.valueID = CSSValueKannada; 1795 break; 1796 case Katakana: 1797 m_value.valueID = CSSValueKatakana; 1798 break; 1799 case KatakanaIroha: 1800 m_value.valueID = CSSValueKatakanaIroha; 1801 break; 1802 case Khmer: 1803 m_value.valueID = CSSValueKhmer; 1804 break; 1805 case Lao: 1806 m_value.valueID = CSSValueLao; 1807 break; 1808 case LowerAlpha: 1809 m_value.valueID = CSSValueLowerAlpha; 1810 break; 1811 case LowerArmenian: 1812 m_value.valueID = CSSValueLowerArmenian; 1813 break; 1814 case LowerGreek: 1815 m_value.valueID = CSSValueLowerGreek; 1816 break; 1817 case LowerHexadecimal: 1818 m_value.valueID = CSSValueLowerHexadecimal; 1819 break; 1820 case LowerLatin: 1821 m_value.valueID = CSSValueLowerLatin; 1822 break; 1823 case LowerNorwegian: 1824 m_value.valueID = CSSValueLowerNorwegian; 1825 break; 1826 case LowerRoman: 1827 m_value.valueID = CSSValueLowerRoman; 1828 break; 1829 case Malayalam: 1830 m_value.valueID = CSSValueMalayalam; 1831 break; 1832 case Mongolian: 1833 m_value.valueID = CSSValueMongolian; 1834 break; 1835 case Myanmar: 1836 m_value.valueID = CSSValueMyanmar; 1837 break; 1838 case NoneListStyle: 1839 m_value.valueID = CSSValueNone; 1840 break; 1841 case Octal: 1842 m_value.valueID = CSSValueOctal; 1843 break; 1844 case Oriya: 1845 m_value.valueID = CSSValueOriya; 1846 break; 1847 case Oromo: 1848 m_value.valueID = CSSValueOromo; 1849 break; 1850 case Persian: 1851 m_value.valueID = CSSValuePersian; 1852 break; 1853 case Sidama: 1854 m_value.valueID = CSSValueSidama; 1855 break; 1856 case Somali: 1857 m_value.valueID = CSSValueSomali; 1858 break; 1859 case Square: 1860 m_value.valueID = CSSValueSquare; 1861 break; 1862 case Telugu: 1863 m_value.valueID = CSSValueTelugu; 1864 break; 1865 case Thai: 1866 m_value.valueID = CSSValueThai; 1867 break; 1868 case Tibetan: 1869 m_value.valueID = CSSValueTibetan; 1870 break; 1871 case Tigre: 1872 m_value.valueID = CSSValueTigre; 1873 break; 1874 case TigrinyaEr: 1875 m_value.valueID = CSSValueTigrinyaEr; 1876 break; 1877 case TigrinyaErAbegede: 1878 m_value.valueID = CSSValueTigrinyaErAbegede; 1879 break; 1880 case TigrinyaEt: 1881 m_value.valueID = CSSValueTigrinyaEt; 1882 break; 1883 case TigrinyaEtAbegede: 1884 m_value.valueID = CSSValueTigrinyaEtAbegede; 1885 break; 1886 case UpperAlpha: 1887 m_value.valueID = CSSValueUpperAlpha; 1888 break; 1889 case UpperArmenian: 1890 m_value.valueID = CSSValueUpperArmenian; 1891 break; 1892 case UpperGreek: 1893 m_value.valueID = CSSValueUpperGreek; 1894 break; 1895 case UpperHexadecimal: 1896 m_value.valueID = CSSValueUpperHexadecimal; 1897 break; 1898 case UpperLatin: 1899 m_value.valueID = CSSValueUpperLatin; 1900 break; 1901 case UpperNorwegian: 1902 m_value.valueID = CSSValueUpperNorwegian; 1903 break; 1904 case UpperRoman: 1905 m_value.valueID = CSSValueUpperRoman; 1906 break; 1907 case Urdu: 1908 m_value.valueID = CSSValueUrdu; 1909 break; 1910 } 1911 } 1912 1913 template<> inline CSSPrimitiveValue::operator EListStyleType() const 1914 { 1915 ASSERT(isValueID()); 1916 switch (m_value.valueID) { 1917 case CSSValueNone: 1918 return NoneListStyle; 1919 default: 1920 return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc); 1921 } 1922 } 1923 1924 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e) 1925 : CSSValue(PrimitiveClass) 1926 { 1927 m_primitiveUnitType = CSS_VALUE_ID; 1928 switch (e) { 1929 case MCOLLAPSE: 1930 m_value.valueID = CSSValueCollapse; 1931 break; 1932 case MSEPARATE: 1933 m_value.valueID = CSSValueSeparate; 1934 break; 1935 case MDISCARD: 1936 m_value.valueID = CSSValueDiscard; 1937 break; 1938 } 1939 } 1940 1941 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const 1942 { 1943 ASSERT(isValueID()); 1944 switch (m_value.valueID) { 1945 case CSSValueCollapse: 1946 return MCOLLAPSE; 1947 case CSSValueSeparate: 1948 return MSEPARATE; 1949 case CSSValueDiscard: 1950 return MDISCARD; 1951 default: 1952 break; 1953 } 1954 1955 ASSERT_NOT_REACHED(); 1956 return MCOLLAPSE; 1957 } 1958 1959 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e) 1960 : CSSValue(PrimitiveClass) 1961 { 1962 m_primitiveUnitType = CSS_VALUE_ID; 1963 switch (e) { 1964 case MNONE: 1965 m_value.valueID = CSSValueNone; 1966 break; 1967 case MSCROLL: 1968 m_value.valueID = CSSValueScroll; 1969 break; 1970 case MSLIDE: 1971 m_value.valueID = CSSValueSlide; 1972 break; 1973 case MALTERNATE: 1974 m_value.valueID = CSSValueAlternate; 1975 break; 1976 } 1977 } 1978 1979 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const 1980 { 1981 ASSERT(isValueID()); 1982 switch (m_value.valueID) { 1983 case CSSValueNone: 1984 return MNONE; 1985 case CSSValueScroll: 1986 return MSCROLL; 1987 case CSSValueSlide: 1988 return MSLIDE; 1989 case CSSValueAlternate: 1990 return MALTERNATE; 1991 default: 1992 break; 1993 } 1994 1995 ASSERT_NOT_REACHED(); 1996 return MNONE; 1997 } 1998 1999 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e) 2000 : CSSValue(PrimitiveClass) 2001 { 2002 m_primitiveUnitType = CSS_VALUE_ID; 2003 switch (e) { 2004 case AutoRegionFragment: 2005 m_value.valueID = CSSValueAuto; 2006 break; 2007 case BreakRegionFragment: 2008 m_value.valueID = CSSValueBreak; 2009 break; 2010 } 2011 } 2012 2013 template<> inline CSSPrimitiveValue::operator RegionFragment() const 2014 { 2015 ASSERT(isValueID()); 2016 switch (m_value.valueID) { 2017 case CSSValueAuto: 2018 return AutoRegionFragment; 2019 case CSSValueBreak: 2020 return BreakRegionFragment; 2021 default: 2022 break; 2023 } 2024 2025 ASSERT_NOT_REACHED(); 2026 return AutoRegionFragment; 2027 } 2028 2029 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e) 2030 : CSSValue(PrimitiveClass) 2031 { 2032 m_primitiveUnitType = CSS_VALUE_ID; 2033 switch (e) { 2034 case MFORWARD: 2035 m_value.valueID = CSSValueForwards; 2036 break; 2037 case MBACKWARD: 2038 m_value.valueID = CSSValueBackwards; 2039 break; 2040 case MAUTO: 2041 m_value.valueID = CSSValueAuto; 2042 break; 2043 case MUP: 2044 m_value.valueID = CSSValueUp; 2045 break; 2046 case MDOWN: 2047 m_value.valueID = CSSValueDown; 2048 break; 2049 case MLEFT: 2050 m_value.valueID = CSSValueLeft; 2051 break; 2052 case MRIGHT: 2053 m_value.valueID = CSSValueRight; 2054 break; 2055 } 2056 } 2057 2058 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const 2059 { 2060 ASSERT(isValueID()); 2061 switch (m_value.valueID) { 2062 case CSSValueForwards: 2063 return MFORWARD; 2064 case CSSValueBackwards: 2065 return MBACKWARD; 2066 case CSSValueAuto: 2067 return MAUTO; 2068 case CSSValueAhead: 2069 case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP. 2070 return MUP; 2071 case CSSValueReverse: 2072 case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text. 2073 return MDOWN; 2074 case CSSValueLeft: 2075 return MLEFT; 2076 case CSSValueRight: 2077 return MRIGHT; 2078 default: 2079 break; 2080 } 2081 2082 ASSERT_NOT_REACHED(); 2083 return MAUTO; 2084 } 2085 2086 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e) 2087 : CSSValue(PrimitiveClass) 2088 { 2089 m_primitiveUnitType = CSS_VALUE_ID; 2090 switch (e) { 2091 case OVISIBLE: 2092 m_value.valueID = CSSValueVisible; 2093 break; 2094 case OHIDDEN: 2095 m_value.valueID = CSSValueHidden; 2096 break; 2097 case OSCROLL: 2098 m_value.valueID = CSSValueScroll; 2099 break; 2100 case OAUTO: 2101 m_value.valueID = CSSValueAuto; 2102 break; 2103 case OOVERLAY: 2104 m_value.valueID = CSSValueOverlay; 2105 break; 2106 case OPAGEDX: 2107 m_value.valueID = CSSValueWebkitPagedX; 2108 break; 2109 case OPAGEDY: 2110 m_value.valueID = CSSValueWebkitPagedY; 2111 break; 2112 } 2113 } 2114 2115 template<> inline CSSPrimitiveValue::operator EOverflow() const 2116 { 2117 ASSERT(isValueID()); 2118 switch (m_value.valueID) { 2119 case CSSValueVisible: 2120 return OVISIBLE; 2121 case CSSValueHidden: 2122 return OHIDDEN; 2123 case CSSValueScroll: 2124 return OSCROLL; 2125 case CSSValueAuto: 2126 return OAUTO; 2127 case CSSValueOverlay: 2128 return OOVERLAY; 2129 case CSSValueWebkitPagedX: 2130 return OPAGEDX; 2131 case CSSValueWebkitPagedY: 2132 return OPAGEDY; 2133 default: 2134 break; 2135 } 2136 2137 ASSERT_NOT_REACHED(); 2138 return OVISIBLE; 2139 } 2140 2141 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e) 2142 : CSSValue(PrimitiveClass) 2143 { 2144 m_primitiveUnitType = CSS_VALUE_ID; 2145 switch (e) { 2146 case PBAUTO: 2147 m_value.valueID = CSSValueAuto; 2148 break; 2149 case PBALWAYS: 2150 m_value.valueID = CSSValueAlways; 2151 break; 2152 case PBAVOID: 2153 m_value.valueID = CSSValueAvoid; 2154 break; 2155 } 2156 } 2157 2158 template<> inline CSSPrimitiveValue::operator EPageBreak() const 2159 { 2160 ASSERT(isValueID()); 2161 switch (m_value.valueID) { 2162 case CSSValueAuto: 2163 return PBAUTO; 2164 case CSSValueLeft: 2165 case CSSValueRight: 2166 case CSSValueAlways: 2167 return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always." 2168 case CSSValueAvoid: 2169 return PBAVOID; 2170 default: 2171 break; 2172 } 2173 2174 ASSERT_NOT_REACHED(); 2175 return PBAUTO; 2176 } 2177 2178 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e) 2179 : CSSValue(PrimitiveClass) 2180 { 2181 m_primitiveUnitType = CSS_VALUE_ID; 2182 switch (e) { 2183 case StaticPosition: 2184 m_value.valueID = CSSValueStatic; 2185 break; 2186 case RelativePosition: 2187 m_value.valueID = CSSValueRelative; 2188 break; 2189 case AbsolutePosition: 2190 m_value.valueID = CSSValueAbsolute; 2191 break; 2192 case FixedPosition: 2193 m_value.valueID = CSSValueFixed; 2194 break; 2195 case StickyPosition: 2196 m_value.valueID = CSSValueSticky; 2197 break; 2198 } 2199 } 2200 2201 template<> inline CSSPrimitiveValue::operator EPosition() const 2202 { 2203 ASSERT(isValueID()); 2204 switch (m_value.valueID) { 2205 case CSSValueStatic: 2206 return StaticPosition; 2207 case CSSValueRelative: 2208 return RelativePosition; 2209 case CSSValueAbsolute: 2210 return AbsolutePosition; 2211 case CSSValueFixed: 2212 return FixedPosition; 2213 case CSSValueSticky: 2214 return StickyPosition; 2215 default: 2216 break; 2217 } 2218 2219 ASSERT_NOT_REACHED(); 2220 return StaticPosition; 2221 } 2222 2223 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e) 2224 : CSSValue(PrimitiveClass) 2225 { 2226 m_primitiveUnitType = CSS_VALUE_ID; 2227 switch (e) { 2228 case RESIZE_BOTH: 2229 m_value.valueID = CSSValueBoth; 2230 break; 2231 case RESIZE_HORIZONTAL: 2232 m_value.valueID = CSSValueHorizontal; 2233 break; 2234 case RESIZE_VERTICAL: 2235 m_value.valueID = CSSValueVertical; 2236 break; 2237 case RESIZE_NONE: 2238 m_value.valueID = CSSValueNone; 2239 break; 2240 } 2241 } 2242 2243 template<> inline CSSPrimitiveValue::operator EResize() const 2244 { 2245 ASSERT(isValueID()); 2246 switch (m_value.valueID) { 2247 case CSSValueBoth: 2248 return RESIZE_BOTH; 2249 case CSSValueHorizontal: 2250 return RESIZE_HORIZONTAL; 2251 case CSSValueVertical: 2252 return RESIZE_VERTICAL; 2253 case CSSValueAuto: 2254 ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller. 2255 return RESIZE_NONE; 2256 case CSSValueNone: 2257 return RESIZE_NONE; 2258 default: 2259 break; 2260 } 2261 2262 ASSERT_NOT_REACHED(); 2263 return RESIZE_NONE; 2264 } 2265 2266 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e) 2267 : CSSValue(PrimitiveClass) 2268 { 2269 m_primitiveUnitType = CSS_VALUE_ID; 2270 switch (e) { 2271 case TAUTO: 2272 m_value.valueID = CSSValueAuto; 2273 break; 2274 case TFIXED: 2275 m_value.valueID = CSSValueFixed; 2276 break; 2277 } 2278 } 2279 2280 template<> inline CSSPrimitiveValue::operator ETableLayout() const 2281 { 2282 ASSERT(isValueID()); 2283 switch (m_value.valueID) { 2284 case CSSValueFixed: 2285 return TFIXED; 2286 case CSSValueAuto: 2287 return TAUTO; 2288 default: 2289 break; 2290 } 2291 2292 ASSERT_NOT_REACHED(); 2293 return TAUTO; 2294 } 2295 2296 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e) 2297 : CSSValue(PrimitiveClass) 2298 { 2299 m_primitiveUnitType = CSS_VALUE_ID; 2300 switch (e) { 2301 case TASTART: 2302 m_value.valueID = CSSValueStart; 2303 break; 2304 case TAEND: 2305 m_value.valueID = CSSValueEnd; 2306 break; 2307 case LEFT: 2308 m_value.valueID = CSSValueLeft; 2309 break; 2310 case RIGHT: 2311 m_value.valueID = CSSValueRight; 2312 break; 2313 case CENTER: 2314 m_value.valueID = CSSValueCenter; 2315 break; 2316 case JUSTIFY: 2317 m_value.valueID = CSSValueJustify; 2318 break; 2319 case WEBKIT_LEFT: 2320 m_value.valueID = CSSValueWebkitLeft; 2321 break; 2322 case WEBKIT_RIGHT: 2323 m_value.valueID = CSSValueWebkitRight; 2324 break; 2325 case WEBKIT_CENTER: 2326 m_value.valueID = CSSValueWebkitCenter; 2327 break; 2328 } 2329 } 2330 2331 template<> inline CSSPrimitiveValue::operator ETextAlign() const 2332 { 2333 ASSERT(isValueID()); 2334 switch (m_value.valueID) { 2335 case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start. 2336 case CSSValueStart: 2337 return TASTART; 2338 case CSSValueEnd: 2339 return TAEND; 2340 default: 2341 return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft); 2342 } 2343 } 2344 2345 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e) 2346 : CSSValue(PrimitiveClass) 2347 { 2348 m_primitiveUnitType = CSS_VALUE_ID; 2349 switch (e) { 2350 case TextAlignLastStart: 2351 m_value.valueID = CSSValueStart; 2352 break; 2353 case TextAlignLastEnd: 2354 m_value.valueID = CSSValueEnd; 2355 break; 2356 case TextAlignLastLeft: 2357 m_value.valueID = CSSValueLeft; 2358 break; 2359 case TextAlignLastRight: 2360 m_value.valueID = CSSValueRight; 2361 break; 2362 case TextAlignLastCenter: 2363 m_value.valueID = CSSValueCenter; 2364 break; 2365 case TextAlignLastJustify: 2366 m_value.valueID = CSSValueJustify; 2367 break; 2368 case TextAlignLastAuto: 2369 m_value.valueID = CSSValueAuto; 2370 break; 2371 } 2372 } 2373 2374 template<> inline CSSPrimitiveValue::operator TextAlignLast() const 2375 { 2376 ASSERT(isValueID()); 2377 switch (m_value.valueID) { 2378 case CSSValueAuto: 2379 return TextAlignLastAuto; 2380 case CSSValueStart: 2381 return TextAlignLastStart; 2382 case CSSValueEnd: 2383 return TextAlignLastEnd; 2384 case CSSValueLeft: 2385 return TextAlignLastLeft; 2386 case CSSValueRight: 2387 return TextAlignLastRight; 2388 case CSSValueCenter: 2389 return TextAlignLastCenter; 2390 case CSSValueJustify: 2391 return TextAlignLastJustify; 2392 default: 2393 break; 2394 } 2395 2396 ASSERT_NOT_REACHED(); 2397 return TextAlignLastAuto; 2398 } 2399 2400 template<> inline CSSPrimitiveValue::operator TextDecoration() const 2401 { 2402 ASSERT(isValueID()); 2403 switch (m_value.valueID) { 2404 case CSSValueNone: 2405 return TextDecorationNone; 2406 case CSSValueUnderline: 2407 return TextDecorationUnderline; 2408 case CSSValueOverline: 2409 return TextDecorationOverline; 2410 case CSSValueLineThrough: 2411 return TextDecorationLineThrough; 2412 case CSSValueBlink: 2413 return TextDecorationBlink; 2414 default: 2415 break; 2416 } 2417 2418 ASSERT_NOT_REACHED(); 2419 return TextDecorationNone; 2420 } 2421 2422 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const 2423 { 2424 ASSERT(isValueID()); 2425 switch (m_value.valueID) { 2426 case CSSValueSolid: 2427 return TextDecorationStyleSolid; 2428 case CSSValueDouble: 2429 return TextDecorationStyleDouble; 2430 case CSSValueDotted: 2431 return TextDecorationStyleDotted; 2432 case CSSValueDashed: 2433 return TextDecorationStyleDashed; 2434 case CSSValueWavy: 2435 return TextDecorationStyleWavy; 2436 default: 2437 break; 2438 } 2439 2440 ASSERT_NOT_REACHED(); 2441 return TextDecorationStyleSolid; 2442 } 2443 2444 #if ENABLE(CSS3_TEXT) 2445 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e) 2446 : CSSValue(PrimitiveClass) 2447 { 2448 m_primitiveUnitType = CSS_VALUE_ID; 2449 switch (e) { 2450 case TextUnderlinePositionAuto: 2451 m_value.valueID = CSSValueAuto; 2452 break; 2453 case TextUnderlinePositionAlphabetic: 2454 m_value.valueID = CSSValueAlphabetic; 2455 break; 2456 case TextUnderlinePositionUnder: 2457 m_value.valueID = CSSValueUnder; 2458 break; 2459 } 2460 2461 // FIXME: Implement support for 'under left' and 'under right' values. 2462 } 2463 2464 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const 2465 { 2466 ASSERT(isValueID()); 2467 switch (m_value.valueID) { 2468 case CSSValueAuto: 2469 return TextUnderlinePositionAuto; 2470 case CSSValueAlphabetic: 2471 return TextUnderlinePositionAlphabetic; 2472 case CSSValueUnder: 2473 return TextUnderlinePositionUnder; 2474 default: 2475 break; 2476 } 2477 2478 // FIXME: Implement support for 'under left' and 'under right' values. 2479 2480 ASSERT_NOT_REACHED(); 2481 return TextUnderlinePositionAuto; 2482 } 2483 #endif // CSS3_TEXT 2484 2485 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e) 2486 : CSSValue(PrimitiveClass) 2487 { 2488 m_primitiveUnitType = CSS_VALUE_ID; 2489 switch (e) { 2490 case TSNONE: 2491 m_value.valueID = CSSValueNone; 2492 break; 2493 case TSDISC: 2494 m_value.valueID = CSSValueDisc; 2495 break; 2496 case TSCIRCLE: 2497 m_value.valueID = CSSValueCircle; 2498 break; 2499 case TSSQUARE: 2500 m_value.valueID = CSSValueSquare; 2501 break; 2502 } 2503 } 2504 2505 template<> inline CSSPrimitiveValue::operator ETextSecurity() const 2506 { 2507 ASSERT(isValueID()); 2508 switch (m_value.valueID) { 2509 case CSSValueNone: 2510 return TSNONE; 2511 case CSSValueDisc: 2512 return TSDISC; 2513 case CSSValueCircle: 2514 return TSCIRCLE; 2515 case CSSValueSquare: 2516 return TSSQUARE; 2517 default: 2518 break; 2519 } 2520 2521 ASSERT_NOT_REACHED(); 2522 return TSNONE; 2523 } 2524 2525 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e) 2526 : CSSValue(PrimitiveClass) 2527 { 2528 m_primitiveUnitType = CSS_VALUE_ID; 2529 switch (e) { 2530 case CAPITALIZE: 2531 m_value.valueID = CSSValueCapitalize; 2532 break; 2533 case UPPERCASE: 2534 m_value.valueID = CSSValueUppercase; 2535 break; 2536 case LOWERCASE: 2537 m_value.valueID = CSSValueLowercase; 2538 break; 2539 case TTNONE: 2540 m_value.valueID = CSSValueNone; 2541 break; 2542 } 2543 } 2544 2545 template<> inline CSSPrimitiveValue::operator ETextTransform() const 2546 { 2547 ASSERT(isValueID()); 2548 switch (m_value.valueID) { 2549 case CSSValueCapitalize: 2550 return CAPITALIZE; 2551 case CSSValueUppercase: 2552 return UPPERCASE; 2553 case CSSValueLowercase: 2554 return LOWERCASE; 2555 case CSSValueNone: 2556 return TTNONE; 2557 default: 2558 break; 2559 } 2560 2561 ASSERT_NOT_REACHED(); 2562 return TTNONE; 2563 } 2564 2565 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e) 2566 : CSSValue(PrimitiveClass) 2567 { 2568 m_primitiveUnitType = CSS_VALUE_ID; 2569 switch (e) { 2570 case UBNormal: 2571 m_value.valueID = CSSValueNormal; 2572 break; 2573 case Embed: 2574 m_value.valueID = CSSValueEmbed; 2575 break; 2576 case Override: 2577 m_value.valueID = CSSValueBidiOverride; 2578 break; 2579 case Isolate: 2580 m_value.valueID = CSSValueWebkitIsolate; 2581 break; 2582 case IsolateOverride: 2583 m_value.valueID = CSSValueWebkitIsolateOverride; 2584 break; 2585 case Plaintext: 2586 m_value.valueID = CSSValueWebkitPlaintext; 2587 break; 2588 } 2589 } 2590 2591 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const 2592 { 2593 ASSERT(isValueID()); 2594 switch (m_value.valueID) { 2595 case CSSValueNormal: 2596 return UBNormal; 2597 case CSSValueEmbed: 2598 return Embed; 2599 case CSSValueBidiOverride: 2600 return Override; 2601 case CSSValueWebkitIsolate: 2602 return Isolate; 2603 case CSSValueWebkitIsolateOverride: 2604 return IsolateOverride; 2605 case CSSValueWebkitPlaintext: 2606 return Plaintext; 2607 default: 2608 break; 2609 } 2610 2611 ASSERT_NOT_REACHED(); 2612 return UBNormal; 2613 } 2614 2615 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e) 2616 : CSSValue(PrimitiveClass) 2617 { 2618 m_primitiveUnitType = CSS_VALUE_ID; 2619 switch (e) { 2620 case DRAG_AUTO: 2621 m_value.valueID = CSSValueAuto; 2622 break; 2623 case DRAG_NONE: 2624 m_value.valueID = CSSValueNone; 2625 break; 2626 case DRAG_ELEMENT: 2627 m_value.valueID = CSSValueElement; 2628 break; 2629 default: 2630 break; 2631 } 2632 } 2633 2634 template<> inline CSSPrimitiveValue::operator EUserDrag() const 2635 { 2636 ASSERT(isValueID()); 2637 switch (m_value.valueID) { 2638 case CSSValueAuto: 2639 return DRAG_AUTO; 2640 case CSSValueNone: 2641 return DRAG_NONE; 2642 case CSSValueElement: 2643 return DRAG_ELEMENT; 2644 default: 2645 break; 2646 } 2647 2648 ASSERT_NOT_REACHED(); 2649 return DRAG_AUTO; 2650 } 2651 2652 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e) 2653 : CSSValue(PrimitiveClass) 2654 { 2655 m_primitiveUnitType = CSS_VALUE_ID; 2656 switch (e) { 2657 case READ_ONLY: 2658 m_value.valueID = CSSValueReadOnly; 2659 break; 2660 case READ_WRITE: 2661 m_value.valueID = CSSValueReadWrite; 2662 break; 2663 case READ_WRITE_PLAINTEXT_ONLY: 2664 m_value.valueID = CSSValueReadWritePlaintextOnly; 2665 break; 2666 } 2667 } 2668 2669 template<> inline CSSPrimitiveValue::operator EUserModify() const 2670 { 2671 ASSERT(isValueID()); 2672 switch (m_value.valueID) { 2673 case CSSValueReadOnly: 2674 return READ_ONLY; 2675 case CSSValueReadWrite: 2676 return READ_WRITE; 2677 case CSSValueReadWritePlaintextOnly: 2678 return READ_WRITE_PLAINTEXT_ONLY; 2679 default: 2680 break; 2681 } 2682 2683 ASSERT_NOT_REACHED(); 2684 return READ_ONLY; 2685 } 2686 2687 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e) 2688 : CSSValue(PrimitiveClass) 2689 { 2690 m_primitiveUnitType = CSS_VALUE_ID; 2691 switch (e) { 2692 case SELECT_NONE: 2693 m_value.valueID = CSSValueNone; 2694 break; 2695 case SELECT_TEXT: 2696 m_value.valueID = CSSValueText; 2697 break; 2698 case SELECT_ALL: 2699 m_value.valueID = CSSValueAll; 2700 break; 2701 } 2702 } 2703 2704 template<> inline CSSPrimitiveValue::operator EUserSelect() const 2705 { 2706 ASSERT(isValueID()); 2707 switch (m_value.valueID) { 2708 case CSSValueAuto: 2709 return SELECT_TEXT; 2710 case CSSValueNone: 2711 return SELECT_NONE; 2712 case CSSValueText: 2713 return SELECT_TEXT; 2714 case CSSValueAll: 2715 return SELECT_ALL; 2716 default: 2717 break; 2718 } 2719 2720 ASSERT_NOT_REACHED(); 2721 return SELECT_TEXT; 2722 } 2723 2724 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a) 2725 : CSSValue(PrimitiveClass) 2726 { 2727 m_primitiveUnitType = CSS_VALUE_ID; 2728 switch (a) { 2729 case TOP: 2730 m_value.valueID = CSSValueTop; 2731 break; 2732 case BOTTOM: 2733 m_value.valueID = CSSValueBottom; 2734 break; 2735 case MIDDLE: 2736 m_value.valueID = CSSValueMiddle; 2737 break; 2738 case BASELINE: 2739 m_value.valueID = CSSValueBaseline; 2740 break; 2741 case TEXT_BOTTOM: 2742 m_value.valueID = CSSValueTextBottom; 2743 break; 2744 case TEXT_TOP: 2745 m_value.valueID = CSSValueTextTop; 2746 break; 2747 case SUB: 2748 m_value.valueID = CSSValueSub; 2749 break; 2750 case SUPER: 2751 m_value.valueID = CSSValueSuper; 2752 break; 2753 case BASELINE_MIDDLE: 2754 m_value.valueID = CSSValueWebkitBaselineMiddle; 2755 break; 2756 case LENGTH: 2757 m_value.valueID = CSSValueInvalid; 2758 } 2759 } 2760 2761 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const 2762 { 2763 ASSERT(isValueID()); 2764 switch (m_value.valueID) { 2765 case CSSValueTop: 2766 return TOP; 2767 case CSSValueBottom: 2768 return BOTTOM; 2769 case CSSValueMiddle: 2770 return MIDDLE; 2771 case CSSValueBaseline: 2772 return BASELINE; 2773 case CSSValueTextBottom: 2774 return TEXT_BOTTOM; 2775 case CSSValueTextTop: 2776 return TEXT_TOP; 2777 case CSSValueSub: 2778 return SUB; 2779 case CSSValueSuper: 2780 return SUPER; 2781 case CSSValueWebkitBaselineMiddle: 2782 return BASELINE_MIDDLE; 2783 default: 2784 break; 2785 } 2786 2787 ASSERT_NOT_REACHED(); 2788 return TOP; 2789 } 2790 2791 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e) 2792 : CSSValue(PrimitiveClass) 2793 { 2794 m_primitiveUnitType = CSS_VALUE_ID; 2795 switch (e) { 2796 case VISIBLE: 2797 m_value.valueID = CSSValueVisible; 2798 break; 2799 case HIDDEN: 2800 m_value.valueID = CSSValueHidden; 2801 break; 2802 case COLLAPSE: 2803 m_value.valueID = CSSValueCollapse; 2804 break; 2805 } 2806 } 2807 2808 template<> inline CSSPrimitiveValue::operator EVisibility() const 2809 { 2810 ASSERT(isValueID()); 2811 switch (m_value.valueID) { 2812 case CSSValueHidden: 2813 return HIDDEN; 2814 case CSSValueVisible: 2815 return VISIBLE; 2816 case CSSValueCollapse: 2817 return COLLAPSE; 2818 default: 2819 break; 2820 } 2821 2822 ASSERT_NOT_REACHED(); 2823 return VISIBLE; 2824 } 2825 2826 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e) 2827 : CSSValue(PrimitiveClass) 2828 { 2829 m_primitiveUnitType = CSS_VALUE_ID; 2830 switch (e) { 2831 case NORMAL: 2832 m_value.valueID = CSSValueNormal; 2833 break; 2834 case PRE: 2835 m_value.valueID = CSSValuePre; 2836 break; 2837 case PRE_WRAP: 2838 m_value.valueID = CSSValuePreWrap; 2839 break; 2840 case PRE_LINE: 2841 m_value.valueID = CSSValuePreLine; 2842 break; 2843 case NOWRAP: 2844 m_value.valueID = CSSValueNowrap; 2845 break; 2846 case KHTML_NOWRAP: 2847 m_value.valueID = CSSValueWebkitNowrap; 2848 break; 2849 } 2850 } 2851 2852 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const 2853 { 2854 ASSERT(isValueID()); 2855 switch (m_value.valueID) { 2856 case CSSValueWebkitNowrap: 2857 return KHTML_NOWRAP; 2858 case CSSValueNowrap: 2859 return NOWRAP; 2860 case CSSValuePre: 2861 return PRE; 2862 case CSSValuePreWrap: 2863 return PRE_WRAP; 2864 case CSSValuePreLine: 2865 return PRE_LINE; 2866 case CSSValueNormal: 2867 return NORMAL; 2868 default: 2869 break; 2870 } 2871 2872 ASSERT_NOT_REACHED(); 2873 return NORMAL; 2874 } 2875 2876 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e) 2877 : CSSValue(PrimitiveClass) 2878 { 2879 m_primitiveUnitType = CSS_VALUE_ID; 2880 switch (e) { 2881 case NormalWordBreak: 2882 m_value.valueID = CSSValueNormal; 2883 break; 2884 case BreakAllWordBreak: 2885 m_value.valueID = CSSValueBreakAll; 2886 break; 2887 case BreakWordBreak: 2888 m_value.valueID = CSSValueBreakWord; 2889 break; 2890 } 2891 } 2892 2893 template<> inline CSSPrimitiveValue::operator EWordBreak() const 2894 { 2895 ASSERT(isValueID()); 2896 switch (m_value.valueID) { 2897 case CSSValueBreakAll: 2898 return BreakAllWordBreak; 2899 case CSSValueBreakWord: 2900 return BreakWordBreak; 2901 case CSSValueNormal: 2902 return NormalWordBreak; 2903 default: 2904 break; 2905 } 2906 2907 ASSERT_NOT_REACHED(); 2908 return NormalWordBreak; 2909 } 2910 2911 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e) 2912 : CSSValue(PrimitiveClass) 2913 { 2914 m_primitiveUnitType = CSS_VALUE_ID; 2915 switch (e) { 2916 case NormalOverflowWrap: 2917 m_value.valueID = CSSValueNormal; 2918 break; 2919 case BreakOverflowWrap: 2920 m_value.valueID = CSSValueBreakWord; 2921 break; 2922 } 2923 } 2924 2925 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const 2926 { 2927 ASSERT(isValueID()); 2928 switch (m_value.valueID) { 2929 case CSSValueBreakWord: 2930 return BreakOverflowWrap; 2931 case CSSValueNormal: 2932 return NormalOverflowWrap; 2933 default: 2934 break; 2935 } 2936 2937 ASSERT_NOT_REACHED(); 2938 return NormalOverflowWrap; 2939 } 2940 2941 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e) 2942 : CSSValue(PrimitiveClass) 2943 { 2944 m_primitiveUnitType = CSS_VALUE_ID; 2945 switch (e) { 2946 case LTR: 2947 m_value.valueID = CSSValueLtr; 2948 break; 2949 case RTL: 2950 m_value.valueID = CSSValueRtl; 2951 break; 2952 } 2953 } 2954 2955 template<> inline CSSPrimitiveValue::operator TextDirection() const 2956 { 2957 ASSERT(isValueID()); 2958 switch (m_value.valueID) { 2959 case CSSValueLtr: 2960 return LTR; 2961 case CSSValueRtl: 2962 return RTL; 2963 default: 2964 break; 2965 } 2966 2967 ASSERT_NOT_REACHED(); 2968 return LTR; 2969 } 2970 2971 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e) 2972 : CSSValue(PrimitiveClass) 2973 { 2974 m_primitiveUnitType = CSS_VALUE_ID; 2975 switch (e) { 2976 case TopToBottomWritingMode: 2977 m_value.valueID = CSSValueHorizontalTb; 2978 break; 2979 case RightToLeftWritingMode: 2980 m_value.valueID = CSSValueVerticalRl; 2981 break; 2982 case LeftToRightWritingMode: 2983 m_value.valueID = CSSValueVerticalLr; 2984 break; 2985 case BottomToTopWritingMode: 2986 m_value.valueID = CSSValueHorizontalBt; 2987 break; 2988 } 2989 } 2990 2991 template<> inline CSSPrimitiveValue::operator WritingMode() const 2992 { 2993 ASSERT(isValueID()); 2994 switch (m_value.valueID) { 2995 case CSSValueHorizontalTb: 2996 return TopToBottomWritingMode; 2997 case CSSValueVerticalRl: 2998 return RightToLeftWritingMode; 2999 case CSSValueVerticalLr: 3000 return LeftToRightWritingMode; 3001 case CSSValueHorizontalBt: 3002 return BottomToTopWritingMode; 3003 default: 3004 break; 3005 } 3006 3007 ASSERT_NOT_REACHED(); 3008 return TopToBottomWritingMode; 3009 } 3010 3011 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e) 3012 : CSSValue(PrimitiveClass) 3013 { 3014 m_primitiveUnitType = CSS_VALUE_ID; 3015 switch (e) { 3016 case TextCombineNone: 3017 m_value.valueID = CSSValueNone; 3018 break; 3019 case TextCombineHorizontal: 3020 m_value.valueID = CSSValueHorizontal; 3021 break; 3022 } 3023 } 3024 3025 template<> inline CSSPrimitiveValue::operator TextCombine() const 3026 { 3027 ASSERT(isValueID()); 3028 switch (m_value.valueID) { 3029 case CSSValueNone: 3030 return TextCombineNone; 3031 case CSSValueHorizontal: 3032 return TextCombineHorizontal; 3033 default: 3034 break; 3035 } 3036 3037 ASSERT_NOT_REACHED(); 3038 return TextCombineNone; 3039 } 3040 3041 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position) 3042 : CSSValue(PrimitiveClass) 3043 { 3044 m_primitiveUnitType = CSS_VALUE_ID; 3045 switch (position) { 3046 case RubyPositionBefore: 3047 m_value.valueID = CSSValueBefore; 3048 break; 3049 case RubyPositionAfter: 3050 m_value.valueID = CSSValueAfter; 3051 break; 3052 } 3053 } 3054 3055 template<> inline CSSPrimitiveValue::operator RubyPosition() const 3056 { 3057 ASSERT(isValueID()); 3058 switch (m_value.valueID) { 3059 case CSSValueBefore: 3060 return RubyPositionBefore; 3061 case CSSValueAfter: 3062 return RubyPositionAfter; 3063 default: 3064 break; 3065 } 3066 3067 ASSERT_NOT_REACHED(); 3068 return RubyPositionBefore; 3069 } 3070 3071 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position) 3072 : CSSValue(PrimitiveClass) 3073 { 3074 m_primitiveUnitType = CSS_VALUE_ID; 3075 switch (position) { 3076 case TextEmphasisPositionOver: 3077 m_value.valueID = CSSValueOver; 3078 break; 3079 case TextEmphasisPositionUnder: 3080 m_value.valueID = CSSValueUnder; 3081 break; 3082 } 3083 } 3084 3085 template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const 3086 { 3087 ASSERT(isValueID()); 3088 switch (m_value.valueID) { 3089 case CSSValueOver: 3090 return TextEmphasisPositionOver; 3091 case CSSValueUnder: 3092 return TextEmphasisPositionUnder; 3093 default: 3094 break; 3095 } 3096 3097 ASSERT_NOT_REACHED(); 3098 return TextEmphasisPositionOver; 3099 } 3100 3101 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow) 3102 : CSSValue(PrimitiveClass) 3103 { 3104 m_primitiveUnitType = CSS_VALUE_ID; 3105 switch (overflow) { 3106 case TextOverflowClip: 3107 m_value.valueID = CSSValueClip; 3108 break; 3109 case TextOverflowEllipsis: 3110 m_value.valueID = CSSValueEllipsis; 3111 break; 3112 } 3113 } 3114 3115 template<> inline CSSPrimitiveValue::operator TextOverflow() const 3116 { 3117 ASSERT(isValueID()); 3118 switch (m_value.valueID) { 3119 case CSSValueClip: 3120 return TextOverflowClip; 3121 case CSSValueEllipsis: 3122 return TextOverflowEllipsis; 3123 default: 3124 break; 3125 } 3126 3127 ASSERT_NOT_REACHED(); 3128 return TextOverflowClip; 3129 } 3130 3131 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill) 3132 : CSSValue(PrimitiveClass) 3133 { 3134 m_primitiveUnitType = CSS_VALUE_ID; 3135 switch (fill) { 3136 case TextEmphasisFillFilled: 3137 m_value.valueID = CSSValueFilled; 3138 break; 3139 case TextEmphasisFillOpen: 3140 m_value.valueID = CSSValueOpen; 3141 break; 3142 } 3143 } 3144 3145 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const 3146 { 3147 ASSERT(isValueID()); 3148 switch (m_value.valueID) { 3149 case CSSValueFilled: 3150 return TextEmphasisFillFilled; 3151 case CSSValueOpen: 3152 return TextEmphasisFillOpen; 3153 default: 3154 break; 3155 } 3156 3157 ASSERT_NOT_REACHED(); 3158 return TextEmphasisFillFilled; 3159 } 3160 3161 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark) 3162 : CSSValue(PrimitiveClass) 3163 { 3164 m_primitiveUnitType = CSS_VALUE_ID; 3165 switch (mark) { 3166 case TextEmphasisMarkDot: 3167 m_value.valueID = CSSValueDot; 3168 break; 3169 case TextEmphasisMarkCircle: 3170 m_value.valueID = CSSValueCircle; 3171 break; 3172 case TextEmphasisMarkDoubleCircle: 3173 m_value.valueID = CSSValueDoubleCircle; 3174 break; 3175 case TextEmphasisMarkTriangle: 3176 m_value.valueID = CSSValueTriangle; 3177 break; 3178 case TextEmphasisMarkSesame: 3179 m_value.valueID = CSSValueSesame; 3180 break; 3181 case TextEmphasisMarkNone: 3182 case TextEmphasisMarkAuto: 3183 case TextEmphasisMarkCustom: 3184 ASSERT_NOT_REACHED(); 3185 m_value.valueID = CSSValueNone; 3186 break; 3187 } 3188 } 3189 3190 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const 3191 { 3192 ASSERT(isValueID()); 3193 switch (m_value.valueID) { 3194 case CSSValueNone: 3195 return TextEmphasisMarkNone; 3196 case CSSValueDot: 3197 return TextEmphasisMarkDot; 3198 case CSSValueCircle: 3199 return TextEmphasisMarkCircle; 3200 case CSSValueDoubleCircle: 3201 return TextEmphasisMarkDoubleCircle; 3202 case CSSValueTriangle: 3203 return TextEmphasisMarkTriangle; 3204 case CSSValueSesame: 3205 return TextEmphasisMarkSesame; 3206 default: 3207 break; 3208 } 3209 3210 ASSERT_NOT_REACHED(); 3211 return TextEmphasisMarkNone; 3212 } 3213 3214 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e) 3215 : CSSValue(PrimitiveClass) 3216 { 3217 m_primitiveUnitType = CSS_VALUE_ID; 3218 switch (e) { 3219 case TextOrientationSideways: 3220 m_value.valueID = CSSValueSideways; 3221 break; 3222 case TextOrientationSidewaysRight: 3223 m_value.valueID = CSSValueSidewaysRight; 3224 break; 3225 case TextOrientationVerticalRight: 3226 m_value.valueID = CSSValueVerticalRight; 3227 break; 3228 case TextOrientationUpright: 3229 m_value.valueID = CSSValueUpright; 3230 break; 3231 } 3232 } 3233 3234 template<> inline CSSPrimitiveValue::operator TextOrientation() const 3235 { 3236 ASSERT(isValueID()); 3237 switch (m_value.valueID) { 3238 case CSSValueSideways: 3239 return TextOrientationSideways; 3240 case CSSValueSidewaysRight: 3241 return TextOrientationSidewaysRight; 3242 case CSSValueVerticalRight: 3243 return TextOrientationVerticalRight; 3244 case CSSValueUpright: 3245 return TextOrientationUpright; 3246 default: 3247 break; 3248 } 3249 3250 ASSERT_NOT_REACHED(); 3251 return TextOrientationVerticalRight; 3252 } 3253 3254 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e) 3255 : CSSValue(PrimitiveClass) 3256 { 3257 m_primitiveUnitType = CSS_VALUE_ID; 3258 switch (e) { 3259 case PE_NONE: 3260 m_value.valueID = CSSValueNone; 3261 break; 3262 case PE_STROKE: 3263 m_value.valueID = CSSValueStroke; 3264 break; 3265 case PE_FILL: 3266 m_value.valueID = CSSValueFill; 3267 break; 3268 case PE_PAINTED: 3269 m_value.valueID = CSSValuePainted; 3270 break; 3271 case PE_VISIBLE: 3272 m_value.valueID = CSSValueVisible; 3273 break; 3274 case PE_VISIBLE_STROKE: 3275 m_value.valueID = CSSValueVisiblestroke; 3276 break; 3277 case PE_VISIBLE_FILL: 3278 m_value.valueID = CSSValueVisiblefill; 3279 break; 3280 case PE_VISIBLE_PAINTED: 3281 m_value.valueID = CSSValueVisiblepainted; 3282 break; 3283 case PE_AUTO: 3284 m_value.valueID = CSSValueAuto; 3285 break; 3286 case PE_ALL: 3287 m_value.valueID = CSSValueAll; 3288 break; 3289 } 3290 } 3291 3292 template<> inline CSSPrimitiveValue::operator EPointerEvents() const 3293 { 3294 ASSERT(isValueID()); 3295 switch (m_value.valueID) { 3296 case CSSValueAll: 3297 return PE_ALL; 3298 case CSSValueAuto: 3299 return PE_AUTO; 3300 case CSSValueNone: 3301 return PE_NONE; 3302 case CSSValueVisiblepainted: 3303 return PE_VISIBLE_PAINTED; 3304 case CSSValueVisiblefill: 3305 return PE_VISIBLE_FILL; 3306 case CSSValueVisiblestroke: 3307 return PE_VISIBLE_STROKE; 3308 case CSSValueVisible: 3309 return PE_VISIBLE; 3310 case CSSValuePainted: 3311 return PE_PAINTED; 3312 case CSSValueFill: 3313 return PE_FILL; 3314 case CSSValueStroke: 3315 return PE_STROKE; 3316 default: 3317 break; 3318 } 3319 3320 ASSERT_NOT_REACHED(); 3321 return PE_ALL; 3322 } 3323 3324 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning) 3325 : CSSValue(PrimitiveClass) 3326 { 3327 m_primitiveUnitType = CSS_VALUE_ID; 3328 switch (kerning) { 3329 case FontDescription::AutoKerning: 3330 m_value.valueID = CSSValueAuto; 3331 return; 3332 case FontDescription::NormalKerning: 3333 m_value.valueID = CSSValueNormal; 3334 return; 3335 case FontDescription::NoneKerning: 3336 m_value.valueID = CSSValueNone; 3337 return; 3338 } 3339 3340 ASSERT_NOT_REACHED(); 3341 m_value.valueID = CSSValueAuto; 3342 } 3343 3344 template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const 3345 { 3346 ASSERT(isValueID()); 3347 switch (m_value.valueID) { 3348 case CSSValueAuto: 3349 return FontDescription::AutoKerning; 3350 case CSSValueNormal: 3351 return FontDescription::NormalKerning; 3352 case CSSValueNone: 3353 return FontDescription::NoneKerning; 3354 default: 3355 break; 3356 } 3357 3358 ASSERT_NOT_REACHED(); 3359 return FontDescription::AutoKerning; 3360 } 3361 3362 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing) 3363 : CSSValue(PrimitiveClass) 3364 { 3365 m_primitiveUnitType = CSS_VALUE_ID; 3366 switch (smoothing) { 3367 case AutoSmoothing: 3368 m_value.valueID = CSSValueAuto; 3369 return; 3370 case NoSmoothing: 3371 m_value.valueID = CSSValueNone; 3372 return; 3373 case Antialiased: 3374 m_value.valueID = CSSValueAntialiased; 3375 return; 3376 case SubpixelAntialiased: 3377 m_value.valueID = CSSValueSubpixelAntialiased; 3378 return; 3379 } 3380 3381 ASSERT_NOT_REACHED(); 3382 m_value.valueID = CSSValueAuto; 3383 } 3384 3385 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const 3386 { 3387 ASSERT(isValueID()); 3388 switch (m_value.valueID) { 3389 case CSSValueAuto: 3390 return AutoSmoothing; 3391 case CSSValueNone: 3392 return NoSmoothing; 3393 case CSSValueAntialiased: 3394 return Antialiased; 3395 case CSSValueSubpixelAntialiased: 3396 return SubpixelAntialiased; 3397 default: 3398 break; 3399 } 3400 3401 ASSERT_NOT_REACHED(); 3402 return AutoSmoothing; 3403 } 3404 3405 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight) 3406 : CSSValue(PrimitiveClass) 3407 { 3408 m_primitiveUnitType = CSS_VALUE_ID; 3409 switch (weight) { 3410 case FontWeight900: 3411 m_value.valueID = CSSValue900; 3412 return; 3413 case FontWeight800: 3414 m_value.valueID = CSSValue800; 3415 return; 3416 case FontWeight700: 3417 m_value.valueID = CSSValue700; 3418 return; 3419 case FontWeight600: 3420 m_value.valueID = CSSValue600; 3421 return; 3422 case FontWeight500: 3423 m_value.valueID = CSSValue500; 3424 return; 3425 case FontWeight400: 3426 m_value.valueID = CSSValue400; 3427 return; 3428 case FontWeight300: 3429 m_value.valueID = CSSValue300; 3430 return; 3431 case FontWeight200: 3432 m_value.valueID = CSSValue200; 3433 return; 3434 case FontWeight100: 3435 m_value.valueID = CSSValue100; 3436 return; 3437 } 3438 3439 ASSERT_NOT_REACHED(); 3440 m_value.valueID = CSSValueNormal; 3441 } 3442 3443 template<> inline CSSPrimitiveValue::operator FontWeight() const 3444 { 3445 ASSERT(isValueID()); 3446 switch (m_value.valueID) { 3447 case CSSValueBold: 3448 return FontWeightBold; 3449 case CSSValueNormal: 3450 return FontWeightNormal; 3451 case CSSValue900: 3452 return FontWeight900; 3453 case CSSValue800: 3454 return FontWeight800; 3455 case CSSValue700: 3456 return FontWeight700; 3457 case CSSValue600: 3458 return FontWeight600; 3459 case CSSValue500: 3460 return FontWeight500; 3461 case CSSValue400: 3462 return FontWeight400; 3463 case CSSValue300: 3464 return FontWeight300; 3465 case CSSValue200: 3466 return FontWeight200; 3467 case CSSValue100: 3468 return FontWeight100; 3469 default: 3470 break; 3471 } 3472 3473 ASSERT_NOT_REACHED(); 3474 return FontWeightNormal; 3475 } 3476 3477 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic) 3478 : CSSValue(PrimitiveClass) 3479 { 3480 m_primitiveUnitType = CSS_VALUE_ID; 3481 switch (italic) { 3482 case FontItalicOff: 3483 m_value.valueID = CSSValueNormal; 3484 return; 3485 case FontItalicOn: 3486 m_value.valueID = CSSValueItalic; 3487 return; 3488 } 3489 3490 ASSERT_NOT_REACHED(); 3491 m_value.valueID = CSSValueNormal; 3492 } 3493 3494 template<> inline CSSPrimitiveValue::operator FontItalic() const 3495 { 3496 ASSERT(isValueID()); 3497 switch (m_value.valueID) { 3498 case CSSValueOblique: 3499 // FIXME: oblique is the same as italic for the moment... 3500 case CSSValueItalic: 3501 return FontItalicOn; 3502 case CSSValueNormal: 3503 return FontItalicOff; 3504 default: 3505 break; 3506 } 3507 ASSERT_NOT_REACHED(); 3508 return FontItalicOff; 3509 } 3510 3511 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps) 3512 : CSSValue(PrimitiveClass) 3513 { 3514 m_primitiveUnitType = CSS_VALUE_ID; 3515 switch (smallCaps) { 3516 case FontSmallCapsOff: 3517 m_value.valueID = CSSValueNormal; 3518 return; 3519 case FontSmallCapsOn: 3520 m_value.valueID = CSSValueSmallCaps; 3521 return; 3522 } 3523 3524 ASSERT_NOT_REACHED(); 3525 m_value.valueID = CSSValueNormal; 3526 } 3527 3528 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const 3529 { 3530 ASSERT(isValueID()); 3531 switch (m_value.valueID) { 3532 case CSSValueSmallCaps: 3533 return FontSmallCapsOn; 3534 case CSSValueNormal: 3535 return FontSmallCapsOff; 3536 default: 3537 break; 3538 } 3539 ASSERT_NOT_REACHED(); 3540 return FontSmallCapsOff; 3541 } 3542 3543 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e) 3544 : CSSValue(PrimitiveClass) 3545 { 3546 m_primitiveUnitType = CSS_VALUE_ID; 3547 switch (e) { 3548 case AutoTextRendering: 3549 m_value.valueID = CSSValueAuto; 3550 break; 3551 case OptimizeSpeed: 3552 m_value.valueID = CSSValueOptimizespeed; 3553 break; 3554 case OptimizeLegibility: 3555 m_value.valueID = CSSValueOptimizelegibility; 3556 break; 3557 case GeometricPrecision: 3558 m_value.valueID = CSSValueGeometricprecision; 3559 break; 3560 } 3561 } 3562 3563 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const 3564 { 3565 ASSERT(isValueID()); 3566 switch (m_value.valueID) { 3567 case CSSValueAuto: 3568 return AutoTextRendering; 3569 case CSSValueOptimizespeed: 3570 return OptimizeSpeed; 3571 case CSSValueOptimizelegibility: 3572 return OptimizeLegibility; 3573 case CSSValueGeometricprecision: 3574 return GeometricPrecision; 3575 default: 3576 break; 3577 } 3578 3579 ASSERT_NOT_REACHED(); 3580 return AutoTextRendering; 3581 } 3582 3583 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap) 3584 : CSSValue(PrimitiveClass) 3585 { 3586 m_primitiveUnitType = CSS_VALUE_ID; 3587 switch (gridSnap) { 3588 case LineSnapNone: 3589 m_value.valueID = CSSValueNone; 3590 break; 3591 case LineSnapBaseline: 3592 m_value.valueID = CSSValueBaseline; 3593 break; 3594 case LineSnapContain: 3595 m_value.valueID = CSSValueContain; 3596 break; 3597 } 3598 } 3599 3600 template<> inline CSSPrimitiveValue::operator LineSnap() const 3601 { 3602 ASSERT(isValueID()); 3603 switch (m_value.valueID) { 3604 case CSSValueNone: 3605 return LineSnapNone; 3606 case CSSValueBaseline: 3607 return LineSnapBaseline; 3608 case CSSValueContain: 3609 return LineSnapContain; 3610 default: 3611 break; 3612 } 3613 3614 ASSERT_NOT_REACHED(); 3615 return LineSnapNone; 3616 } 3617 3618 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign) 3619 : CSSValue(PrimitiveClass) 3620 { 3621 m_primitiveUnitType = CSS_VALUE_ID; 3622 switch (lineAlign) { 3623 case LineAlignNone: 3624 m_value.valueID = CSSValueNone; 3625 break; 3626 case LineAlignEdges: 3627 m_value.valueID = CSSValueEdges; 3628 break; 3629 } 3630 } 3631 3632 template<> inline CSSPrimitiveValue::operator LineAlign() const 3633 { 3634 ASSERT(isValueID()); 3635 switch (m_value.valueID) { 3636 case CSSValueNone: 3637 return LineAlignNone; 3638 case CSSValueEdges: 3639 return LineAlignEdges; 3640 default: 3641 break; 3642 } 3643 3644 ASSERT_NOT_REACHED(); 3645 return LineAlignNone; 3646 } 3647 3648 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e) 3649 : CSSValue(PrimitiveClass) 3650 { 3651 m_primitiveUnitType = CSS_VALUE_ID; 3652 switch (e) { 3653 case SpeakNone: 3654 m_value.valueID = CSSValueNone; 3655 break; 3656 case SpeakNormal: 3657 m_value.valueID = CSSValueNormal; 3658 break; 3659 case SpeakSpellOut: 3660 m_value.valueID = CSSValueSpellOut; 3661 break; 3662 case SpeakDigits: 3663 m_value.valueID = CSSValueDigits; 3664 break; 3665 case SpeakLiteralPunctuation: 3666 m_value.valueID = CSSValueLiteralPunctuation; 3667 break; 3668 case SpeakNoPunctuation: 3669 m_value.valueID = CSSValueNoPunctuation; 3670 break; 3671 } 3672 } 3673 3674 template<> inline CSSPrimitiveValue::operator Order() const 3675 { 3676 ASSERT(isValueID()); 3677 switch (m_value.valueID) { 3678 case CSSValueLogical: 3679 return LogicalOrder; 3680 case CSSValueVisual: 3681 return VisualOrder; 3682 default: 3683 break; 3684 } 3685 3686 ASSERT_NOT_REACHED(); 3687 return LogicalOrder; 3688 } 3689 3690 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e) 3691 : CSSValue(PrimitiveClass) 3692 { 3693 m_primitiveUnitType = CSS_VALUE_ID; 3694 switch (e) { 3695 case LogicalOrder: 3696 m_value.valueID = CSSValueLogical; 3697 break; 3698 case VisualOrder: 3699 m_value.valueID = CSSValueVisual; 3700 break; 3701 } 3702 } 3703 3704 template<> inline CSSPrimitiveValue::operator ESpeak() const 3705 { 3706 ASSERT(isValueID()); 3707 switch (m_value.valueID) { 3708 case CSSValueNone: 3709 return SpeakNone; 3710 case CSSValueNormal: 3711 return SpeakNormal; 3712 case CSSValueSpellOut: 3713 return SpeakSpellOut; 3714 case CSSValueDigits: 3715 return SpeakDigits; 3716 case CSSValueLiteralPunctuation: 3717 return SpeakLiteralPunctuation; 3718 case CSSValueNoPunctuation: 3719 return SpeakNoPunctuation; 3720 default: 3721 break; 3722 } 3723 3724 ASSERT_NOT_REACHED(); 3725 return SpeakNormal; 3726 } 3727 3728 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode) 3729 : CSSValue(PrimitiveClass) 3730 { 3731 m_primitiveUnitType = CSS_VALUE_ID; 3732 switch (blendMode) { 3733 case BlendModeNormal: 3734 m_value.valueID = CSSValueNormal; 3735 break; 3736 case BlendModeMultiply: 3737 m_value.valueID = CSSValueMultiply; 3738 break; 3739 case BlendModeScreen: 3740 m_value.valueID = CSSValueScreen; 3741 break; 3742 case BlendModeOverlay: 3743 m_value.valueID = CSSValueOverlay; 3744 break; 3745 case BlendModeDarken: 3746 m_value.valueID = CSSValueDarken; 3747 break; 3748 case BlendModeLighten: 3749 m_value.valueID = CSSValueLighten; 3750 break; 3751 case BlendModeColorDodge: 3752 m_value.valueID = CSSValueColorDodge; 3753 break; 3754 case BlendModeColorBurn: 3755 m_value.valueID = CSSValueColorBurn; 3756 break; 3757 case BlendModeHardLight: 3758 m_value.valueID = CSSValueHardLight; 3759 break; 3760 case BlendModeSoftLight: 3761 m_value.valueID = CSSValueSoftLight; 3762 break; 3763 case BlendModeDifference: 3764 m_value.valueID = CSSValueDifference; 3765 break; 3766 case BlendModeExclusion: 3767 m_value.valueID = CSSValueExclusion; 3768 break; 3769 case BlendModeHue: 3770 m_value.valueID = CSSValueHue; 3771 break; 3772 case BlendModeSaturation: 3773 m_value.valueID = CSSValueSaturation; 3774 break; 3775 case BlendModeColor: 3776 m_value.valueID = CSSValueColor; 3777 break; 3778 case BlendModeLuminosity: 3779 m_value.valueID = CSSValueLuminosity; 3780 break; 3781 } 3782 } 3783 3784 template<> inline CSSPrimitiveValue::operator BlendMode() const 3785 { 3786 ASSERT(isValueID()); 3787 switch (m_value.valueID) { 3788 case CSSValueNormal: 3789 return BlendModeNormal; 3790 case CSSValueMultiply: 3791 return BlendModeMultiply; 3792 case CSSValueScreen: 3793 return BlendModeScreen; 3794 case CSSValueOverlay: 3795 return BlendModeOverlay; 3796 case CSSValueDarken: 3797 return BlendModeDarken; 3798 case CSSValueLighten: 3799 return BlendModeLighten; 3800 case CSSValueColorDodge: 3801 return BlendModeColorDodge; 3802 case CSSValueColorBurn: 3803 return BlendModeColorBurn; 3804 case CSSValueHardLight: 3805 return BlendModeHardLight; 3806 case CSSValueSoftLight: 3807 return BlendModeSoftLight; 3808 case CSSValueDifference: 3809 return BlendModeDifference; 3810 case CSSValueExclusion: 3811 return BlendModeExclusion; 3812 case CSSValueHue: 3813 return BlendModeHue; 3814 case CSSValueSaturation: 3815 return BlendModeSaturation; 3816 case CSSValueColor: 3817 return BlendModeColor; 3818 case CSSValueLuminosity: 3819 return BlendModeLuminosity; 3820 default: 3821 break; 3822 } 3823 3824 ASSERT_NOT_REACHED(); 3825 return BlendModeNormal; 3826 } 3827 3828 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e) 3829 : CSSValue(PrimitiveClass) 3830 { 3831 m_primitiveUnitType = CSS_VALUE_ID; 3832 switch (e) { 3833 case ButtCap: 3834 m_value.valueID = CSSValueButt; 3835 break; 3836 case RoundCap: 3837 m_value.valueID = CSSValueRound; 3838 break; 3839 case SquareCap: 3840 m_value.valueID = CSSValueSquare; 3841 break; 3842 } 3843 } 3844 3845 template<> inline CSSPrimitiveValue::operator LineCap() const 3846 { 3847 ASSERT(isValueID()); 3848 switch (m_value.valueID) { 3849 case CSSValueButt: 3850 return ButtCap; 3851 case CSSValueRound: 3852 return RoundCap; 3853 case CSSValueSquare: 3854 return SquareCap; 3855 default: 3856 break; 3857 } 3858 3859 ASSERT_NOT_REACHED(); 3860 return ButtCap; 3861 } 3862 3863 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e) 3864 : CSSValue(PrimitiveClass) 3865 { 3866 m_primitiveUnitType = CSS_VALUE_ID; 3867 switch (e) { 3868 case MiterJoin: 3869 m_value.valueID = CSSValueMiter; 3870 break; 3871 case RoundJoin: 3872 m_value.valueID = CSSValueRound; 3873 break; 3874 case BevelJoin: 3875 m_value.valueID = CSSValueBevel; 3876 break; 3877 } 3878 } 3879 3880 template<> inline CSSPrimitiveValue::operator LineJoin() const 3881 { 3882 ASSERT(isValueID()); 3883 switch (m_value.valueID) { 3884 case CSSValueMiter: 3885 return MiterJoin; 3886 case CSSValueRound: 3887 return RoundJoin; 3888 case CSSValueBevel: 3889 return BevelJoin; 3890 default: 3891 break; 3892 } 3893 3894 ASSERT_NOT_REACHED(); 3895 return MiterJoin; 3896 } 3897 3898 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e) 3899 : CSSValue(PrimitiveClass) 3900 { 3901 m_primitiveUnitType = CSS_VALUE_ID; 3902 switch (e) { 3903 case RULE_NONZERO: 3904 m_value.valueID = CSSValueNonzero; 3905 break; 3906 case RULE_EVENODD: 3907 m_value.valueID = CSSValueEvenodd; 3908 break; 3909 } 3910 } 3911 3912 template<> inline CSSPrimitiveValue::operator WindRule() const 3913 { 3914 ASSERT(isValueID()); 3915 switch (m_value.valueID) { 3916 case CSSValueNonzero: 3917 return RULE_NONZERO; 3918 case CSSValueEvenodd: 3919 return RULE_EVENODD; 3920 default: 3921 break; 3922 } 3923 3924 ASSERT_NOT_REACHED(); 3925 return RULE_NONZERO; 3926 } 3927 3928 3929 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e) 3930 : CSSValue(PrimitiveClass) 3931 { 3932 m_primitiveUnitType = CSS_VALUE_ID; 3933 switch (e) { 3934 case AB_AUTO: 3935 m_value.valueID = CSSValueAuto; 3936 break; 3937 case AB_BASELINE: 3938 m_value.valueID = CSSValueBaseline; 3939 break; 3940 case AB_BEFORE_EDGE: 3941 m_value.valueID = CSSValueBeforeEdge; 3942 break; 3943 case AB_TEXT_BEFORE_EDGE: 3944 m_value.valueID = CSSValueTextBeforeEdge; 3945 break; 3946 case AB_MIDDLE: 3947 m_value.valueID = CSSValueMiddle; 3948 break; 3949 case AB_CENTRAL: 3950 m_value.valueID = CSSValueCentral; 3951 break; 3952 case AB_AFTER_EDGE: 3953 m_value.valueID = CSSValueAfterEdge; 3954 break; 3955 case AB_TEXT_AFTER_EDGE: 3956 m_value.valueID = CSSValueTextAfterEdge; 3957 break; 3958 case AB_IDEOGRAPHIC: 3959 m_value.valueID = CSSValueIdeographic; 3960 break; 3961 case AB_ALPHABETIC: 3962 m_value.valueID = CSSValueAlphabetic; 3963 break; 3964 case AB_HANGING: 3965 m_value.valueID = CSSValueHanging; 3966 break; 3967 case AB_MATHEMATICAL: 3968 m_value.valueID = CSSValueMathematical; 3969 break; 3970 } 3971 } 3972 3973 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const 3974 { 3975 ASSERT(isValueID()); 3976 switch (m_value.valueID) { 3977 case CSSValueAuto: 3978 return AB_AUTO; 3979 case CSSValueBaseline: 3980 return AB_BASELINE; 3981 case CSSValueBeforeEdge: 3982 return AB_BEFORE_EDGE; 3983 case CSSValueTextBeforeEdge: 3984 return AB_TEXT_BEFORE_EDGE; 3985 case CSSValueMiddle: 3986 return AB_MIDDLE; 3987 case CSSValueCentral: 3988 return AB_CENTRAL; 3989 case CSSValueAfterEdge: 3990 return AB_AFTER_EDGE; 3991 case CSSValueTextAfterEdge: 3992 return AB_TEXT_AFTER_EDGE; 3993 case CSSValueIdeographic: 3994 return AB_IDEOGRAPHIC; 3995 case CSSValueAlphabetic: 3996 return AB_ALPHABETIC; 3997 case CSSValueHanging: 3998 return AB_HANGING; 3999 case CSSValueMathematical: 4000 return AB_MATHEMATICAL; 4001 default: 4002 break; 4003 } 4004 4005 ASSERT_NOT_REACHED(); 4006 return AB_AUTO; 4007 } 4008 4009 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e) 4010 : CSSValue(PrimitiveClass) 4011 { 4012 m_primitiveUnitType = CSS_VALUE_ID; 4013 switch (e) { 4014 case BSEPARATE: 4015 m_value.valueID = CSSValueSeparate; 4016 break; 4017 case BCOLLAPSE: 4018 m_value.valueID = CSSValueCollapse; 4019 break; 4020 } 4021 } 4022 4023 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const 4024 { 4025 ASSERT(isValueID()); 4026 switch (m_value.valueID) { 4027 case CSSValueSeparate: 4028 return BSEPARATE; 4029 case CSSValueCollapse: 4030 return BCOLLAPSE; 4031 default: 4032 break; 4033 } 4034 4035 ASSERT_NOT_REACHED(); 4036 return BSEPARATE; 4037 } 4038 4039 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e) 4040 : CSSValue(PrimitiveClass) 4041 { 4042 m_primitiveUnitType = CSS_VALUE_ID; 4043 switch (e) { 4044 case BorderFitBorder: 4045 m_value.valueID = CSSValueBorder; 4046 break; 4047 case BorderFitLines: 4048 m_value.valueID = CSSValueLines; 4049 break; 4050 } 4051 } 4052 4053 template<> inline CSSPrimitiveValue::operator EBorderFit() const 4054 { 4055 ASSERT(isValueID()); 4056 switch (m_value.valueID) { 4057 case CSSValueBorder: 4058 return BorderFitBorder; 4059 case CSSValueLines: 4060 return BorderFitLines; 4061 default: 4062 break; 4063 } 4064 4065 ASSERT_NOT_REACHED(); 4066 return BorderFitLines; 4067 } 4068 4069 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e) 4070 : CSSValue(PrimitiveClass) 4071 { 4072 m_primitiveUnitType = CSS_VALUE_ID; 4073 switch (e) { 4074 case ImageRenderingAuto: 4075 m_value.valueID = CSSValueAuto; 4076 break; 4077 case ImageRenderingOptimizeSpeed: 4078 m_value.valueID = CSSValueOptimizespeed; 4079 break; 4080 case ImageRenderingOptimizeQuality: 4081 m_value.valueID = CSSValueOptimizequality; 4082 break; 4083 case ImageRenderingOptimizeContrast: 4084 m_value.valueID = CSSValueWebkitOptimizeContrast; 4085 break; 4086 } 4087 } 4088 4089 template<> inline CSSPrimitiveValue::operator EImageRendering() const 4090 { 4091 ASSERT(isValueID()); 4092 switch (m_value.valueID) { 4093 case CSSValueAuto: 4094 return ImageRenderingAuto; 4095 case CSSValueOptimizespeed: 4096 return ImageRenderingOptimizeSpeed; 4097 case CSSValueOptimizequality: 4098 return ImageRenderingOptimizeQuality; 4099 case CSSValueWebkitOptimizeContrast: 4100 return ImageRenderingOptimizeContrast; 4101 default: 4102 break; 4103 } 4104 4105 ASSERT_NOT_REACHED(); 4106 return ImageRenderingAuto; 4107 } 4108 4109 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e) 4110 : CSSValue(PrimitiveClass) 4111 { 4112 m_primitiveUnitType = CSS_VALUE_ID; 4113 switch (e) { 4114 case TransformStyle3DFlat: 4115 m_value.valueID = CSSValueFlat; 4116 break; 4117 case TransformStyle3DPreserve3D: 4118 m_value.valueID = CSSValuePreserve3d; 4119 break; 4120 } 4121 } 4122 4123 template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const 4124 { 4125 ASSERT(isValueID()); 4126 switch (m_value.valueID) { 4127 case CSSValueFlat: 4128 return TransformStyle3DFlat; 4129 case CSSValuePreserve3d: 4130 return TransformStyle3DPreserve3D; 4131 default: 4132 break; 4133 } 4134 4135 ASSERT_NOT_REACHED(); 4136 return TransformStyle3DFlat; 4137 } 4138 4139 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnAxis e) 4140 : CSSValue(PrimitiveClass) 4141 { 4142 m_primitiveUnitType = CSS_VALUE_ID; 4143 switch (e) { 4144 case HorizontalColumnAxis: 4145 m_value.valueID = CSSValueHorizontal; 4146 break; 4147 case VerticalColumnAxis: 4148 m_value.valueID = CSSValueVertical; 4149 break; 4150 case AutoColumnAxis: 4151 m_value.valueID = CSSValueAuto; 4152 break; 4153 } 4154 } 4155 4156 template<> inline CSSPrimitiveValue::operator ColumnAxis() const 4157 { 4158 ASSERT(isValueID()); 4159 switch (m_value.valueID) { 4160 case CSSValueHorizontal: 4161 return HorizontalColumnAxis; 4162 case CSSValueVertical: 4163 return VerticalColumnAxis; 4164 case CSSValueAuto: 4165 return AutoColumnAxis; 4166 default: 4167 break; 4168 } 4169 4170 ASSERT_NOT_REACHED(); 4171 return AutoColumnAxis; 4172 } 4173 4174 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnProgression e) 4175 : CSSValue(PrimitiveClass) 4176 { 4177 m_primitiveUnitType = CSS_VALUE_ID; 4178 switch (e) { 4179 case NormalColumnProgression: 4180 m_value.valueID = CSSValueNormal; 4181 break; 4182 case ReverseColumnProgression: 4183 m_value.valueID = CSSValueReverse; 4184 break; 4185 } 4186 } 4187 4188 template<> inline CSSPrimitiveValue::operator ColumnProgression() const 4189 { 4190 ASSERT(isValueID()); 4191 switch (m_value.valueID) { 4192 case CSSValueNormal: 4193 return NormalColumnProgression; 4194 case CSSValueReverse: 4195 return ReverseColumnProgression; 4196 default: 4197 break; 4198 } 4199 4200 ASSERT_NOT_REACHED(); 4201 return NormalColumnProgression; 4202 } 4203 4204 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapFlow wrapFlow) 4205 : CSSValue(PrimitiveClass) 4206 { 4207 m_primitiveUnitType = CSS_VALUE_ID; 4208 switch (wrapFlow) { 4209 case WrapFlowAuto: 4210 m_value.valueID = CSSValueAuto; 4211 break; 4212 case WrapFlowBoth: 4213 m_value.valueID = CSSValueBoth; 4214 break; 4215 case WrapFlowStart: 4216 m_value.valueID = CSSValueStart; 4217 break; 4218 case WrapFlowEnd: 4219 m_value.valueID = CSSValueEnd; 4220 break; 4221 case WrapFlowMaximum: 4222 m_value.valueID = CSSValueMaximum; 4223 break; 4224 case WrapFlowClear: 4225 m_value.valueID = CSSValueClear; 4226 break; 4227 } 4228 } 4229 4230 template<> inline CSSPrimitiveValue::operator WrapFlow() const 4231 { 4232 ASSERT(isValueID()); 4233 switch (m_value.valueID) { 4234 case CSSValueAuto: 4235 return WrapFlowAuto; 4236 case CSSValueBoth: 4237 return WrapFlowBoth; 4238 case CSSValueStart: 4239 return WrapFlowStart; 4240 case CSSValueEnd: 4241 return WrapFlowEnd; 4242 case CSSValueMaximum: 4243 return WrapFlowMaximum; 4244 case CSSValueClear: 4245 return WrapFlowClear; 4246 default: 4247 break; 4248 } 4249 4250 ASSERT_NOT_REACHED(); 4251 return WrapFlowAuto; 4252 } 4253 4254 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapThrough wrapThrough) 4255 : CSSValue(PrimitiveClass) 4256 { 4257 m_primitiveUnitType = CSS_VALUE_ID; 4258 switch (wrapThrough) { 4259 case WrapThroughWrap: 4260 m_value.valueID = CSSValueWrap; 4261 break; 4262 case WrapThroughNone: 4263 m_value.valueID = CSSValueNone; 4264 break; 4265 } 4266 } 4267 4268 template<> inline CSSPrimitiveValue::operator WrapThrough() const 4269 { 4270 ASSERT(isValueID()); 4271 switch (m_value.valueID) { 4272 case CSSValueWrap: 4273 return WrapThroughWrap; 4274 case CSSValueNone: 4275 return WrapThroughNone; 4276 default: 4277 break; 4278 } 4279 4280 ASSERT_NOT_REACHED(); 4281 return WrapThroughWrap; 4282 } 4283 4284 template<> inline CSSPrimitiveValue::operator GridAutoFlow() const 4285 { 4286 ASSERT(isValueID()); 4287 switch (m_value.valueID) { 4288 case CSSValueNone: 4289 return AutoFlowNone; 4290 case CSSValueColumn: 4291 return AutoFlowColumn; 4292 case CSSValueRow: 4293 return AutoFlowRow; 4294 default: 4295 break; 4296 } 4297 4298 ASSERT_NOT_REACHED(); 4299 return AutoFlowNone; 4300 4301 } 4302 4303 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(GridAutoFlow flow) 4304 : CSSValue(PrimitiveClass) 4305 { 4306 m_primitiveUnitType = CSS_VALUE_ID; 4307 switch (flow) { 4308 case AutoFlowNone: 4309 m_value.valueID = CSSValueNone; 4310 break; 4311 case AutoFlowColumn: 4312 m_value.valueID = CSSValueColumn; 4313 break; 4314 case AutoFlowRow: 4315 m_value.valueID = CSSValueRow; 4316 break; 4317 } 4318 } 4319 4320 enum LengthConversion { 4321 AnyConversion = ~0, 4322 FixedIntegerConversion = 1 << 0, 4323 FixedFloatConversion = 1 << 1, 4324 AutoConversion = 1 << 2, 4325 PercentConversion = 1 << 3, 4326 FractionConversion = 1 << 4, 4327 }; 4328 4329 template<int supported> Length CSSPrimitiveValue::convertToLength(const RenderStyle* style, const RenderStyle* rootStyle, double multiplier, bool computingFontSize) 4330 { 4331 ASSERT(!hasVariableReference()); 4332 if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!style || !rootStyle)) 4333 return Length(Undefined); 4334 if ((supported & FixedIntegerConversion) && isLength()) 4335 return computeLength<Length>(style, rootStyle, multiplier, computingFontSize); 4336 if ((supported & FixedFloatConversion) && isLength()) 4337 return Length(computeLength<double>(style, rootStyle, multiplier), Fixed); 4338 if ((supported & PercentConversion) && isPercentage()) 4339 return Length(getDoubleValue(), Percent); 4340 if ((supported & FractionConversion) && isNumber()) 4341 return Length(getDoubleValue() * 100.0, Percent); 4342 if ((supported & AutoConversion) && getValueID() == CSSValueAuto) 4343 return Length(Auto); 4344 if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && (supported & PercentConversion) && isCalculated()) 4345 return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier)); 4346 if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isViewportPercentageLength()) 4347 return viewportPercentageLength(); 4348 return Length(Undefined); 4349 } 4350 4351 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e) 4352 : CSSValue(PrimitiveClass) 4353 { 4354 m_primitiveUnitType = CSS_VALUE_ID; 4355 switch (e) { 4356 case BR_AUTO: 4357 m_value.valueID = CSSValueAuto; 4358 break; 4359 case BR_DYNAMIC: 4360 m_value.valueID = CSSValueDynamic; 4361 break; 4362 case BR_STATIC: 4363 m_value.valueID = CSSValueStatic; 4364 break; 4365 } 4366 } 4367 4368 template<> inline CSSPrimitiveValue::operator EBufferedRendering() const 4369 { 4370 ASSERT(isValueID()); 4371 switch (m_value.valueID) { 4372 case CSSValueAuto: 4373 return BR_AUTO; 4374 case CSSValueDynamic: 4375 return BR_DYNAMIC; 4376 case CSSValueStatic: 4377 return BR_STATIC; 4378 default: 4379 break; 4380 } 4381 4382 ASSERT_NOT_REACHED(); 4383 return BR_AUTO; 4384 } 4385 4386 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e) 4387 : CSSValue(PrimitiveClass) 4388 { 4389 m_primitiveUnitType = CSS_VALUE_ID; 4390 switch (e) { 4391 case CI_AUTO: 4392 m_value.valueID = CSSValueAuto; 4393 break; 4394 case CI_SRGB: 4395 m_value.valueID = CSSValueSrgb; 4396 break; 4397 case CI_LINEARRGB: 4398 m_value.valueID = CSSValueLinearrgb; 4399 break; 4400 } 4401 } 4402 4403 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const 4404 { 4405 ASSERT(isValueID()); 4406 switch (m_value.valueID) { 4407 case CSSValueSrgb: 4408 return CI_SRGB; 4409 case CSSValueLinearrgb: 4410 return CI_LINEARRGB; 4411 case CSSValueAuto: 4412 return CI_AUTO; 4413 default: 4414 break; 4415 } 4416 4417 ASSERT_NOT_REACHED(); 4418 return CI_AUTO; 4419 } 4420 4421 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e) 4422 : CSSValue(PrimitiveClass) 4423 { 4424 m_primitiveUnitType = CSS_VALUE_ID; 4425 switch (e) { 4426 case CR_AUTO: 4427 m_value.valueID = CSSValueAuto; 4428 break; 4429 case CR_OPTIMIZESPEED: 4430 m_value.valueID = CSSValueOptimizespeed; 4431 break; 4432 case CR_OPTIMIZEQUALITY: 4433 m_value.valueID = CSSValueOptimizequality; 4434 break; 4435 } 4436 } 4437 4438 template<> inline CSSPrimitiveValue::operator EColorRendering() const 4439 { 4440 ASSERT(isValueID()); 4441 switch (m_value.valueID) { 4442 case CSSValueOptimizespeed: 4443 return CR_OPTIMIZESPEED; 4444 case CSSValueOptimizequality: 4445 return CR_OPTIMIZEQUALITY; 4446 case CSSValueAuto: 4447 return CR_AUTO; 4448 default: 4449 break; 4450 } 4451 4452 ASSERT_NOT_REACHED(); 4453 return CR_AUTO; 4454 } 4455 4456 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e) 4457 : CSSValue(PrimitiveClass) 4458 { 4459 m_primitiveUnitType = CSS_VALUE_ID; 4460 switch (e) { 4461 case DB_AUTO: 4462 m_value.valueID = CSSValueAuto; 4463 break; 4464 case DB_USE_SCRIPT: 4465 m_value.valueID = CSSValueUseScript; 4466 break; 4467 case DB_NO_CHANGE: 4468 m_value.valueID = CSSValueNoChange; 4469 break; 4470 case DB_RESET_SIZE: 4471 m_value.valueID = CSSValueResetSize; 4472 break; 4473 case DB_CENTRAL: 4474 m_value.valueID = CSSValueCentral; 4475 break; 4476 case DB_MIDDLE: 4477 m_value.valueID = CSSValueMiddle; 4478 break; 4479 case DB_TEXT_BEFORE_EDGE: 4480 m_value.valueID = CSSValueTextBeforeEdge; 4481 break; 4482 case DB_TEXT_AFTER_EDGE: 4483 m_value.valueID = CSSValueTextAfterEdge; 4484 break; 4485 case DB_IDEOGRAPHIC: 4486 m_value.valueID = CSSValueIdeographic; 4487 break; 4488 case DB_ALPHABETIC: 4489 m_value.valueID = CSSValueAlphabetic; 4490 break; 4491 case DB_HANGING: 4492 m_value.valueID = CSSValueHanging; 4493 break; 4494 case DB_MATHEMATICAL: 4495 m_value.valueID = CSSValueMathematical; 4496 break; 4497 } 4498 } 4499 4500 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const 4501 { 4502 ASSERT(isValueID()); 4503 switch (m_value.valueID) { 4504 case CSSValueAuto: 4505 return DB_AUTO; 4506 case CSSValueUseScript: 4507 return DB_USE_SCRIPT; 4508 case CSSValueNoChange: 4509 return DB_NO_CHANGE; 4510 case CSSValueResetSize: 4511 return DB_RESET_SIZE; 4512 case CSSValueIdeographic: 4513 return DB_IDEOGRAPHIC; 4514 case CSSValueAlphabetic: 4515 return DB_ALPHABETIC; 4516 case CSSValueHanging: 4517 return DB_HANGING; 4518 case CSSValueMathematical: 4519 return DB_MATHEMATICAL; 4520 case CSSValueCentral: 4521 return DB_CENTRAL; 4522 case CSSValueMiddle: 4523 return DB_MIDDLE; 4524 case CSSValueTextAfterEdge: 4525 return DB_TEXT_AFTER_EDGE; 4526 case CSSValueTextBeforeEdge: 4527 return DB_TEXT_BEFORE_EDGE; 4528 default: 4529 break; 4530 } 4531 4532 ASSERT_NOT_REACHED(); 4533 return DB_AUTO; 4534 } 4535 4536 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e) 4537 : CSSValue(PrimitiveClass) 4538 { 4539 m_primitiveUnitType = CSS_VALUE_ID; 4540 switch (e) { 4541 case SR_AUTO: 4542 m_value.valueID = CSSValueAuto; 4543 break; 4544 case SR_OPTIMIZESPEED: 4545 m_value.valueID = CSSValueOptimizespeed; 4546 break; 4547 case SR_CRISPEDGES: 4548 m_value.valueID = CSSValueCrispedges; 4549 break; 4550 case SR_GEOMETRICPRECISION: 4551 m_value.valueID = CSSValueGeometricprecision; 4552 break; 4553 } 4554 } 4555 4556 template<> inline CSSPrimitiveValue::operator EShapeRendering() const 4557 { 4558 ASSERT(isValueID()); 4559 switch (m_value.valueID) { 4560 case CSSValueAuto: 4561 return SR_AUTO; 4562 case CSSValueOptimizespeed: 4563 return SR_OPTIMIZESPEED; 4564 case CSSValueCrispedges: 4565 return SR_CRISPEDGES; 4566 case CSSValueGeometricprecision: 4567 return SR_GEOMETRICPRECISION; 4568 default: 4569 break; 4570 } 4571 4572 ASSERT_NOT_REACHED(); 4573 return SR_AUTO; 4574 } 4575 4576 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e) 4577 : CSSValue(PrimitiveClass) 4578 { 4579 m_primitiveUnitType = CSS_VALUE_ID; 4580 switch (e) { 4581 case TA_START: 4582 m_value.valueID = CSSValueStart; 4583 break; 4584 case TA_MIDDLE: 4585 m_value.valueID = CSSValueMiddle; 4586 break; 4587 case TA_END: 4588 m_value.valueID = CSSValueEnd; 4589 break; 4590 } 4591 } 4592 4593 template<> inline CSSPrimitiveValue::operator ETextAnchor() const 4594 { 4595 ASSERT(isValueID()); 4596 switch (m_value.valueID) { 4597 case CSSValueStart: 4598 return TA_START; 4599 case CSSValueMiddle: 4600 return TA_MIDDLE; 4601 case CSSValueEnd: 4602 return TA_END; 4603 default: 4604 break; 4605 } 4606 4607 ASSERT_NOT_REACHED(); 4608 return TA_START; 4609 } 4610 4611 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e) 4612 : CSSValue(PrimitiveClass) 4613 { 4614 m_primitiveUnitType = CSS_VALUE_ID; 4615 switch (e) { 4616 case WM_LRTB: 4617 m_value.valueID = CSSValueLrTb; 4618 break; 4619 case WM_LR: 4620 m_value.valueID = CSSValueLr; 4621 break; 4622 case WM_RLTB: 4623 m_value.valueID = CSSValueRlTb; 4624 break; 4625 case WM_RL: 4626 m_value.valueID = CSSValueRl; 4627 break; 4628 case WM_TBRL: 4629 m_value.valueID = CSSValueTbRl; 4630 break; 4631 case WM_TB: 4632 m_value.valueID = CSSValueTb; 4633 break; 4634 } 4635 } 4636 4637 template<> inline CSSPrimitiveValue::operator SVGWritingMode() const 4638 { 4639 ASSERT(isValueID()); 4640 switch (m_value.valueID) { 4641 case CSSValueLrTb: 4642 return WM_LRTB; 4643 case CSSValueLr: 4644 return WM_LR; 4645 case CSSValueRlTb: 4646 return WM_RLTB; 4647 case CSSValueRl: 4648 return WM_RL; 4649 case CSSValueTbRl: 4650 return WM_TBRL; 4651 case CSSValueTb: 4652 return WM_TB; 4653 default: 4654 break; 4655 } 4656 4657 ASSERT_NOT_REACHED(); 4658 return WM_LRTB; 4659 } 4660 4661 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e) 4662 : CSSValue(PrimitiveClass) 4663 { 4664 m_primitiveUnitType = CSS_VALUE_ID; 4665 switch (e) { 4666 case VE_NONE: 4667 m_value.valueID = CSSValueNone; 4668 break; 4669 case VE_NON_SCALING_STROKE: 4670 m_value.valueID = CSSValueNonScalingStroke; 4671 break; 4672 } 4673 } 4674 4675 template<> inline CSSPrimitiveValue::operator EVectorEffect() const 4676 { 4677 ASSERT(isValueID()); 4678 switch (m_value.valueID) { 4679 case CSSValueNone: 4680 return VE_NONE; 4681 case CSSValueNonScalingStroke: 4682 return VE_NON_SCALING_STROKE; 4683 default: 4684 break; 4685 } 4686 4687 ASSERT_NOT_REACHED(); 4688 return VE_NONE; 4689 } 4690 4691 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMaskType e) 4692 : CSSValue(PrimitiveClass) 4693 { 4694 m_primitiveUnitType = CSS_VALUE_ID; 4695 switch (e) { 4696 case MT_LUMINANCE: 4697 m_value.valueID = CSSValueLuminance; 4698 break; 4699 case MT_ALPHA: 4700 m_value.valueID = CSSValueAlpha; 4701 break; 4702 } 4703 } 4704 4705 template<> inline CSSPrimitiveValue::operator EMaskType() const 4706 { 4707 ASSERT(isValueID()); 4708 switch (m_value.valueID) { 4709 case CSSValueLuminance: 4710 return MT_LUMINANCE; 4711 case CSSValueAlpha: 4712 return MT_ALPHA; 4713 default: 4714 break; 4715 } 4716 4717 ASSERT_NOT_REACHED(); 4718 return MT_LUMINANCE; 4719 } 4720 4721 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TouchAction t) 4722 : CSSValue(PrimitiveClass) 4723 { 4724 m_primitiveUnitType = CSS_VALUE_ID; 4725 switch (t) { 4726 case TouchActionNone: 4727 m_value.valueID = CSSValueNone; 4728 break; 4729 case TouchActionAuto: 4730 m_value.valueID = CSSValueAuto; 4731 break; 4732 } 4733 } 4734 4735 template<> inline CSSPrimitiveValue::operator TouchAction() const 4736 { 4737 ASSERT(isValueID()); 4738 switch (m_value.valueID) { 4739 case CSSValueNone: 4740 return TouchActionNone; 4741 case CSSValueAuto: 4742 return TouchActionAuto; 4743 default: 4744 break; 4745 } 4746 4747 ASSERT_NOT_REACHED(); 4748 return TouchActionNone; 4749 } 4750 4751 } 4752 4753 #endif 4754
