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