Changeset 69220 in webkit


Ignore:
Timestamp:
Oct 6, 2010 12:02:34 PM (14 years ago)
Author:
hyatt@apple.com
Message:

​https://bugs.webkit.org/show_bug.cgi?id=47285

Reviewed by Dan Bernstein.

Update to the latest writing-mode draft. The block-flow property is gone and has been replaced with writing-mode.
Change all the code to use writingMode() instead of blockFlow() and rename all functions that referred to block flow
as appropriate.

WebCore:

  • css/CSSComputedStyleDeclaration.cpp:

(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):

  • css/CSSParser.cpp:

(WebCore::CSSParser::parseValue):

  • css/CSSPrimitiveValueMappings.h:

(WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
(WebCore::CSSPrimitiveValue::operator WritingMode):
(WebCore::CSSPrimitiveValue::operator SVGWritingMode):

  • css/CSSProperty.cpp:

(WebCore::resolveToPhysicalProperty):
(WebCore::CSSProperty::resolveDirectionAwareProperty):

  • css/CSSProperty.h:
  • css/CSSPropertyNames.in:
  • css/CSSStyleSelector.cpp:

(WebCore::CSSStyleSelector::styleForDocument):
(WebCore::CSSStyleSelector::adjustRenderStyle):
(WebCore::CSSStyleSelector::applyDeclarations):
(WebCore::CSSStyleSelector::applyProperty):

  • css/CSSValueKeywords.in:
  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::MarginInfo::MarginInfo):
(WebCore::RenderBlock::expandsToEncloseOverhangingFloats):
(WebCore::RenderBlock::setLogicalLeftForChild):
(WebCore::RenderBlock::setLogicalTopForChild):
(WebCore::RenderBlock::layoutBlockChild):
(WebCore::RenderBlock::insertFloatingObject):
(WebCore::RenderBlock::addOverhangingFloats):
(WebCore::RenderBlock::addIntrudingFloats):
(WebCore::RenderBlock::collapsedMarginBeforeForChild):
(WebCore::RenderBlock::collapsedMarginAfterForChild):
(WebCore::RenderBlock::marginBeforeForChild):
(WebCore::RenderBlock::marginAfterForChild):
(WebCore::RenderBlock::marginStartForChild):
(WebCore::RenderBlock::marginEndForChild):
(WebCore::RenderBlock::setMarginStartForChild):
(WebCore::RenderBlock::setMarginEndForChild):
(WebCore::RenderBlock::setMarginBeforeForChild):
(WebCore::RenderBlock::setMarginAfterForChild):
(WebCore::RenderBlock::marginValuesForChild):

  • rendering/RenderBlock.h:

(WebCore::RenderBlock::logicalWidthForChild):
(WebCore::RenderBlock::logicalHeightForChild):
(WebCore::RenderBlock::logicalTopForChild):
(WebCore::RenderBlock::logicalRightOffsetForContent):
(WebCore::RenderBlock::logicalLeftOffsetForContent):
(WebCore::RenderBlock::logicalTopForFloat):
(WebCore::RenderBlock::logicalBottomForFloat):
(WebCore::RenderBlock::logicalLeftForFloat):
(WebCore::RenderBlock::logicalRightForFloat):
(WebCore::RenderBlock::logicalWidthForFloat):
(WebCore::RenderBlock::setLogicalTopForFloat):
(WebCore::RenderBlock::setLogicalLeftForFloat):
(WebCore::RenderBlock::setLogicalHeightForFloat):
(WebCore::RenderBlock::setLogicalWidthForFloat):

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::marginBefore):
(WebCore::RenderBox::marginAfter):
(WebCore::RenderBox::marginStart):
(WebCore::RenderBox::marginEnd):
(WebCore::RenderBox::setMarginStart):
(WebCore::RenderBox::setMarginEnd):
(WebCore::RenderBox::setMarginBefore):
(WebCore::RenderBox::setMarginAfter):
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::perpendicularContainingBlockLogicalHeight):
(WebCore::RenderBox::computeLogicalWidth):
(WebCore::RenderBox::computeLogicalHeight):
(WebCore::RenderBox::availableLogicalHeightUsing):
(WebCore::RenderBox::avoidsFloats):

  • rendering/RenderBox.h:

(WebCore::RenderBox::logicalLeft):
(WebCore::RenderBox::logicalTop):
(WebCore::RenderBox::logicalWidth):
(WebCore::RenderBox::logicalHeight):
(WebCore::RenderBox::setLogicalLeft):
(WebCore::RenderBox::setLogicalTop):
(WebCore::RenderBox::setLogicalWidth):
(WebCore::RenderBox::setLogicalHeight):
(WebCore::RenderBox::setLogicalLocation):
(WebCore::RenderBox::contentLogicalWidth):
(WebCore::RenderBox::contentLogicalHeight):
(WebCore::RenderBox::stretchesToViewport):
(WebCore::RenderBox::intrinsicLogicalWidth):
(WebCore::RenderBox::intrinsicLogicalHeight):
(WebCore::RenderBox::availableWidth):
(WebCore::RenderBox::availableHeight):
(WebCore::RenderBox::scrollbarLogicalHeight):
(WebCore::RenderBox::isWritingModeRoot):

  • rendering/RenderFieldset.cpp:

(WebCore::RenderFieldset::paintBoxDecorations):
(WebCore::RenderFieldset::paintMask):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::computeReplacedLogicalWidth):
(WebCore::RenderImage::computeReplacedLogicalHeight):

  • rendering/RenderInline.cpp:

(WebCore::RenderInline::marginLeft):
(WebCore::RenderInline::marginRight):
(WebCore::RenderInline::marginTop):
(WebCore::RenderInline::marginBottom):

  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::paddingTop):
(WebCore::RenderTableCell::paddingBottom):
(WebCore::RenderTableCell::paddingLeft):
(WebCore::RenderTableCell::paddingRight):

  • rendering/RenderView.h:

(WebCore::RenderView::viewLogicalWidth):
(WebCore::RenderView::viewLogicalHeight):

  • rendering/RootInlineBox.cpp:

(WebCore::RootInlineBox::RootInlineBox):

  • rendering/style/RenderStyle.cpp:

(WebCore::RenderStyle::diff):
(WebCore::RenderStyle::logicalWidth):
(WebCore::RenderStyle::logicalHeight):
(WebCore::RenderStyle::logicalMinWidth):
(WebCore::RenderStyle::logicalMaxWidth):
(WebCore::RenderStyle::logicalMinHeight):
(WebCore::RenderStyle::logicalMaxHeight):
(WebCore::RenderStyle::borderBeforeWidth):
(WebCore::RenderStyle::borderAfterWidth):
(WebCore::RenderStyle::borderStartWidth):
(WebCore::RenderStyle::borderEndWidth):
(WebCore::RenderStyle::marginBefore):
(WebCore::RenderStyle::marginAfter):
(WebCore::RenderStyle::marginBeforeUsing):
(WebCore::RenderStyle::marginAfterUsing):
(WebCore::RenderStyle::marginStart):
(WebCore::RenderStyle::marginEnd):
(WebCore::RenderStyle::marginStartUsing):
(WebCore::RenderStyle::marginEndUsing):
(WebCore::RenderStyle::paddingBefore):
(WebCore::RenderStyle::paddingAfter):
(WebCore::RenderStyle::paddingStart):
(WebCore::RenderStyle::paddingEnd):

  • rendering/style/RenderStyle.h:

(WebCore::InheritedFlags::setBitDefaults):
(WebCore::InheritedFlags::writingMode):
(WebCore::InheritedFlags::isHorizontalWritingMode):
(WebCore::InheritedFlags::setWritingMode):
(WebCore::InheritedFlags::initialWritingMode):

  • rendering/style/RenderStyleConstants.h:
  • rendering/style/SVGRenderStyle.h:

(WebCore::SVGRenderStyle::initialWritingMode):
(WebCore::SVGRenderStyle::setWritingMode):
(WebCore::SVGRenderStyle::writingMode):

  • rendering/style/SVGRenderStyleDefs.h:

LayoutTests:

Also hacked all of the getComputedStyle tests to just omit dashboard regions so that the results can be
cross-platform.

  • fast/blockflow/auto-margins-across-boundaries.html:
  • fast/blockflow/block-formatting-context.html:
  • fast/blockflow/block-level-images.html:
  • fast/blockflow/display-mutation.html:
  • fast/blockflow/fieldsets.html:
  • fast/blockflow/floats-in-block-layout.html:
  • fast/blockflow/inline-direction-positioning.html:
  • fast/blockflow/margin-collapse.html:
  • fast/blockflow/percentage-padding.html:
  • fast/blockflow/relative-positioning-percentages.html:
  • fast/blockflow/root-lr-basic.html:
  • fast/blockflow/self-collapsing-block.html:
  • fast/css/getComputedStyle/computed-style-expected.txt:
  • fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
  • fast/css/getComputedStyle/computed-style-without-renderer.html:
  • fast/css/getComputedStyle/computed-style.html:
  • fast/css/logical-property-resolution.html:
  • platform/mac/fast/css/getComputedStyle/computed-style-expected.txt: Removed.
  • platform/mac/svg/css/getComputedStyle-basic-expected.checksum: Removed.
  • platform/mac/svg/css/getComputedStyle-basic-expected.png: Removed.
  • platform/win/fast/css/getComputedStyle/computed-style-expected.txt: Removed.
  • platform/win/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt: Removed.
  • svg/css/getComputedStyle-basic-expected.txt:
  • svg/css/getComputedStyle-basic.xhtml:
Location:
trunk
Files:
5 deleted
44 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r69219 r69220  
     12010-10-06  David Hyatt  <hyatt@apple.com>
     2
     3        Reviewed by Dan Bernstein.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=47285
     6
     7        Update to the latest writing-mode draft. The block-flow property is gone and has been replaced with writing-mode.
     8        Change all the code to use writingMode() instead of blockFlow() and rename all functions that referred to block flow
     9        as appropriate.
     10
     11        Also hacked all of the getComputedStyle tests to just omit dashboard regions so that the results can be
     12        cross-platform.
     13
     14        * fast/blockflow/auto-margins-across-boundaries.html:
     15        * fast/blockflow/block-formatting-context.html:
     16        * fast/blockflow/block-level-images.html:
     17        * fast/blockflow/display-mutation.html:
     18        * fast/blockflow/fieldsets.html:
     19        * fast/blockflow/floats-in-block-layout.html:
     20        * fast/blockflow/inline-direction-positioning.html:
     21        * fast/blockflow/margin-collapse.html:
     22        * fast/blockflow/percentage-padding.html:
     23        * fast/blockflow/relative-positioning-percentages.html:
     24        * fast/blockflow/root-lr-basic.html:
     25        * fast/blockflow/self-collapsing-block.html:
     26        * fast/css/getComputedStyle/computed-style-expected.txt:
     27        * fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
     28        * fast/css/getComputedStyle/computed-style-without-renderer.html:
     29        * fast/css/getComputedStyle/computed-style.html:
     30        * fast/css/logical-property-resolution.html:
     31        * platform/mac/fast/css/getComputedStyle/computed-style-expected.txt: Removed.
     32        * platform/mac/svg/css/getComputedStyle-basic-expected.checksum: Removed.
     33        * platform/mac/svg/css/getComputedStyle-basic-expected.png: Removed.
     34        * platform/win/fast/css/getComputedStyle/computed-style-expected.txt: Removed.
     35        * platform/win/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt: Removed.
     36        * svg/css/getComputedStyle-basic-expected.txt:
     37        * svg/css/getComputedStyle-basic.xhtml:
     38
    1392010-10-06  Albert J. Wong  <ajwong@chromium.org>
    240

  • trunk/LayoutTests/fast/blockflow/auto-margins-across-boundaries.html

    r68417 r69220  
    22<head>
    33<style>
    4 .lr { -webkit-block-flow: lr; block-flow: lr; background-color:green; margin-left:auto; margin-right:auto; width:100px; height:100px; }
     4.lr { -webkit-writing-mode: vertical-lr; background-color:green; margin-left:auto; margin-right:auto; width:100px; height:100px; }
    55</style>
    66</head>

  • trunk/LayoutTests/fast/blockflow/block-formatting-context.html

    r68417 r69220  
    22<head>
    33<style>
    4 .lr { -webkit-block-flow: lr; block-flow: lr; background-color:green; margin:10px; width:100px; height:100px; }
     4.lr { -webkit-writing-mode: vertical-lr; background-color:green; margin:10px; width:100px; height:100px; }
    55.float { width:100px; height:100px; background-color:blue; float:left}
    66body { margin: 0 }

  • trunk/LayoutTests/fast/blockflow/block-level-images.html

    r68917 r69220  
    11<!doctype html>
    2 <div style="margin:2px; float:left; height:300px;border:2px solid black;-webkit-writing-mode:tb-lr; writing-mode:tb-lr">
     2<div style="margin:2px; float:left; height:300px;border:2px solid black;-webkit-writing-mode:vertical-lr">
    33<div style="width:25px;background-color:green"></div>
    44<img style="display:block;height:50%; -webkit-border-before:2px solid maroon; -webkit-border-after:2px solid maroon; -webkit-border-start: 1px solid purple; -webkit-border-end:5px dashed grey" src="resources/circle.svg">
    … …  
    77</div>
    88
    9 <div style="margin:2px; float:left; height:300px;border:2px solid black;-webkit-writing-mode:bt-lr; writing-mode:bt-lr">
     9<div style="margin:2px; float:left; height:300px;border:2px solid black;-webkit-writing-mode:vertical-lr; direction:rtl">
    1010<div style="width:25px;background-color:green"></div>
    1111<img style="display:block;height:50%; -webkit-border-before:2px solid maroon; -webkit-border-after:2px solid maroon; -webkit-border-start: 1px solid purple; -webkit-border-end:5px dashed grey" src="resources/circle.svg">

  • trunk/LayoutTests/fast/blockflow/display-mutation.html

    r68083 r69220  
    1616</head>
    1717<body onload="runTest()">
    18 <span id="test" style="-webkit-block-flow:lr"></span>
     18<span id="test" style="-webkit-writing-mode:vertical-lr"></span>
    1919<div id="console"></div>

  • trunk/LayoutTests/fast/blockflow/fieldsets.html

    r69184 r69220  
    5454Vertical LTR fieldset with left/center/right text-align: <br>
    5555
    56 <fieldset style="-webkit-block-flow:lr;">
     56<fieldset style="-webkit-writing-mode:vertical-lr">
    5757<legend style="text-align:left; margin-top:20px"><div></div></legend>
    5858</fieldset>
    5959
    60 <fieldset style="-webkit-block-flow:lr;">
     60<fieldset style="-webkit-writing-mode:vertical-lr">
    6161<legend style="text-align:right; margin-bottom:20px"><div></div></legend>
    6262</fieldset>
    6363
    64 <fieldset style="-webkit-block-flow:lr;">
     64<fieldset style="-webkit-writing-mode:vertical-lr">
    6565<legend style="text-align:center"><div></div></legend>
    6666</fieldset>
    … …  
    7171Vertical RTL fieldset with left/center/right text-align: <br>
    7272
    73 <fieldset dir=rtl style="-webkit-block-flow:lr;">
     73<fieldset dir=rtl style="-webkit-writing-mode:vertical-lr">
    7474<legend style="text-align:left; margin-top:20px"><div></div></legend>
    7575</fieldset>
    7676
    77 <fieldset dir=rtl style="-webkit-block-flow:lr;">
     77<fieldset dir=rtl style="-webkit-writing-mode:vertical-lr">
    7878<legend style="text-align:right; margin-bottom:20px"><div></div></legend>
    7979</fieldset>
    8080
    81 <fieldset dir=rtl style="-webkit-block-flow:lr;">
     81<fieldset dir=rtl style="-webkit-writing-mode:vertical-lr">
    8282<legend style="text-align:center"><div></div></legend>
    8383</fieldset>

  • trunk/LayoutTests/fast/blockflow/floats-in-block-layout.html

    r69136 r69220  
    11<!doctype html>
    22<html>
    3 <body style="-webkit-writing-mode:tb-lr; writing-mode:tb-lr;">
     3<body style="-webkit-writing-mode:vertical-lr">
    44<div style="width:100px; background-color:yellow"></div>
    55<div style="float:left;width:100px;height:100px;background-color:green; margin-top:10px;"></div>

  • trunk/LayoutTests/fast/blockflow/inline-direction-positioning.html

    r68814 r69220  
    22<body>
    33<div style="border:2px solid black;width:600px;">
    4 <div style="-webkit-writing-mode: tb-lr; writing-mode:tb-lr; width:100px; height:100px; margin-left:50px; background-color:green"></div>
     4<div style="-webkit-writing-mode:vertical-lr; width:100px; height:100px; margin-left:50px; background-color:green"></div>
    55</div>
    66
    77<div style="border:2px solid black;width:600px;direction:rtl">
    8 <div style="-webkit-writing-mode: tb-lr; writing-mode:tb-lr; width:100px; height:100px; margin-right:50px; background-color:green"></div>
     8<div style="-webkit-writing-mode:vertical-lr; width:100px; height:100px; margin-right:50px; background-color:green"></div>
    99</div>

  • trunk/LayoutTests/fast/blockflow/margin-collapse.html

    r68842 r69220  
    66<body>
    77<div style="border:2px solid black">
    8 <div style="-webkit-block-flow:lr" class="block"></div>
    9 <div style="-webkit-block-flow:rl" class="block"></div>
    10 <div style="-webkit-block-flow:bt" class="block"></div>
     8<div style="-webkit-writing-mode:vertical-lr" class="block"></div>
     9<div style="-webkit-writing-mode:vertical-rl" class="block"></div>
     10<div style="-webkit-writing-mode:horizontal-bt" class="block"></div>
    1111<div class="block"></div>
    1212</div>

  • trunk/LayoutTests/fast/blockflow/percentage-padding.html

    r68417 r69220  
    1212</head>
    1313<body>
    14 <div style="width:100px;height:200px; -webkit-block-flow:lr;">
     14<div style="width:100px;height:200px; -webkit-writing-mode:vertical-lr">
    1515<div id="test" class="block"></div>
    1616</div>

  • trunk/LayoutTests/fast/blockflow/relative-positioning-percentages.html

    r68417 r69220  
    22<head>
    33<style>
    4 .lr { -webkit-block-flow: lr; block-flow: lr; background-color:green; width:100px; height:100px; position:relative; top:50%; }
     4.lr { -webkit-writing-mode:vertical-lr; background-color:green; width:100px; height:100px; position:relative; top:50%; }
    55</style>
    66</head>

  • trunk/LayoutTests/fast/blockflow/root-lr-basic.html

    r68436 r69220  
    11<!doctype html>
    2 <html style="overflow:hidden; -webkit-block-flow:lr; -webkit-logical-height:100px; border:2px solid black"></html>
     2<html style="overflow:hidden; -webkit-writing-mode:vertical-lr; -webkit-logical-height:100px; border:2px solid black"></html>

  • trunk/LayoutTests/fast/blockflow/self-collapsing-block.html

    r69141 r69220  
    11<!doctype html>
    22<html>
    3 <body style="-webkit-writing-mode:tb-lr; writing-mode:tb-lr">
     3<body style="-webkit-writing-mode:vertical-lr">
    44<div style="width:100px;background-color:green"></div>
    55<div style="height:100px;margin-left:100px;margin-right:100px"></div>

  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt

    r67667 r69220  
    22
    33background-attachment: scroll;
     4background-clip: border-box;
    45background-color: rgba(0, 0, 0, 0);
    56background-image: none;
     7background-origin: padding-box;
    68background-position: 0% 0%;
    79background-repeat: repeat;
     10background-size: auto auto;
    811border-bottom-color: rgb(0, 0, 0);
     12border-bottom-left-radius: 0px;
     13border-bottom-right-radius: 0px;
    914border-bottom-style: none;
    1015border-bottom-width: 0px;
    … …  
    1722border-right-width: 0px;
    1823border-top-color: rgb(0, 0, 0);
     24border-top-left-radius: 0px;
     25border-top-right-radius: 0px;
    1926border-top-style: none;
    2027border-top-width: 0px;
    … …  
    2229caption-side: top;
    2330clear: none;
     31clip: auto;
    2432color: rgb(0, 0, 0);
    2533cursor: auto;
    … …  
    6674resize: none;
    6775right: auto;
     76speak: normal;
    6877table-layout: auto;
    6978text-align: -webkit-auto;
    7079text-decoration: none;
    7180text-indent: 0px;
     81text-rendering: auto;
    7282text-shadow: none;
    7383text-overflow: clip;
    … …  
    8090widows: 2;
    8191width: 784px;
     92word-break: normal;
    8293word-spacing: 0px;
    8394word-wrap: normal;
    … …  
    90101-webkit-animation-iteration-count: 1;
    91102-webkit-animation-name: none;
     103-webkit-animation-play-state: running;
    92104-webkit-animation-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1);
    93105-webkit-appearance: none;
    … …  
    97109-webkit-background-origin: padding-box;
    98110-webkit-background-size: auto auto;
    99 -webkit-block-flow: tb;
    100111-webkit-border-fit: border;
     112-webkit-border-horizontal-spacing: 0px;
    101113-webkit-border-image: none;
    102 -webkit-border-horizontal-spacing: 0px;
    103114-webkit-border-vertical-spacing: 0px;
    104115-webkit-box-align: stretch;
    … …  
    113124-webkit-box-shadow: none;
    114125-webkit-box-sizing: content-box;
     126-webkit-color-correction: default;
    115127-webkit-column-break-after: auto;
    116128-webkit-column-break-before: auto;
    … …  
    123135-webkit-column-span: 1;
    124136-webkit-column-width: auto;
     137-webkit-font-smoothing: auto;
    125138-webkit-highlight: none;
    126139-webkit-line-break: normal;
    127140-webkit-line-clamp: none;
    128 -webkit-margin-bottom-collapse: collapse;
    129 -webkit-margin-top-collapse: collapse;
     141-webkit-margin-before-collapse: collapse;
     142-webkit-margin-after-collapse: collapse;
    130143-webkit-marquee-direction: auto;
    131144-webkit-marquee-increment: 6px;
    … …  
    134147-webkit-mask-attachment: scroll;
    135148-webkit-mask-box-image: none;
     149-webkit-mask-clip: border-box;
     150-webkit-mask-composite: source-over;
    136151-webkit-mask-image: none;
     152-webkit-mask-origin: border-box;
    137153-webkit-mask-position: 0% 0%;
    138154-webkit-mask-repeat: repeat;
    139 -webkit-mask-clip: border-box;
    140 -webkit-mask-composite: source-over;
    141 -webkit-mask-origin: border-box;
    142155-webkit-mask-size: auto auto;
    143156-webkit-nbsp-mode: normal;
    … …  
    160173-webkit-user-modify: read-only;
    161174-webkit-user-select: text;
    162 -webkit-border-bottom-left-radius: 0px;
    163 -webkit-border-bottom-right-radius: 0px;
    164 -webkit-border-top-left-radius: 0px;
    165 -webkit-border-top-right-radius: 0px;
     175-webkit-writing-mode: horizontal-tb;
    166176clip-path: none;
    167177clip-rule: nonzero;
    … …  
    185195shape-rendering: auto;
    186196stroke: none;
    187 stroke-dasharray: ;
    188 stroke-dashoffset: ;
     197stroke-dasharray: none;
     198stroke-dashoffset: 0;
    189199stroke-linecap: butt;
    190200stroke-linejoin: miter;
    191201stroke-miterlimit: 4;
    192202stroke-opacity: 1;
    193 stroke-width: ;
    194 text-rendering: auto;
     203stroke-width: 1;
    195204alignment-baseline: auto;
    196205baseline-shift: baseline;
    197206dominant-baseline: auto;
    198 kerning: ;
     207kerning: 0;
    199208text-anchor: start;
    200209writing-mode: lr-tb;
    201210glyph-orientation-horizontal: 0deg;
    202211glyph-orientation-vertical: auto;
     212-webkit-svg-shadow: none;
     213vector-effect: none;
    203214
    204215Other attributes that the computed style class supports:
    205216
    206 background-position: 0% 0%;
     217background-position-x: 0%;
     218background-position-y: 0%;
    207219border-spacing: 0px 0px;
    208220overflow: visible;
     221-webkit-mask-position-x: 0%;
     222-webkit-mask-position-y: 0%;
    209223-webkit-match-nearest-mail-blockquote-color: normal;
    210224-webkit-text-size-adjust: auto;

  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt

    r67667 r69220  
    11Computed style of an element whose parent's 'display' value is 'none':
    22    background-attachment: scroll
     3    background-clip: border-box
    34    background-color: rgb(0, 128, 0)
    45    background-image: none
     6    background-origin: padding-box
    57    background-position: 0% 0%
    68    background-repeat: repeat
     9    background-size: auto auto
    710    border-bottom-color: rgb(0, 0, 0)
     11    border-bottom-left-radius: 0px
     12    border-bottom-right-radius: 0px
    813    border-bottom-style: none
    914    border-bottom-width: 0px
    … …  
    1621    border-right-width: 0px
    1722    border-top-color: rgb(0, 0, 0)
     23    border-top-left-radius: 0px
     24    border-top-right-radius: 0px
    1825    border-top-style: solid
    1926    border-top-width: 16px
    … …  
    2128    caption-side: top
    2229    clear: none
     30    clip: auto
    2331    color: rgb(0, 0, 0)
    2432    cursor: auto
    … …  
    6573    resize: none
    6674    right: auto
     75    speak: normal
    6776    table-layout: auto
    6877    text-align: -webkit-auto
    6978    text-decoration: none
    7079    text-indent: 0px
     80    text-rendering: auto
    7181    text-shadow: none
    7282    text-overflow: clip
    … …  
    7989    widows: 2
    8090    width: 50%
     91    word-break: normal
    8192    word-spacing: 0px
    8293    word-wrap: normal
    … …  
    89100    -webkit-animation-iteration-count: 1
    90101    -webkit-animation-name: none
     102    -webkit-animation-play-state: running
    91103    -webkit-animation-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1)
    92104    -webkit-appearance: none
    … …  
    96108    -webkit-background-origin: padding-box
    97109    -webkit-background-size: auto auto
    98     -webkit-block-flow: tb
    99110    -webkit-border-fit: border
     111    -webkit-border-horizontal-spacing: 0px
    100112    -webkit-border-image: none
    101     -webkit-border-horizontal-spacing: 0px
    102113    -webkit-border-vertical-spacing: 0px
    103114    -webkit-box-align: stretch
    … …  
    112123    -webkit-box-shadow: none
    113124    -webkit-box-sizing: content-box
     125    -webkit-color-correction: default
    114126    -webkit-column-break-after: auto
    115127    -webkit-column-break-before: auto
    … …  
    122134    -webkit-column-span: 1
    123135    -webkit-column-width: auto
     136    -webkit-font-smoothing: auto
    124137    -webkit-highlight: none
    125138    -webkit-line-break: normal
    126139    -webkit-line-clamp: none
    127     -webkit-margin-bottom-collapse: collapse
    128     -webkit-margin-top-collapse: collapse
     140    -webkit-margin-before-collapse: collapse
     141    -webkit-margin-after-collapse: collapse
    129142    -webkit-marquee-direction: auto
    130143    -webkit-marquee-increment: 6px
    … …  
    133146    -webkit-mask-attachment: scroll
    134147    -webkit-mask-box-image: none
     148    -webkit-mask-clip: border-box
     149    -webkit-mask-composite: source-over
    135150    -webkit-mask-image: none
     151    -webkit-mask-origin: border-box
    136152    -webkit-mask-position: 0% 0%
    137153    -webkit-mask-repeat: repeat
    138     -webkit-mask-clip: border-box
    139     -webkit-mask-composite: source-over
    140     -webkit-mask-origin: border-box
    141154    -webkit-mask-size: auto auto
    142155    -webkit-nbsp-mode: normal
    … …  
    159172    -webkit-user-modify: read-only
    160173    -webkit-user-select: text
    161     -webkit-border-bottom-left-radius: 0px
    162     -webkit-border-bottom-right-radius: 0px
    163     -webkit-border-top-left-radius: 0px
    164     -webkit-border-top-right-radius: 0px
     174    -webkit-writing-mode: horizontal-tb
    165175    clip-path: none
    166176    clip-rule: nonzero
    … …  
    184194    shape-rendering: auto
    185195    stroke: none
    186     stroke-dasharray:
    187     stroke-dashoffset:
     196    stroke-dasharray: none
     197    stroke-dashoffset: 0
    188198    stroke-linecap: butt
    189199    stroke-linejoin: miter
    190200    stroke-miterlimit: 4
    191201    stroke-opacity: 1
    192     stroke-width:
    193     text-rendering: auto
     202    stroke-width: 1
    194203    alignment-baseline: auto
    195204    baseline-shift: baseline
    196205    dominant-baseline: auto
    197     kerning:
     206    kerning: 0
    198207    text-anchor: start
    199208    writing-mode: lr-tb
    200209    glyph-orientation-horizontal: 0deg
    201210    glyph-orientation-vertical: auto
    202     background-position: 0% 0%
     211    -webkit-svg-shadow: none
     212    vector-effect: none
     213    background-position-x: 0%
     214    background-position-y: 0%
    203215    border-spacing: 0px 0px
    204216    overflow: visible
     217    -webkit-mask-position-x: 0%
     218    -webkit-mask-position-y: 0%
    205219    -webkit-match-nearest-mail-blockquote-color: normal
    206220    -webkit-text-size-adjust: auto

  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer.html

    r43797 r69220  
    2929                for (var i = 0; i != style.length; ++i) {
    3030                    var name = style.item(i);
    31                     log("    " + name + ": " + style.getPropertyValue(name));
     31                    if (name != "-webkit-dashboard-region")
     32                        log("    " + name + ": " + style.getPropertyValue(name));
    3233                }
    3334                properties = others;

  • trunk/LayoutTests/fast/css/getComputedStyle/computed-style.html

    r43797 r69220  
    88        var name = style.item(i);
    99        var value = style.getPropertyValue(name);
    10         text += name + ": " + value + ";\n";
     10        if (name != "-webkit-dashboard-region")
     11            text += name + ": " + value + ";\n";
    1112    }
    1213    document.getElementById("exposed").textContent = text;

  • trunk/LayoutTests/fast/css/logical-property-resolution.html

    r68270 r69220  
    1111
    1212.tb-block {
    13   -webkit-block-flow: tb
     13  -webkit-writing-mode: horizontal-tb;
    1414}
    1515
    1616.bt-block {
    17   -webkit-block-flow: bt
     17  -webkit-writing-mode: horizontal-bt
    1818}
    1919
    2020.lr-block {
    21   -webkit-block-flow: lr
     21  -webkit-writing-mode: vertical-lr
    2222}
    2323
    2424.rl-block {
    25   -webkit-block-flow: rl
     25  -webkit-writing-mode: vertical-rl
    2626}
    2727

  • trunk/LayoutTests/svg/css/getComputedStyle-basic-expected.txt

    r68728 r69220  
    215215rect: style.getPropertyValue(-webkit-background-size) : auto auto
    216216rect: style.getPropertyCSSValue(-webkit-background-size) : [object CSSValueList]
    217 rect: style.getPropertyValue(-webkit-block-flow) : tb
    218 rect: style.getPropertyCSSValue(-webkit-block-flow) : [object CSSPrimitiveValue]
    219217rect: style.getPropertyValue(-webkit-border-fit) : border
    220218rect: style.getPropertyCSSValue(-webkit-border-fit) : [object CSSPrimitiveValue]
    … …  
    269267rect: style.getPropertyValue(-webkit-column-width) : auto
    270268rect: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
    271 rect: style.getPropertyValue(-webkit-dashboard-region) : null
    272 rect: style.getPropertyCSSValue(-webkit-dashboard-region) : [object CSSPrimitiveValue]
    273269rect: style.getPropertyValue(-webkit-font-smoothing) : auto
    274270rect: style.getPropertyCSSValue(-webkit-font-smoothing) : [object CSSPrimitiveValue]
    … …  
    347343rect: style.getPropertyValue(-webkit-user-select) : text
    348344rect: style.getPropertyCSSValue(-webkit-user-select) : [object CSSPrimitiveValue]
     345rect: style.getPropertyValue(-webkit-writing-mode) : horizontal-tb
     346rect: style.getPropertyCSSValue(-webkit-writing-mode) : [object CSSPrimitiveValue]
    349347rect: style.getPropertyValue(clip-path) : none
    350348rect: style.getPropertyCSSValue(clip-path) : [object CSSPrimitiveValue]
    … …  
    639637g: style.getPropertyValue(-webkit-background-size) : auto auto
    640638g: style.getPropertyCSSValue(-webkit-background-size) : [object CSSValueList]
    641 g: style.getPropertyValue(-webkit-block-flow) : tb
    642 g: style.getPropertyCSSValue(-webkit-block-flow) : [object CSSPrimitiveValue]
    643639g: style.getPropertyValue(-webkit-border-fit) : border
    644640g: style.getPropertyCSSValue(-webkit-border-fit) : [object CSSPrimitiveValue]
    … …  
    693689g: style.getPropertyValue(-webkit-column-width) : auto
    694690g: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
    695 g: style.getPropertyValue(-webkit-dashboard-region) : null
    696 g: style.getPropertyCSSValue(-webkit-dashboard-region) : [object CSSPrimitiveValue]
    697691g: style.getPropertyValue(-webkit-font-smoothing) : auto
    698692g: style.getPropertyCSSValue(-webkit-font-smoothing) : [object CSSPrimitiveValue]
    … …  
    771765g: style.getPropertyValue(-webkit-user-select) : text
    772766g: style.getPropertyCSSValue(-webkit-user-select) : [object CSSPrimitiveValue]
     767g: style.getPropertyValue(-webkit-writing-mode) : horizontal-tb
     768g: style.getPropertyCSSValue(-webkit-writing-mode) : [object CSSPrimitiveValue]
    773769g: style.getPropertyValue(clip-path) : none
    774770g: style.getPropertyCSSValue(clip-path) : [object CSSPrimitiveValue]

  • trunk/LayoutTests/svg/css/getComputedStyle-basic.xhtml

    r26522 r69220  
    2626          var cssValue = style.getPropertyCSSValue(name);
    2727 
    28           debugLog(elementId + ": style.getPropertyValue(" + name + ") : " + value);
    29           debugLog(elementId + ": style.getPropertyCSSValue(" + name + ") : " + cssValue);
     28          if (name != "-webkit-dashboard-region") {
     29            debugLog(elementId + ": style.getPropertyValue(" + name + ") : " + value);
     30            debugLog(elementId + ": style.getPropertyCSSValue(" + name + ") : " + cssValue);
     31          }
    3032        }
    3133      }

  • trunk/WebCore/ChangeLog

    r69216 r69220  
     12010-10-06  David Hyatt  <hyatt@apple.com>
     2
     3        Reviewed by Dan Bernstein.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=47285
     6
     7        Update to the latest writing-mode draft. The block-flow property is gone and has been replaced with writing-mode.
     8        Change all the code to use writingMode() instead of blockFlow() and rename all functions that referred to block flow
     9        as appropriate.
     10
     11        * css/CSSComputedStyleDeclaration.cpp:
     12        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
     13        * css/CSSParser.cpp:
     14        (WebCore::CSSParser::parseValue):
     15        * css/CSSPrimitiveValueMappings.h:
     16        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
     17        (WebCore::CSSPrimitiveValue::operator WritingMode):
     18        (WebCore::CSSPrimitiveValue::operator SVGWritingMode):
     19        * css/CSSProperty.cpp:
     20        (WebCore::resolveToPhysicalProperty):
     21        (WebCore::CSSProperty::resolveDirectionAwareProperty):
     22        * css/CSSProperty.h:
     23        * css/CSSPropertyNames.in:
     24        * css/CSSStyleSelector.cpp:
     25        (WebCore::CSSStyleSelector::styleForDocument):
     26        (WebCore::CSSStyleSelector::adjustRenderStyle):
     27        (WebCore::CSSStyleSelector::applyDeclarations):
     28        (WebCore::CSSStyleSelector::applyProperty):
     29        * css/CSSValueKeywords.in:
     30        * rendering/RenderBlock.cpp:
     31        (WebCore::RenderBlock::MarginInfo::MarginInfo):
     32        (WebCore::RenderBlock::expandsToEncloseOverhangingFloats):
     33        (WebCore::RenderBlock::setLogicalLeftForChild):
     34        (WebCore::RenderBlock::setLogicalTopForChild):
     35        (WebCore::RenderBlock::layoutBlockChild):
     36        (WebCore::RenderBlock::insertFloatingObject):
     37        (WebCore::RenderBlock::addOverhangingFloats):
     38        (WebCore::RenderBlock::addIntrudingFloats):
     39        (WebCore::RenderBlock::collapsedMarginBeforeForChild):
     40        (WebCore::RenderBlock::collapsedMarginAfterForChild):
     41        (WebCore::RenderBlock::marginBeforeForChild):
     42        (WebCore::RenderBlock::marginAfterForChild):
     43        (WebCore::RenderBlock::marginStartForChild):
     44        (WebCore::RenderBlock::marginEndForChild):
     45        (WebCore::RenderBlock::setMarginStartForChild):
     46        (WebCore::RenderBlock::setMarginEndForChild):
     47        (WebCore::RenderBlock::setMarginBeforeForChild):
     48        (WebCore::RenderBlock::setMarginAfterForChild):
     49        (WebCore::RenderBlock::marginValuesForChild):
     50        * rendering/RenderBlock.h:
     51        (WebCore::RenderBlock::logicalWidthForChild):
     52        (WebCore::RenderBlock::logicalHeightForChild):
     53        (WebCore::RenderBlock::logicalTopForChild):
     54        (WebCore::RenderBlock::logicalRightOffsetForContent):
     55        (WebCore::RenderBlock::logicalLeftOffsetForContent):
     56        (WebCore::RenderBlock::logicalTopForFloat):
     57        (WebCore::RenderBlock::logicalBottomForFloat):
     58        (WebCore::RenderBlock::logicalLeftForFloat):
     59        (WebCore::RenderBlock::logicalRightForFloat):
     60        (WebCore::RenderBlock::logicalWidthForFloat):
     61        (WebCore::RenderBlock::setLogicalTopForFloat):
     62        (WebCore::RenderBlock::setLogicalLeftForFloat):
     63        (WebCore::RenderBlock::setLogicalHeightForFloat):
     64        (WebCore::RenderBlock::setLogicalWidthForFloat):
     65        * rendering/RenderBox.cpp:
     66        (WebCore::RenderBox::marginBefore):
     67        (WebCore::RenderBox::marginAfter):
     68        (WebCore::RenderBox::marginStart):
     69        (WebCore::RenderBox::marginEnd):
     70        (WebCore::RenderBox::setMarginStart):
     71        (WebCore::RenderBox::setMarginEnd):
     72        (WebCore::RenderBox::setMarginBefore):
     73        (WebCore::RenderBox::setMarginAfter):
     74        (WebCore::RenderBox::styleDidChange):
     75        (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight):
     76        (WebCore::RenderBox::computeLogicalWidth):
     77        (WebCore::RenderBox::computeLogicalHeight):
     78        (WebCore::RenderBox::availableLogicalHeightUsing):
     79        (WebCore::RenderBox::avoidsFloats):
     80        * rendering/RenderBox.h:
     81        (WebCore::RenderBox::logicalLeft):
     82        (WebCore::RenderBox::logicalTop):
     83        (WebCore::RenderBox::logicalWidth):
     84        (WebCore::RenderBox::logicalHeight):
     85        (WebCore::RenderBox::setLogicalLeft):
     86        (WebCore::RenderBox::setLogicalTop):
     87        (WebCore::RenderBox::setLogicalWidth):
     88        (WebCore::RenderBox::setLogicalHeight):
     89        (WebCore::RenderBox::setLogicalLocation):
     90        (WebCore::RenderBox::contentLogicalWidth):
     91        (WebCore::RenderBox::contentLogicalHeight):
     92        (WebCore::RenderBox::stretchesToViewport):
     93        (WebCore::RenderBox::intrinsicLogicalWidth):
     94        (WebCore::RenderBox::intrinsicLogicalHeight):
     95        (WebCore::RenderBox::availableWidth):
     96        (WebCore::RenderBox::availableHeight):
     97        (WebCore::RenderBox::scrollbarLogicalHeight):
     98        (WebCore::RenderBox::isWritingModeRoot):
     99        * rendering/RenderFieldset.cpp:
     100        (WebCore::RenderFieldset::paintBoxDecorations):
     101        (WebCore::RenderFieldset::paintMask):
     102        * rendering/RenderImage.cpp:
     103        (WebCore::RenderImage::computeReplacedLogicalWidth):
     104        (WebCore::RenderImage::computeReplacedLogicalHeight):
     105        * rendering/RenderInline.cpp:
     106        (WebCore::RenderInline::marginLeft):
     107        (WebCore::RenderInline::marginRight):
     108        (WebCore::RenderInline::marginTop):
     109        (WebCore::RenderInline::marginBottom):
     110        * rendering/RenderTableCell.cpp:
     111        (WebCore::RenderTableCell::paddingTop):
     112        (WebCore::RenderTableCell::paddingBottom):
     113        (WebCore::RenderTableCell::paddingLeft):
     114        (WebCore::RenderTableCell::paddingRight):
     115        * rendering/RenderView.h:
     116        (WebCore::RenderView::viewLogicalWidth):
     117        (WebCore::RenderView::viewLogicalHeight):
     118        * rendering/RootInlineBox.cpp:
     119        (WebCore::RootInlineBox::RootInlineBox):
     120        * rendering/style/RenderStyle.cpp:
     121        (WebCore::RenderStyle::diff):
     122        (WebCore::RenderStyle::logicalWidth):
     123        (WebCore::RenderStyle::logicalHeight):
     124        (WebCore::RenderStyle::logicalMinWidth):
     125        (WebCore::RenderStyle::logicalMaxWidth):
     126        (WebCore::RenderStyle::logicalMinHeight):
     127        (WebCore::RenderStyle::logicalMaxHeight):
     128        (WebCore::RenderStyle::borderBeforeWidth):
     129        (WebCore::RenderStyle::borderAfterWidth):
     130        (WebCore::RenderStyle::borderStartWidth):
     131        (WebCore::RenderStyle::borderEndWidth):
     132        (WebCore::RenderStyle::marginBefore):
     133        (WebCore::RenderStyle::marginAfter):
     134        (WebCore::RenderStyle::marginBeforeUsing):
     135        (WebCore::RenderStyle::marginAfterUsing):
     136        (WebCore::RenderStyle::marginStart):
     137        (WebCore::RenderStyle::marginEnd):
     138        (WebCore::RenderStyle::marginStartUsing):
     139        (WebCore::RenderStyle::marginEndUsing):
     140        (WebCore::RenderStyle::paddingBefore):
     141        (WebCore::RenderStyle::paddingAfter):
     142        (WebCore::RenderStyle::paddingStart):
     143        (WebCore::RenderStyle::paddingEnd):
     144        * rendering/style/RenderStyle.h:
     145        (WebCore::InheritedFlags::setBitDefaults):
     146        (WebCore::InheritedFlags::writingMode):
     147        (WebCore::InheritedFlags::isHorizontalWritingMode):
     148        (WebCore::InheritedFlags::setWritingMode):
     149        (WebCore::InheritedFlags::initialWritingMode):
     150        * rendering/style/RenderStyleConstants.h:
     151        * rendering/style/SVGRenderStyle.h:
     152        (WebCore::SVGRenderStyle::initialWritingMode):
     153        (WebCore::SVGRenderStyle::setWritingMode):
     154        (WebCore::SVGRenderStyle::writingMode):
     155        * rendering/style/SVGRenderStyleDefs.h:
     156
    11572010-10-06  Sheriff Bot  <webkit.review.bot@gmail.com>
    2158

  • trunk/WebCore/css/CSSComputedStyleDeclaration.cpp

    r68690 r69220  
    160160    CSSPropertyWebkitBackgroundOrigin,
    161161    CSSPropertyWebkitBackgroundSize,
    162     CSSPropertyWebkitBlockFlow,
    163162    CSSPropertyWebkitBorderFit,
    164163    CSSPropertyWebkitBorderHorizontalSpacing,
    … …  
    227226    CSSPropertyWebkitUserDrag,
    228227    CSSPropertyWebkitUserModify,
    229     CSSPropertyWebkitUserSelect
     228    CSSPropertyWebkitUserSelect,
     229    CSSPropertyWebkitWritingMode
    230230
    231231#if ENABLE(SVG)
    … …  
    735735        return 0;
    736736
    737     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->blockFlow());
     737    propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->writingMode());
    738738
    739739    switch (static_cast<CSSPropertyID>(propertyID)) {
    … …  
    13551355        case CSSPropertyWebkitBackfaceVisibility:
    13561356            return CSSPrimitiveValue::createIdentifier((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
    1357         case CSSPropertyWebkitBlockFlow:
    1358             return CSSPrimitiveValue::create(style->blockFlow());
    13591357        case CSSPropertyWebkitBorderImage:
    13601358            return valueForNinePieceImage(style->borderImage());
    … …  
    14641462        case CSSPropertyWebkitColorCorrection:
    14651463            return CSSPrimitiveValue::create(style->colorSpace());
    1466 
     1464        case CSSPropertyWebkitWritingMode:
     1465            return CSSPrimitiveValue::create(style->writingMode());
     1466       
    14671467        /* Shorthand properties, currently not supported see bug 13658*/
    14681468        case CSSPropertyBackground:
    … …  
    14801480        case CSSPropertyMargin:
    14811481        case CSSPropertyPadding:
    1482         case CSSPropertyWebkitWritingMode:
    14831482            break;
    14841483

  • trunk/WebCore/css/CSSParser.cpp

    r69196 r69220  
    17821782
    17831783    // CSS Text Layout Module Level 3: Vertical writing support
    1784     case CSSPropertyWebkitBlockFlow:
    1785         // [ "tb" | "rl" | "lr" | "bt" ]
    1786         if (id == CSSValueTb || id == CSSValueRl || id == CSSValueLr || id == CSSValueBt)
    1787             validPrimitive = true;
    1788         break;
    1789 
    17901784    case CSSPropertyWebkitWritingMode:
    1791         // [ "lr-tb" | "rl-tb" | "tb-rl" | "bt-rl" | "tb-lr" | "bt-lr" ]
    1792         if (id == CSSValueLrTb || id == CSSValueRlTb || id == CSSValueTbRl || id == CSSValueBtRl || id == CSSValueTbLr || id == CSSValueBtLr)
     1785        if (id >= CSSValueHorizontalTb && id <= CSSValueHorizontalBt)
    17931786            validPrimitive = true;
    17941787        break;

  • trunk/WebCore/css/CSSPrimitiveValueMappings.h

    r68738 r69220  
    20042004}
    20052005
    2006 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBlockFlowDirection e)
    2007     : m_type(CSS_IDENT)
    2008     , m_hasCachedCSSText(false)
    2009 {
    2010     switch (e) {
    2011     case TopToBottomBlockFlow:
    2012         m_value.ident = CSSValueTb;
    2013         break;
    2014     case RightToLeftBlockFlow:
    2015         m_value.ident = CSSValueRl;
    2016         break;
    2017     case LeftToRightBlockFlow:
    2018         m_value.ident = CSSValueLr;
    2019         break;
    2020     case BottomToTopBlockFlow:
    2021         m_value.ident = CSSValueBt;
    2022         break;
    2023     }
    2024 }
    2025 
    2026 template<> inline CSSPrimitiveValue::operator EBlockFlowDirection() const
    2027 {
    2028     switch (m_value.ident) {
    2029     case CSSValueTb:
    2030         return TopToBottomBlockFlow;
    2031     case CSSValueRl:
    2032         return RightToLeftBlockFlow;
    2033     case CSSValueLr:
    2034         return LeftToRightBlockFlow;
    2035     case CSSValueBt:
    2036         return BottomToTopBlockFlow;
     2006template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
     2007    : m_type(CSS_IDENT)
     2008    , m_hasCachedCSSText(false)
     2009{
     2010    switch (e) {
     2011    case TopToBottomWritingMode:
     2012        m_value.ident = CSSValueHorizontalTb;
     2013        break;
     2014    case RightToLeftWritingMode:
     2015        m_value.ident = CSSValueVerticalRl;
     2016        break;
     2017    case LeftToRightWritingMode:
     2018        m_value.ident = CSSValueVerticalLr;
     2019        break;
     2020    case BottomToTopWritingMode:
     2021        m_value.ident = CSSValueHorizontalBt;
     2022        break;
     2023    }
     2024}
     2025
     2026template<> inline CSSPrimitiveValue::operator WritingMode() const
     2027{
     2028    switch (m_value.ident) {
     2029    case CSSValueHorizontalTb:
     2030        return TopToBottomWritingMode;
     2031    case CSSValueVerticalRl:
     2032        return RightToLeftWritingMode;
     2033    case CSSValueVerticalLr:
     2034        return LeftToRightWritingMode;
     2035    case CSSValueHorizontalBt:
     2036        return BottomToTopWritingMode;
    20372037    default:
    20382038        ASSERT_NOT_REACHED();
    2039         return TopToBottomBlockFlow;
     2039        return TopToBottomWritingMode;
    20402040    }
    20412041}
    … …  
    27042704}
    27052705
    2706 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWritingMode e)
     2706template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
    27072707    : m_type(CSS_IDENT)
    27082708    , m_hasCachedCSSText(false)
    … …  
    27302730}
    27312731
    2732 template<> inline CSSPrimitiveValue::operator EWritingMode() const
     2732template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
    27332733{
    27342734    switch (m_value.ident) {

  • trunk/WebCore/css/CSSProperty.cpp

    r67882 r69220  
    4343enum PhysicalBoxSide { TopSide, RightSide, BottomSide, LeftSide };
    4444
    45 static int resolveToPhysicalProperty(TextDirection direction, EBlockFlowDirection blockDirection, LogicalBoxSide logicalSide, const int* properties)
     45static int resolveToPhysicalProperty(TextDirection direction, WritingMode writingMode, LogicalBoxSide logicalSide, const int* properties)
    4646{
    4747    if (direction == LTR) {
    48         if (blockDirection == TopToBottomBlockFlow) {
     48        if (writingMode == TopToBottomWritingMode) {
    4949            // The common case. The logical and physical box sides match.
    5050            // Left = Start, Right = End, Before = Top, After = Bottom
    … …  
    5252        }
    5353       
    54         if (blockDirection == BottomToTopBlockFlow) {
     54        if (writingMode == BottomToTopWritingMode) {
    5555            // Start = Left, End = Right, Before = Bottom, After = Top.
    5656            switch (logicalSide) {
    … …  
    6666        }
    6767       
    68         if (blockDirection == LeftToRightBlockFlow) {
     68        if (writingMode == LeftToRightWritingMode) {
    6969            // Start = Top, End = Bottom, Before = Left, After = Right.
    7070            switch (logicalSide) {
    … …  
    9393    }
    9494
    95     if (blockDirection == TopToBottomBlockFlow) {
     95    if (writingMode == TopToBottomWritingMode) {
    9696        // Start = Right, End = Left, Before = Top, After = Bottom
    9797        switch (logicalSide) {
    … …  
    107107    }
    108108   
    109     if (blockDirection == BottomToTopBlockFlow) {
     109    if (writingMode == BottomToTopWritingMode) {
    110110        // Start = Right, End = Left, Before = Bottom, After = Top
    111111        switch (logicalSide) {
    … …  
    121121    }
    122122   
    123     if (blockDirection == LeftToRightBlockFlow) {
     123    if (writingMode == LeftToRightWritingMode) {
    124124        // Start = Bottom, End = Top, Before = Left, After = Right
    125125        switch (logicalSide) {
    … …  
    150150enum LogicalExtent { LogicalWidth, LogicalHeight };
    151151
    152 static int resolveToPhysicalProperty(EBlockFlowDirection blockDirection, LogicalExtent logicalSide, const int* properties)
    153 {
    154     if (blockDirection == TopToBottomBlockFlow || blockDirection == BottomToTopBlockFlow)
     152static int resolveToPhysicalProperty(WritingMode writingMode, LogicalExtent logicalSide, const int* properties)
     153{
     154    if (writingMode == TopToBottomWritingMode || writingMode == BottomToTopWritingMode)
    155155        return properties[logicalSide];
    156156    return logicalSide == LogicalWidth ? properties[1] : properties[0];
    157157}
    158158       
    159 int CSSProperty::resolveDirectionAwareProperty(int propertyID, TextDirection direction, EBlockFlowDirection blockDirection)
     159int CSSProperty::resolveDirectionAwareProperty(int propertyID, TextDirection direction, WritingMode writingMode)
    160160{
    161161    switch (static_cast<CSSPropertyID>(propertyID)) {
    162162    case CSSPropertyWebkitMarginEnd: {
    163163        const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight, CSSPropertyMarginBottom, CSSPropertyMarginLeft };
    164         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     164        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    165165    }
    166166    case CSSPropertyWebkitMarginStart: {
    167167        const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight, CSSPropertyMarginBottom, CSSPropertyMarginLeft };
    168         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     168        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    169169    }
    170170    case CSSPropertyWebkitMarginBefore: {
    171171        const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight, CSSPropertyMarginBottom, CSSPropertyMarginLeft };
    172         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     172        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    173173    }
    174174    case CSSPropertyWebkitMarginAfter: {
    175175        const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight, CSSPropertyMarginBottom, CSSPropertyMarginLeft };
    176         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     176        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    177177    }
    178178    case CSSPropertyWebkitPaddingEnd: {
    179179        const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight, CSSPropertyPaddingBottom, CSSPropertyPaddingLeft };
    180         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     180        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    181181    }
    182182    case CSSPropertyWebkitPaddingStart: {
    183183        const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight, CSSPropertyPaddingBottom, CSSPropertyPaddingLeft };
    184         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     184        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    185185    }
    186186    case CSSPropertyWebkitPaddingBefore: {
    187187        const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight, CSSPropertyPaddingBottom, CSSPropertyPaddingLeft };
    188         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     188        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    189189    }
    190190    case CSSPropertyWebkitPaddingAfter: {
    191191        const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight, CSSPropertyPaddingBottom, CSSPropertyPaddingLeft };
    192         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     192        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    193193    }
    194194    case CSSPropertyWebkitBorderEnd: {
    195195        const int properties[4] = { CSSPropertyBorderTop, CSSPropertyBorderRight, CSSPropertyBorderBottom, CSSPropertyBorderLeft };
    196         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     196        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    197197    }
    198198    case CSSPropertyWebkitBorderStart: {
    199199        const int properties[4] = { CSSPropertyBorderTop, CSSPropertyBorderRight, CSSPropertyBorderBottom, CSSPropertyBorderLeft };
    200         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     200        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    201201    }
    202202    case CSSPropertyWebkitBorderBefore: {
    203203        const int properties[4] = { CSSPropertyBorderTop, CSSPropertyBorderRight, CSSPropertyBorderBottom, CSSPropertyBorderLeft };
    204         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     204        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    205205    }
    206206    case CSSPropertyWebkitBorderAfter: {
    207207        const int properties[4] = { CSSPropertyBorderTop, CSSPropertyBorderRight, CSSPropertyBorderBottom, CSSPropertyBorderLeft };
    208         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     208        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    209209    }
    210210    case CSSPropertyWebkitBorderEndColor: {
    211211        const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor, CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor };
    212         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     212        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    213213    }
    214214    case CSSPropertyWebkitBorderStartColor: {
    215215        const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor, CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor };
    216         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     216        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    217217    }
    218218    case CSSPropertyWebkitBorderBeforeColor: {
    219219        const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor, CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor };
    220         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     220        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    221221    }
    222222    case CSSPropertyWebkitBorderAfterColor: {
    223223        const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor, CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor };
    224         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     224        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    225225    }
    226226    case CSSPropertyWebkitBorderEndStyle: {
    227227        const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle, CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle };
    228         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     228        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    229229    }
    230230    case CSSPropertyWebkitBorderStartStyle: {
    231231        const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle, CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle };
    232         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     232        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    233233    }
    234234    case CSSPropertyWebkitBorderBeforeStyle: {
    235235        const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle, CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle };
    236         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     236        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    237237    }
    238238    case CSSPropertyWebkitBorderAfterStyle: {
    239239        const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle, CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle };
    240         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     240        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    241241    }
    242242    case CSSPropertyWebkitBorderEndWidth: {
    243243        const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth, CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth };
    244         return resolveToPhysicalProperty(direction, blockDirection, EndSide, properties);
     244        return resolveToPhysicalProperty(direction, writingMode, EndSide, properties);
    245245    }
    246246    case CSSPropertyWebkitBorderStartWidth: {
    247247        const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth, CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth };
    248         return resolveToPhysicalProperty(direction, blockDirection, StartSide, properties);
     248        return resolveToPhysicalProperty(direction, writingMode, StartSide, properties);
    249249    }
    250250    case CSSPropertyWebkitBorderBeforeWidth: {
    251251        const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth, CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth };
    252         return resolveToPhysicalProperty(direction, blockDirection, BeforeSide, properties);
     252        return resolveToPhysicalProperty(direction, writingMode, BeforeSide, properties);
    253253    }
    254254    case CSSPropertyWebkitBorderAfterWidth: {
    255255        const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth, CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth };
    256         return resolveToPhysicalProperty(direction, blockDirection, AfterSide, properties);
     256        return resolveToPhysicalProperty(direction, writingMode, AfterSide, properties);
    257257    }
    258258    case CSSPropertyWebkitLogicalWidth: {
    259259        const int properties[2] = { CSSPropertyWidth, CSSPropertyHeight };
    260         return resolveToPhysicalProperty(blockDirection, LogicalWidth, properties);
     260        return resolveToPhysicalProperty(writingMode, LogicalWidth, properties);
    261261    }
    262262    case CSSPropertyWebkitLogicalHeight: {
    263263        const int properties[2] = { CSSPropertyWidth, CSSPropertyHeight };
    264         return resolveToPhysicalProperty(blockDirection, LogicalHeight, properties);
     264        return resolveToPhysicalProperty(writingMode, LogicalHeight, properties);
    265265    }
    266266    case CSSPropertyWebkitMinLogicalWidth: {
    267267        const int properties[2] = { CSSPropertyMinWidth, CSSPropertyMinHeight };
    268         return resolveToPhysicalProperty(blockDirection, LogicalWidth, properties);
     268        return resolveToPhysicalProperty(writingMode, LogicalWidth, properties);
    269269    }
    270270    case CSSPropertyWebkitMinLogicalHeight: {
    271271        const int properties[2] = { CSSPropertyMinWidth, CSSPropertyMinHeight };
    272         return resolveToPhysicalProperty(blockDirection, LogicalHeight, properties);
     272        return resolveToPhysicalProperty(writingMode, LogicalHeight, properties);
    273273    }
    274274    case CSSPropertyWebkitMaxLogicalWidth: {
    275275        const int properties[2] = { CSSPropertyMaxWidth, CSSPropertyMaxHeight };
    276         return resolveToPhysicalProperty(blockDirection, LogicalWidth, properties);
     276        return resolveToPhysicalProperty(writingMode, LogicalWidth, properties);
    277277    }
    278278    case CSSPropertyWebkitMaxLogicalHeight: {
    279279        const int properties[2] = { CSSPropertyMaxWidth, CSSPropertyMaxHeight };
    280         return resolveToPhysicalProperty(blockDirection, LogicalHeight, properties);
     280        return resolveToPhysicalProperty(writingMode, LogicalHeight, properties);
    281281    }
    282282    default:

  • trunk/WebCore/css/CSSProperty.h

    r67882 r69220  
    6161    String cssText() const;
    6262
    63     static int resolveDirectionAwareProperty(int propertyID, TextDirection, EBlockFlowDirection);
     63    static int resolveDirectionAwareProperty(int propertyID, TextDirection, WritingMode);
    6464
    6565    friend bool operator==(const CSSProperty&, const CSSProperty&);

  • trunk/WebCore/css/CSSPropertyNames.in

    r68680 r69220  
    2121font-weight
    2222text-rendering
    23 -webkit-block-flow
    2423-webkit-font-smoothing
    2524-webkit-text-size-adjust

  • trunk/WebCore/css/CSSStyleSelector.cpp

    r68897 r69220  
    11111111        // Use the direction and block-flow of the document element to set the
    11121112        // viewport's direction and block-flow.
    1113         documentStyle->setBlockFlow(docElement->renderer()->style()->blockFlow());
     1113        documentStyle->setWritingMode(docElement->renderer()->style()->writingMode());
    11141114        documentStyle->setDirection(docElement->renderer()->style()->direction());
    11151115    }
    … …  
    17271727        // FIXME: Don't support this mutation for pseudo styles like first-letter or first-line, since it's not completely
    17281728        // clear how that should work.
    1729         if (style->display() == INLINE && style->styleType() == NOPSEUDO && parentStyle && style->blockFlow() != parentStyle->blockFlow())
     1729        if (style->display() == INLINE && style->styleType() == NOPSEUDO && parentStyle && style->writingMode() != parentStyle->writingMode())
    17301730            style->setDisplay(INLINE_BLOCK);
    17311731       
    … …  
    17391739       
    17401740        // FIXME: Since we don't support block-flow on either tables or flexible boxes yet, disallow setting
    1741         // of block-flow to anything other than TopToBottomBlockFlow.
     1741        // of block-flow to anything other than TopToBottomWritingMode.
    17421742        // https://bugs.webkit.org/show_bug.cgi?id=46417 - Tables support
    17431743        // https://bugs.webkit.org/show_bug.cgi?id=46418 - Flexible box support.
    1744         if (style->blockFlow() != TopToBottomBlockFlow && (style->display() == TABLE || style->display() == INLINE_TABLE
     1744        if (style->writingMode() != TopToBottomWritingMode && (style->display() == TABLE || style->display() == INLINE_TABLE
    17451745            || style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW_GROUP
    17461746            || style->display() == TABLE_FOOTER_GROUP || style->display() == TABLE_ROW || style->display() == TABLE_CELL
    17471747            || style->display() == BOX || style->display() == INLINE_BOX))
    1748             style->setBlockFlow(TopToBottomBlockFlow);
     1748            style->setWritingMode(TopToBottomWritingMode);
    17491749    }
    17501750
    … …  
    29472947                if (applyFirst) {
    29482948                    COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
    2949                     COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 14, CSS_zoom_is_end_of_first_prop_range);
     2949                    COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 13, CSS_zoom_is_end_of_first_prop_range);
    29502950                    COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
    29512951
    … …  
    31353135    bool isInitial = valueType == CSSValue::CSS_INITIAL || (!m_parentNode && valueType == CSSValue::CSS_INHERIT);
    31363136   
    3137     id = CSSProperty::resolveDirectionAwareProperty(id, m_style->direction(), m_style->blockFlow());
     3137    id = CSSProperty::resolveDirectionAwareProperty(id, m_style->direction(), m_style->writingMode());
    31383138
    31393139    if (m_checker.m_matchVisitedPseudoClass && !isValidVisitedLinkProperty(id)) {
    … …  
    55725572
    55735573    // CSS Text Layout Module Level 3: Vertical writing support
    5574     case CSSPropertyWebkitBlockFlow:
    5575         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(blockFlow, BlockFlow)
    5576         return;
    5577 
    55785574    case CSSPropertyWebkitWritingMode:
    5579         // The 'writing-mode' property is a shorthand property for the 'direction' property and the 'block-flow' property.
    5580         if (isInherit) {
    5581             m_style->setDirection(m_parentStyle->direction());
    5582             m_style->setBlockFlow(m_parentStyle->blockFlow());
    5583         } else if (isInitial) {
    5584             m_style->setDirection(m_style->initialDirection());
    5585             m_style->setBlockFlow(m_style->initialBlockFlow());
    5586         } else {
    5587             if (!primitiveValue)
    5588                 return;
    5589             switch (primitiveValue->getIdent()) {
    5590             case CSSValueLrTb:
    5591                 m_style->setDirection(LTR);
    5592                 m_style->setBlockFlow(TopToBottomBlockFlow);
    5593                 break;
    5594             case CSSValueRlTb:
    5595                 m_style->setDirection(RTL);
    5596                 m_style->setBlockFlow(TopToBottomBlockFlow);
    5597                 break;
    5598             case CSSValueTbRl:
    5599                 m_style->setDirection(LTR);
    5600                 m_style->setBlockFlow(RightToLeftBlockFlow);
    5601                 break;
    5602             case CSSValueBtRl:
    5603                 m_style->setDirection(RTL);
    5604                 m_style->setBlockFlow(RightToLeftBlockFlow);
    5605                 break;
    5606             case CSSValueTbLr:
    5607                 m_style->setDirection(LTR);
    5608                 m_style->setBlockFlow(LeftToRightBlockFlow);
    5609                 break;
    5610             case CSSValueBtLr:
    5611                 m_style->setDirection(RTL);
    5612                 m_style->setBlockFlow(LeftToRightBlockFlow);
    5613                 break;
    5614             default:
    5615                 break;
    5616             }
    5617         }
     5575        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(writingMode, WritingMode)
    56185576        return;
    56195577

  • trunk/WebCore/css/CSSValueKeywords.in

    r68680 r69220  
    752752# auto
    753753
    754 # -webkit-block-flow
     754# -webkit-writing-mode
     755# SVG compatibility
     756lr
     757rl
    755758tb
    756 rl
    757 lr
    758 bt
    759 
    760 # -webkit-writing-mode
    761759lr-tb
    762760rl-tb
    763761tb-rl
    764 bt-rl
    765 tb-lr
    766 bt-lr
     762# Standard values from CSS3
     763horizontal-tb
     764vertical-rl
     765vertical-lr
     766horizontal-bt

  • trunk/WebCore/rendering/RenderBlock.cpp

    r69192 r69220  
    9191    m_canCollapseWithChildren = !block->isRenderView() && !block->isRoot() && !block->isPositioned()
    9292        && !block->isFloating() && !block->isTableCell() && !block->hasOverflowClip() && !block->isInlineBlockOrInlineTable()
    93         && !block->isBlockFlowRoot();
     93        && !block->isWritingModeRoot();
    9494
    9595    m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && (beforeBorderPadding == 0) && block->style()->marginBeforeCollapse() != MSEPARATE;
    … …  
    13201320{
    13211321    return isInlineBlockOrInlineTable() || isFloatingOrPositioned() || hasOverflowClip() || (parent() && parent()->isFlexibleBox())
    1322            || hasColumns() || isTableCell() || isFieldset() || isBlockFlowRoot();
     1322           || hasColumns() || isTableCell() || isFieldset() || isWritingModeRoot();
    13231323}
    13241324
    … …  
    17211721void RenderBlock::setLogicalLeftForChild(RenderBox* child, int logicalLeft, ApplyLayoutDeltaMode applyDelta)
    17221722{
    1723     if (style()->isVerticalBlockFlow()) {
     1723    if (style()->isHorizontalWritingMode()) {
    17241724        if (applyDelta == ApplyLayoutDelta)
    17251725            view()->addLayoutDelta(IntSize(child->x() - logicalLeft, 0));
    … …  
    17341734void RenderBlock::setLogicalTopForChild(RenderBox* child, int logicalTop, ApplyLayoutDeltaMode applyDelta)
    17351735{
    1736     if (style()->isVerticalBlockFlow()) {
     1736    if (style()->isHorizontalWritingMode()) {
    17371737        if (applyDelta == ApplyLayoutDelta)
    17381738            view()->addLayoutDelta(IntSize(0, child->y() - logicalTop));
    … …  
    18591859        if (markDescendantsWithFloats)
    18601860            childRenderBlock->markAllDescendantsWithFloatsForLayout();
    1861         if (!child->isBlockFlowRoot())
     1861        if (!child->isWritingModeRoot())
    18621862            previousFloatLogicalBottom = max(previousFloatLogicalBottom, oldLogicalTop + childRenderBlock->lowestFloatLogicalBottom());
    18631863    }
    … …  
    29372937    // Just go ahead and lay out the float.
    29382938    bool affectedByPagination = o->isRenderBlock() && view()->layoutState()->m_pageHeight;
    2939     if (!affectedByPagination || isBlockFlowRoot()) // We are unsplittable if we're a block flow root.
     2939    if (!affectedByPagination || isWritingModeRoot()) // We are unsplittable if we're a block flow root.
    29402940        o->layoutIfNeeded();
    29412941    else {
    … …  
    37213721{
    37223722    // Prevent floats from being added to the canvas by the root element, e.g., <html>.
    3723     if (child->hasOverflowClip() || !child->containsFloats() || child->isRoot() || child->hasColumns() || child->isBlockFlowRoot())
     3723    if (child->hasOverflowClip() || !child->containsFloats() || child->isRoot() || child->hasColumns() || child->isWritingModeRoot())
    37243724        return 0;
    37253725
    … …  
    37363736            // If the object is not in the list, we add it now.
    37373737            if (!containsFloat(r->m_renderer)) {
    3738                 int leftOffset = style()->isVerticalBlockFlow() ? logicalLeftOffset : logicalTopOffset;
    3739                 int topOffset = style()->isVerticalBlockFlow() ? logicalTopOffset : logicalLeftOffset;
     3738                int leftOffset = style()->isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;
     3739                int topOffset = style()->isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;
    37403740                FloatingObject* floatingObj = new FloatingObject(r->type(), IntRect(r->left() - leftOffset, r->top() - topOffset, r->width(), r->height()));
    37413741                floatingObj->m_renderer = r->m_renderer;
    … …  
    37783778        return;
    37793779
    3780     logicalLeftOffset += (style()->isVerticalBlockFlow() ? marginLeft() : marginTop());
     3780    logicalLeftOffset += (style()->isHorizontalWritingMode() ? marginLeft() : marginTop());
    37813781               
    37823782    DeprecatedPtrListIterator<FloatingObject> it(*prev->m_floatingObjects);
    … …  
    37953795            }
    37963796            if (!f) {
    3797                 int leftOffset = style()->isVerticalBlockFlow() ? logicalLeftOffset : logicalTopOffset;
    3798                 int topOffset = style()->isVerticalBlockFlow() ? logicalTopOffset : logicalLeftOffset;
     3797                int leftOffset = style()->isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;
     3798                int topOffset = style()->isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;
    37993799               
    38003800                FloatingObject* floatingObj = new FloatingObject(r->type(), IntRect(r->left() - leftOffset, r->top() - topOffset, r->width(), r->height()));
    … …  
    38063806                // will get applied twice.
    38073807                if (prev != parent())
    3808                     floatingObj->setLeft(floatingObj->left() + (style()->isVerticalBlockFlow() ? prev->marginLeft() : prev->marginTop()));
     3808                    floatingObj->setLeft(floatingObj->left() + (style()->isHorizontalWritingMode() ? prev->marginLeft() : prev->marginTop()));
    38093809               
    38103810                floatingObj->m_shouldPaint = false;  // We are not in the direct inheritance chain for this float. We will never paint it.
    … …  
    59985998    // If the child has the same directionality as we do, then we can just return its
    59995999    // collapsed margin.
    6000     if (!child->isBlockFlowRoot())
     6000    if (!child->isWritingModeRoot())
    60016001        return child->collapsedMarginBefore();
    60026002   
    60036003    // The child has a different directionality.  If the child is parallel, then it's just
    60046004    // flipped relative to us.  We can use the collapsed margin for the opposite edge.
    6005     if (child->style()->isVerticalBlockFlow() == style()->isVerticalBlockFlow())
     6005    if (child->style()->isHorizontalWritingMode() == style()->isHorizontalWritingMode())
    60066006        return child->collapsedMarginAfter();
    60076007   
    … …  
    60156015    // If the child has the same directionality as we do, then we can just return its
    60166016    // collapsed margin.
    6017     if (!child->isBlockFlowRoot())
     6017    if (!child->isWritingModeRoot())
    60186018        return child->collapsedMarginAfter();
    60196019   
    60206020    // The child has a different directionality.  If the child is parallel, then it's just
    60216021    // flipped relative to us.  We can use the collapsed margin for the opposite edge.
    6022     if (child->style()->isVerticalBlockFlow() == style()->isVerticalBlockFlow())
     6022    if (child->style()->isHorizontalWritingMode() == style()->isHorizontalWritingMode())
    60236023        return child->collapsedMarginBefore();
    60246024   
    … …  
    60306030int RenderBlock::marginBeforeForChild(RenderBoxModelObject* child) const
    60316031{
    6032     switch (style()->blockFlow()) {
    6033     case TopToBottomBlockFlow:
     6032    switch (style()->writingMode()) {
     6033    case TopToBottomWritingMode:
    60346034        return child->marginTop();
    6035     case BottomToTopBlockFlow:
     6035    case BottomToTopWritingMode:
    60366036        return child->marginBottom();
    6037     case LeftToRightBlockFlow:
     6037    case LeftToRightWritingMode:
    60386038        return child->marginLeft();
    6039     case RightToLeftBlockFlow:
     6039    case RightToLeftWritingMode:
    60406040        return child->marginRight();
    60416041    }
    … …  
    60466046int RenderBlock::marginAfterForChild(RenderBoxModelObject* child) const
    60476047{
    6048     switch (style()->blockFlow()) {
    6049     case TopToBottomBlockFlow:
     6048    switch (style()->writingMode()) {
     6049    case TopToBottomWritingMode:
    60506050        return child->marginBottom();
    6051     case BottomToTopBlockFlow:
     6051    case BottomToTopWritingMode:
    60526052        return child->marginTop();
    6053     case LeftToRightBlockFlow:
     6053    case LeftToRightWritingMode:
    60546054        return child->marginRight();
    6055     case RightToLeftBlockFlow:
     6055    case RightToLeftWritingMode:
    60566056        return child->marginLeft();
    60576057    }
    … …  
    60626062int RenderBlock::marginStartForChild(RenderBoxModelObject* child) const
    60636063{
    6064     if (style()->isVerticalBlockFlow())
     6064    if (style()->isHorizontalWritingMode())
    60656065        return style()->isLeftToRightDirection() ? child->marginLeft() : child->marginRight();
    60666066    return style()->isLeftToRightDirection() ? child->marginTop() : child->marginBottom();
    … …  
    60696069int RenderBlock::marginEndForChild(RenderBoxModelObject* child) const
    60706070{
    6071     if (style()->isVerticalBlockFlow())
     6071    if (style()->isHorizontalWritingMode())
    60726072        return style()->isLeftToRightDirection() ? child->marginRight() : child->marginLeft();
    60736073    return style()->isLeftToRightDirection() ? child->marginBottom() : child->marginTop();
    … …  
    60766076void RenderBlock::setMarginStartForChild(RenderBox* child, int margin)
    60776077{
    6078     if (style()->isVerticalBlockFlow()) {
     6078    if (style()->isHorizontalWritingMode()) {
    60796079        if (style()->isLeftToRightDirection())
    60806080            child->setMarginLeft(margin);
    … …  
    60916091void RenderBlock::setMarginEndForChild(RenderBox* child, int margin)
    60926092{
    6093     if (style()->isVerticalBlockFlow()) {
     6093    if (style()->isHorizontalWritingMode()) {
    60946094        if (style()->isLeftToRightDirection())
    60956095            child->setMarginRight(margin);
    … …  
    61066106void RenderBlock::setMarginBeforeForChild(RenderBox* child, int margin)
    61076107{
    6108     switch (style()->blockFlow()) {
    6109     case TopToBottomBlockFlow:
     6108    switch (style()->writingMode()) {
     6109    case TopToBottomWritingMode:
    61106110        child->setMarginTop(margin);
    61116111        break;
    6112     case BottomToTopBlockFlow:
     6112    case BottomToTopWritingMode:
    61136113        child->setMarginBottom(margin);
    61146114        break;
    6115     case LeftToRightBlockFlow:
     6115    case LeftToRightWritingMode:
    61166116        child->setMarginLeft(margin);
    61176117        break;
    6118     case RightToLeftBlockFlow:
     6118    case RightToLeftWritingMode:
    61196119        child->setMarginRight(margin);
    61206120        break;
    … …  
    61246124void RenderBlock::setMarginAfterForChild(RenderBox* child, int margin)
    61256125{
    6126     switch (style()->blockFlow()) {
    6127     case TopToBottomBlockFlow:
     6126    switch (style()->writingMode()) {
     6127    case TopToBottomWritingMode:
    61286128        child->setMarginBottom(margin);
    61296129        break;
    6130     case BottomToTopBlockFlow:
     6130    case BottomToTopWritingMode:
    61316131        child->setMarginTop(margin);
    61326132        break;
    6133     case LeftToRightBlockFlow:
     6133    case LeftToRightWritingMode:
    61346134        child->setMarginRight(margin);
    61356135        break;
    6136     case RightToLeftBlockFlow:
     6136    case RightToLeftWritingMode:
    61376137        child->setMarginLeft(margin);
    61386138        break;
    … …  
    61546154    // If the child has the same directionality as we do, then we can just return its
    61556155    // margins in the same direction.
    6156     if (!child->isBlockFlowRoot()) {
     6156    if (!child->isWritingModeRoot()) {
    61576157        if (childRenderBlock) {
    61586158            childBeforePositive = childRenderBlock->maxPositiveMarginBefore();
    … …  
    61646164            afterMargin = child->marginAfter();
    61656165        }
    6166     } else if (child->style()->isVerticalBlockFlow() == style()->isVerticalBlockFlow()) {
     6166    } else if (child->style()->isHorizontalWritingMode() == style()->isHorizontalWritingMode()) {
    61676167        // The child has a different directionality.  If the child is parallel, then it's just
    61686168        // flipped relative to us.  We can use the margins for the opposite edges.

  • trunk/WebCore/rendering/RenderBlock.h

    r69184 r69220  
    172172    // Accessors for logical width/height and margins in the containing block's block-flow direction.
    173173    enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
    174     int logicalWidthForChild(RenderBox* child) { return style()->isVerticalBlockFlow() ? child->width() : child->height(); }
    175     int logicalHeightForChild(RenderBox* child) { return style()->isVerticalBlockFlow() ? child->height() : child->width(); }
    176     int logicalTopForChild(RenderBox* child) { return style()->isVerticalBlockFlow() ? child->y() : child->x(); }
     174    int logicalWidthForChild(RenderBox* child) { return style()->isHorizontalWritingMode() ? child->width() : child->height(); }
     175    int logicalHeightForChild(RenderBox* child) { return style()->isHorizontalWritingMode() ? child->height() : child->width(); }
     176    int logicalTopForChild(RenderBox* child) { return style()->isHorizontalWritingMode() ? child->y() : child->x(); }
    177177    void setLogicalLeftForChild(RenderBox* child, int logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
    178178    void setLogicalTopForChild(RenderBox* child, int logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
    … …  
    264264    virtual void paintObject(PaintInfo&, int tx, int ty);
    265265
    266     int logicalRightOffsetForContent() const { return style()->isVerticalBlockFlow() ? borderLeft() + paddingLeft() + availableLogicalWidth() : borderTop() + paddingTop() + availableLogicalWidth(); }
    267     int logicalLeftOffsetForContent() const { return style()->isVerticalBlockFlow() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
     266    int logicalRightOffsetForContent() const { return style()->isHorizontalWritingMode() ? borderLeft() + paddingLeft() + availableLogicalWidth() : borderTop() + paddingTop() + availableLogicalWidth(); }
     267    int logicalLeftOffsetForContent() const { return style()->isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
    268268    int logicalRightOffsetForLine(int position, int fixedOffset, bool applyTextIndent = true, int* logicalHeightRemaining = 0) const;
    269269    int logicalLeftOffsetForLine(int position, int fixedOffset, bool applyTextIndent = true, int* logicalHeightRemaining = 0) const;
    … …  
    415415    };
    416416
    417     int logicalTopForFloat(FloatingObject* child) const { return style()->isVerticalBlockFlow() ? child->top() : child->left(); }
    418     int logicalBottomForFloat(FloatingObject* child) const { return style()->isVerticalBlockFlow() ? child->bottom() : child->right(); }
    419     int logicalLeftForFloat(FloatingObject* child) const { return style()->isVerticalBlockFlow() ? child->left() : child->top(); }
    420     int logicalRightForFloat(FloatingObject* child) const { return style()->isVerticalBlockFlow() ? child->right() : child->bottom(); }
    421     int logicalWidthForFloat(FloatingObject* child) const { return style()->isVerticalBlockFlow() ? child->width() : child->height(); }
     417    int logicalTopForFloat(FloatingObject* child) const { return style()->isHorizontalWritingMode() ? child->top() : child->left(); }
     418    int logicalBottomForFloat(FloatingObject* child) const { return style()->isHorizontalWritingMode() ? child->bottom() : child->right(); }
     419    int logicalLeftForFloat(FloatingObject* child) const { return style()->isHorizontalWritingMode() ? child->left() : child->top(); }
     420    int logicalRightForFloat(FloatingObject* child) const { return style()->isHorizontalWritingMode() ? child->right() : child->bottom(); }
     421    int logicalWidthForFloat(FloatingObject* child) const { return style()->isHorizontalWritingMode() ? child->width() : child->height(); }
    422422    void setLogicalTopForFloat(FloatingObject* child, int logicalTop)
    423423    {
    424         if (style()->isVerticalBlockFlow())
     424        if (style()->isHorizontalWritingMode())
    425425            child->setTop(logicalTop);
    426426        else
    … …  
    429429    void setLogicalLeftForFloat(FloatingObject* child, int logicalLeft)
    430430    {
    431         if (style()->isVerticalBlockFlow())
     431        if (style()->isHorizontalWritingMode())
    432432            child->setLeft(logicalLeft);
    433433        else
    … …  
    436436    void setLogicalHeightForFloat(FloatingObject* child, int logicalHeight)
    437437    {
    438         if (style()->isVerticalBlockFlow())
     438        if (style()->isHorizontalWritingMode())
    439439            child->setHeight(logicalHeight);
    440440        else
    … …  
    443443    void setLogicalWidthForFloat(FloatingObject* child, int logicalWidth)
    444444    {
    445         if (style()->isVerticalBlockFlow())
     445        if (style()->isHorizontalWritingMode())
    446446            child->setWidth(logicalWidth);
    447447        else

  • trunk/WebCore/rendering/RenderBox.cpp

    r69192 r69220  
    8686int RenderBox::marginBefore() const
    8787{
    88     switch (style()->blockFlow()) {
    89     case TopToBottomBlockFlow:
     88    switch (style()->writingMode()) {
     89    case TopToBottomWritingMode:
    9090        return m_marginTop;
    91     case BottomToTopBlockFlow:
     91    case BottomToTopWritingMode:
    9292        return m_marginBottom;
    93     case LeftToRightBlockFlow:
     93    case LeftToRightWritingMode:
    9494        return m_marginLeft;
    95     case RightToLeftBlockFlow:
     95    case RightToLeftWritingMode:
    9696        return m_marginRight;
    9797    }
    … …  
    102102int RenderBox::marginAfter() const
    103103{
    104     switch (style()->blockFlow()) {
    105     case TopToBottomBlockFlow:
     104    switch (style()->writingMode()) {
     105    case TopToBottomWritingMode:
    106106        return m_marginBottom;
    107     case BottomToTopBlockFlow:
     107    case BottomToTopWritingMode:
    108108        return m_marginTop;
    109     case LeftToRightBlockFlow:
     109    case LeftToRightWritingMode:
    110110        return m_marginRight;
    111     case RightToLeftBlockFlow:
     111    case RightToLeftWritingMode:
    112112        return m_marginLeft;
    113113    }
    … …  
    118118int RenderBox::marginStart() const
    119119{
    120     if (style()->isVerticalBlockFlow())
     120    if (style()->isHorizontalWritingMode())
    121121        return style()->isLeftToRightDirection() ? m_marginLeft : m_marginRight;
    122122    return style()->isLeftToRightDirection() ? m_marginTop : m_marginBottom;
    … …  
    125125int RenderBox::marginEnd() const
    126126{
    127     if (style()->isVerticalBlockFlow())
     127    if (style()->isHorizontalWritingMode())
    128128        return style()->isLeftToRightDirection() ? m_marginRight : m_marginLeft;
    129129    return style()->isLeftToRightDirection() ? m_marginBottom : m_marginTop;
    … …  
    132132void RenderBox::setMarginStart(int margin)
    133133{
    134     if (style()->isVerticalBlockFlow()) {
     134    if (style()->isHorizontalWritingMode()) {
    135135        if (style()->isLeftToRightDirection())
    136136            m_marginLeft = margin;
    … …  
    147147void RenderBox::setMarginEnd(int margin)
    148148{
    149     if (style()->isVerticalBlockFlow()) {
     149    if (style()->isHorizontalWritingMode()) {
    150150        if (style()->isLeftToRightDirection())
    151151            m_marginRight = margin;
    … …  
    162162void RenderBox::setMarginBefore(int margin)
    163163{
    164     switch (style()->blockFlow()) {
    165     case TopToBottomBlockFlow:
     164    switch (style()->writingMode()) {
     165    case TopToBottomWritingMode:
    166166        m_marginTop = margin;
    167167        break;
    168     case BottomToTopBlockFlow:
     168    case BottomToTopWritingMode:
    169169        m_marginBottom = margin;
    170170        break;
    171     case LeftToRightBlockFlow:
     171    case LeftToRightWritingMode:
    172172        m_marginLeft = margin;
    173173        break;
    174     case RightToLeftBlockFlow:
     174    case RightToLeftWritingMode:
    175175        m_marginRight = margin;
    176176        break;
    … …  
    180180void RenderBox::setMarginAfter(int margin)
    181181{
    182     switch (style()->blockFlow()) {
    183     case TopToBottomBlockFlow:
     182    switch (style()->writingMode()) {
     183    case TopToBottomWritingMode:
    184184        m_marginBottom = margin;
    185185        break;
    186     case BottomToTopBlockFlow:
     186    case BottomToTopWritingMode:
    187187        m_marginTop = margin;
    188188        break;
    189     case LeftToRightBlockFlow:
     189    case LeftToRightWritingMode:
    190190        m_marginRight = margin;
    191191        break;
    192     case RightToLeftBlockFlow:
     192    case RightToLeftWritingMode:
    193193        m_marginLeft = margin;
    194194        break;
    … …  
    301301    if (isBody())
    302302        document()->setTextColor(style()->visitedDependentColor(CSSPropertyColor));
    303     else if (isRoot() && (!oldStyle || oldStyle->blockFlow() != style()->blockFlow() || oldStyle->direction() != style()->direction())) {
     303    else if (isRoot() && (!oldStyle || oldStyle->writingMode() != style()->writingMode() || oldStyle->direction() != style()->direction())) {
    304304        // Propagate the new block flow and direction up to the RenderView.
    305305        // FIXME: WinIE seems to propagate from the <body> as well.  We may want to consider doing that at some point.
    306306        RenderView* viewRenderer = view();
    307307        RenderStyle* viewStyle = viewRenderer->style();
    308         if (viewStyle->blockFlow() != style()->blockFlow() || viewStyle->direction() != style()->direction()) {
    309             viewStyle->setBlockFlow(style()->blockFlow());
     308        if (viewStyle->writingMode() != style()->writingMode() || viewStyle->direction() != style()->direction()) {
     309            viewStyle->setWritingMode(style()->writingMode());
    310310            viewStyle->setDirection(style()->direction());
    311311            viewRenderer->setNeedsLayoutAndPrefWidthsRecalc();
    … …  
    11001100        // as a constraint.  We do that for now as well even though it's likely being unconstrained is what the spec
    11011101        // will decide.
    1102         return containingBlockStyle->isVerticalBlockFlow() ? view()->frameView()->visibleHeight() : view()->frameView()->visibleWidth();
     1102        return containingBlockStyle->isHorizontalWritingMode() ? view()->frameView()->visibleHeight() : view()->frameView()->visibleWidth();
    11031103    }
    11041104   
    … …  
    14441444    RenderBlock* cb = containingBlock();
    14451445    int containerLogicalWidth = max(0, containingBlockLogicalWidthForContent());
    1446     bool hasPerpendicularContainingBlock = cb->style()->isVerticalBlockFlow() != style()->isVerticalBlockFlow();
     1446    bool hasPerpendicularContainingBlock = cb->style()->isHorizontalWritingMode() != style()->isHorizontalWritingMode();
    14471447    int containerWidthInInlineDirection = containerLogicalWidth;
    14481448    if (hasPerpendicularContainingBlock)
    … …  
    16191619    } else {
    16201620        RenderBlock* cb = containingBlock();
    1621         bool hasPerpendicularContainingBlock = cb->style()->isVerticalBlockFlow() != style()->isVerticalBlockFlow();
     1621        bool hasPerpendicularContainingBlock = cb->style()->isHorizontalWritingMode() != style()->isHorizontalWritingMode();
    16221622   
    16231623        if (!hasPerpendicularContainingBlock)
    … …  
    17001700            visHeight = static_cast<int>(view()->pageHeight());
    17011701        else  {
    1702             if (style()->isVerticalBlockFlow())
     1702            if (style()->isHorizontalWritingMode())
    17031703                visHeight = view()->viewHeight();
    17041704            else
    … …  
    19081908
    19091909    if (isRenderView())
    1910         return style()->isVerticalBlockFlow() ? toRenderView(this)->frameView()->visibleHeight() : toRenderView(this)->frameView()->visibleWidth();
     1910        return style()->isHorizontalWritingMode() ? toRenderView(this)->frameView()->visibleHeight() : toRenderView(this)->frameView()->visibleWidth();
    19111911
    19121912    // We need to stop here, since we don't want to increase the height of the table
    … …  
    30393039bool RenderBox::avoidsFloats() const
    30403040{
    3041     return isReplaced() || hasOverflowClip() || isHR() || isBlockFlowRoot();
     3041    return isReplaced() || hasOverflowClip() || isHR() || isWritingModeRoot();
    30423042}
    30433043

  • trunk/WebCore/rendering/RenderBox.h

    r68917 r69220  
    5151    void setHeight(int height) { m_frameRect.setHeight(height); }
    5252
    53     int logicalLeft() const { return style()->isVerticalBlockFlow() ? x() : y(); }
    54     int logicalTop() const { return style()->isVerticalBlockFlow() ? y() : x(); }
    55     int logicalWidth() const { return style()->isVerticalBlockFlow() ? width() : height(); }
    56     int logicalHeight() const { return style()->isVerticalBlockFlow() ? height() : width(); }
     53    int logicalLeft() const { return style()->isHorizontalWritingMode() ? x() : y(); }
     54    int logicalTop() const { return style()->isHorizontalWritingMode() ? y() : x(); }
     55    int logicalWidth() const { return style()->isHorizontalWritingMode() ? width() : height(); }
     56    int logicalHeight() const { return style()->isHorizontalWritingMode() ? height() : width(); }
    5757    void setLogicalLeft(int left)
    5858    {
    59         if (style()->isVerticalBlockFlow())
     59        if (style()->isHorizontalWritingMode())
    6060            setX(left);
    6161        else
    … …  
    6464    void setLogicalTop(int top)
    6565    {
    66         if (style()->isVerticalBlockFlow())
     66        if (style()->isHorizontalWritingMode())
    6767            setY(top);
    6868        else
    … …  
    7171    void setLogicalWidth(int size)
    7272    {
    73         if (style()->isVerticalBlockFlow())
     73        if (style()->isHorizontalWritingMode())
    7474            setWidth(size);
    7575        else
    … …  
    7878    void setLogicalHeight(int size)
    7979    {
    80         if (style()->isVerticalBlockFlow())
     80        if (style()->isHorizontalWritingMode())
    8181            setHeight(size);
    8282        else
    … …  
    8585    void setLogicalLocation(int left, int top)
    8686    {
    87         if (style()->isVerticalBlockFlow())
     87        if (style()->isHorizontalWritingMode())
    8888            setLocation(left, top);
    8989        else
    … …  
    151151    int contentWidth() const { return clientWidth() - paddingLeft() - paddingRight(); }
    152152    int contentHeight() const { return clientHeight() - paddingTop() - paddingBottom(); }
    153     int contentLogicalWidth() const { return style()->isVerticalBlockFlow() ? contentWidth() : contentHeight(); }
    154     int contentLogicalHeight() const { return style()->isVerticalBlockFlow() ? contentHeight() : contentWidth(); }
     153    int contentLogicalWidth() const { return style()->isHorizontalWritingMode() ? contentWidth() : contentHeight(); }
     154    int contentLogicalHeight() const { return style()->isHorizontalWritingMode() ? contentHeight() : contentWidth(); }
    155155
    156156    // IE extensions. Used to calculate offsetWidth/Height.  Overridden by inlines (RenderFlow)
    … …  
    273273    bool stretchesToViewport() const
    274274    {
    275         return document()->inQuirksMode() && style()->logicalHeight().isAuto() && !isFloatingOrPositioned() && (isRoot() || isBody()) && !isBlockFlowRoot();
     275        return document()->inQuirksMode() && style()->logicalHeight().isAuto() && !isFloatingOrPositioned() && (isRoot() || isBody()) && !isWritingModeRoot();
    276276    }
    277277
    278278    virtual IntSize intrinsicSize() const { return IntSize(); }
    279     int intrinsicLogicalWidth() const { return style()->isVerticalBlockFlow() ? intrinsicSize().width() : intrinsicSize().height(); }
    280     int intrinsicLogicalHeight() const { return style()->isVerticalBlockFlow() ? intrinsicSize().height() : intrinsicSize().width(); }
     279    int intrinsicLogicalWidth() const { return style()->isHorizontalWritingMode() ? intrinsicSize().width() : intrinsicSize().height(); }
     280    int intrinsicLogicalHeight() const { return style()->isHorizontalWritingMode() ? intrinsicSize().height() : intrinsicSize().width(); }
    281281
    282282    // Whether or not the element shrinks to its intrinsic width (rather than filling the width
    … …  
    302302    // There are a few cases where we need to refer specifically to the available physical width and available physical height.
    303303    // Relative positioning is one of those cases, since left/top offsets are physical.
    304     int availableWidth() const { return style()->isVerticalBlockFlow() ? availableLogicalWidth() : availableLogicalHeight(); }
    305     int availableHeight() const { return style()->isVerticalBlockFlow() ? availableLogicalHeight() : availableLogicalWidth(); }
     304    int availableWidth() const { return style()->isHorizontalWritingMode() ? availableLogicalWidth() : availableLogicalHeight(); }
     305    int availableHeight() const { return style()->isHorizontalWritingMode() ? availableLogicalHeight() : availableLogicalWidth(); }
    306306
    307307    virtual int verticalScrollbarWidth() const;
    308308    int horizontalScrollbarHeight() const;
    309     int scrollbarLogicalHeight() const { return style()->isVerticalBlockFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth(); }
     309    int scrollbarLogicalHeight() const { return style()->isHorizontalWritingMode() ? horizontalScrollbarHeight() : verticalScrollbarWidth(); }
    310310    virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Node** stopNode = 0);
    311311    bool canBeScrolledAndHasScrollableArea() const;
    … …  
    361361    virtual void markDescendantBlocksAndLinesForLayout(bool inLayout = true);
    362362   
    363     bool isBlockFlowRoot() const { return !parent() || parent()->style()->blockFlow() != style()->blockFlow(); }
     363    bool isWritingModeRoot() const { return !parent() || parent()->style()->writingMode() != style()->writingMode(); }
    364364
    365365protected:

  • trunk/WebCore/rendering/RenderFieldset.cpp

    r69184 r69220  
    142142    // cases the legend is embedded in the right and bottom borders respectively.
    143143    // https://bugs.webkit.org/show_bug.cgi?id=47236
    144     if (style()->isVerticalBlockFlow()) {
     144    if (style()->isHorizontalWritingMode()) {
    145145        int yOff = (legend->y() > 0) ? 0 : (legend->height() - borderTop()) / 2;
    146146        h -= yOff;
    … …  
    167167    // cases the legend is embedded in the right and bottom borders respectively.
    168168    // https://bugs.webkit.org/show_bug.cgi?id=47236
    169     if (style()->isVerticalBlockFlow()) {
     169    if (style()->isHorizontalWritingMode()) {
    170170        int clipTop = ty;
    171171        int clipHeight = max(static_cast<int>(style()->borderTopWidth()), legend->height());
    … …  
    196196    // cases the legend is embedded in the right and bottom borders respectively.
    197197    // https://bugs.webkit.org/show_bug.cgi?id=47236
    198     if (style()->isVerticalBlockFlow()) {
     198    if (style()->isHorizontalWritingMode()) {
    199199        int yOff = (legend->y() > 0) ? 0 : (legend->height() - borderTop()) / 2;
    200200        h -= yOff;

  • trunk/WebCore/rendering/RenderImage.cpp

    r68917 r69220  
    443443    else if (m_imageResource->usesImageContainerSize()) {
    444444        IntSize size = m_imageResource->imageSize(style()->effectiveZoom());
    445         logicalWidth = style()->isVerticalBlockFlow() ? size.width() : size.height();
     445        logicalWidth = style()->isHorizontalWritingMode() ? size.width() : size.height();
    446446    } else if (m_imageResource->imageHasRelativeWidth())
    447447        logicalWidth = 0; // If the image is relatively-sized, set the width to 0 until there is a set container size.
    … …  
    462462    else if (m_imageResource->usesImageContainerSize()) {
    463463        IntSize size = m_imageResource->imageSize(style()->effectiveZoom());
    464         logicalHeight = style()->isVerticalBlockFlow() ? size.height() : size.width();
     464        logicalHeight = style()->isHorizontalWritingMode() ? size.height() : size.width();
    465465    } else if (m_imageResource->imageHasRelativeHeight())
    466466        logicalHeight = 0; // If the image is relatively-sized, set the height to 0 until there is a set container size.

  • trunk/WebCore/rendering/RenderInline.cpp

    r68177 r69220  
    472472int RenderInline::marginLeft() const
    473473{
    474     if (!style()->isVerticalBlockFlow())
     474    if (!style()->isHorizontalWritingMode())
    475475        return 0;
    476476    return computeMargin(this, style()->marginLeft());
    … …  
    479479int RenderInline::marginRight() const
    480480{
    481     if (!style()->isVerticalBlockFlow())
     481    if (!style()->isHorizontalWritingMode())
    482482        return 0;
    483483    return computeMargin(this, style()->marginRight());
    … …  
    486486int RenderInline::marginTop() const
    487487{
    488     if (style()->isVerticalBlockFlow())
     488    if (style()->isHorizontalWritingMode())
    489489        return 0;
    490490    return computeMargin(this, style()->marginTop());
    … …  
    493493int RenderInline::marginBottom() const
    494494{
    495     if (style()->isVerticalBlockFlow())
     495    if (style()->isHorizontalWritingMode())
    496496        return 0;
    497497    return computeMargin(this, style()->marginBottom());

  • trunk/WebCore/rendering/RenderTableCell.cpp

    r68817 r69220  
    166166{
    167167    int result = RenderBlock::paddingTop();
    168     if (!includeIntrinsicPadding || !style()->isVerticalBlockFlow())
     168    if (!includeIntrinsicPadding || !style()->isHorizontalWritingMode())
    169169        return result;
    170     return result + (style()->blockFlow() == TopToBottomBlockFlow ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
     170    return result + (style()->writingMode() == TopToBottomWritingMode ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
    171171}
    172172
    … …  
    174174{
    175175    int result = RenderBlock::paddingBottom();
    176     if (!includeIntrinsicPadding || !style()->isVerticalBlockFlow())
     176    if (!includeIntrinsicPadding || !style()->isHorizontalWritingMode())
    177177        return result;
    178     return result + (style()->blockFlow() == TopToBottomBlockFlow ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
     178    return result + (style()->writingMode() == TopToBottomWritingMode ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
    179179}
    180180
    … …  
    182182{
    183183    int result = RenderBlock::paddingLeft();
    184     if (!includeIntrinsicPadding || style()->isVerticalBlockFlow())
     184    if (!includeIntrinsicPadding || style()->isHorizontalWritingMode())
    185185        return result;
    186     return result + (style()->blockFlow() == LeftToRightBlockFlow ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
     186    return result + (style()->writingMode() == LeftToRightWritingMode ? intrinsicPaddingBefore() : intrinsicPaddingAfter());
    187187   
    188188}
    … …  
    191191{   
    192192    int result = RenderBlock::paddingRight();
    193     if (!includeIntrinsicPadding || style()->isVerticalBlockFlow())
     193    if (!includeIntrinsicPadding || style()->isHorizontalWritingMode())
    194194        return result;
    195     return result + (style()->blockFlow() == LeftToRightBlockFlow ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
     195    return result + (style()->writingMode() == LeftToRightWritingMode ? intrinsicPaddingAfter() : intrinsicPaddingBefore());
    196196}
    197197

  • trunk/WebCore/rendering/RenderView.h

    r68436 r69220  
    5555    int viewHeight() const;
    5656    int viewWidth() const;
    57     int viewLogicalWidth() const { return style()->isVerticalBlockFlow() ? viewWidth() : viewHeight(); }
    58     int viewLogicalHeight() const { return style()->isVerticalBlockFlow() ? viewHeight() : viewWidth(); }
     57    int viewLogicalWidth() const { return style()->isHorizontalWritingMode() ? viewWidth() : viewHeight(); }
     58    int viewLogicalHeight() const { return style()->isHorizontalWritingMode() ? viewHeight() : viewWidth(); }
    5959
    6060    float zoomFactor() const;

  • trunk/WebCore/rendering/RootInlineBox.cpp

    r68282 r69220  
    4848    , m_paginationStrut(0)
    4949{
    50     setIsVertical(!block->style()->isVerticalBlockFlow());
     50    setIsVertical(!block->style()->isHorizontalWritingMode());
    5151}
    5252

  • trunk/WebCore/rendering/style/RenderStyle.cpp

    r68976 r69220  
    447447
    448448    // Check block flow direction.
    449     if (inherited_flags._blockFlow != other->inherited_flags._blockFlow)
     449    if (inherited_flags.m_writingMode != other->inherited_flags.m_writingMode)
    450450        return StyleDifferenceLayout;
    451451
    … …  
    10801080Length RenderStyle::logicalWidth() const
    10811081{
    1082     if (isVerticalBlockFlow())
     1082    if (isHorizontalWritingMode())
    10831083        return width();
    10841084    return height();
    … …  
    10871087Length RenderStyle::logicalHeight() const
    10881088{
    1089     if (isVerticalBlockFlow())
     1089    if (isHorizontalWritingMode())
    10901090        return height();
    10911091    return width();
    … …  
    10941094Length RenderStyle::logicalMinWidth() const
    10951095{
    1096     if (isVerticalBlockFlow())
     1096    if (isHorizontalWritingMode())
    10971097        return minWidth();
    10981098    return minHeight();
    … …  
    11011101Length RenderStyle::logicalMaxWidth() const
    11021102{
    1103     if (isVerticalBlockFlow())
     1103    if (isHorizontalWritingMode())
    11041104        return maxWidth();
    11051105    return maxHeight();
    … …  
    11081108Length RenderStyle::logicalMinHeight() const
    11091109{
    1110     if (isVerticalBlockFlow())
     1110    if (isHorizontalWritingMode())
    11111111        return minHeight();
    11121112    return minWidth();
    … …  
    11151115Length RenderStyle::logicalMaxHeight() const
    11161116{
    1117     if (isVerticalBlockFlow())
     1117    if (isHorizontalWritingMode())
    11181118        return maxHeight();
    11191119    return maxWidth();
    … …  
    11221122unsigned short RenderStyle::borderBeforeWidth() const
    11231123{
    1124     switch (blockFlow()) {
    1125     case TopToBottomBlockFlow:
     1124    switch (writingMode()) {
     1125    case TopToBottomWritingMode:
    11261126        return borderTopWidth();
    1127     case BottomToTopBlockFlow:
     1127    case BottomToTopWritingMode:
    11281128        return borderBottomWidth();
    1129     case LeftToRightBlockFlow:
     1129    case LeftToRightWritingMode:
    11301130        return borderLeftWidth();
    1131     case RightToLeftBlockFlow:
     1131    case RightToLeftWritingMode:
    11321132        return borderRightWidth();
    11331133    }
    … …  
    11381138unsigned short RenderStyle::borderAfterWidth() const
    11391139{
    1140     switch (blockFlow()) {
    1141     case TopToBottomBlockFlow:
     1140    switch (writingMode()) {
     1141    case TopToBottomWritingMode:
    11421142        return borderBottomWidth();
    1143     case BottomToTopBlockFlow:
     1143    case BottomToTopWritingMode:
    11441144        return borderTopWidth();
    1145     case LeftToRightBlockFlow:
     1145    case LeftToRightWritingMode:
    11461146        return borderRightWidth();
    1147     case RightToLeftBlockFlow:
     1147    case RightToLeftWritingMode:
    11481148        return borderLeftWidth();
    11491149    }
    … …  
    11541154unsigned short RenderStyle::borderStartWidth() const
    11551155{
    1156     if (isVerticalBlockFlow())
     1156    if (isHorizontalWritingMode())
    11571157        return isLeftToRightDirection() ? borderLeftWidth() : borderRightWidth();
    11581158    return isLeftToRightDirection() ? borderTopWidth() : borderBottomWidth();
    … …  
    11611161unsigned short RenderStyle::borderEndWidth() const
    11621162{
    1163     if (isVerticalBlockFlow())
     1163    if (isHorizontalWritingMode())
    11641164        return isLeftToRightDirection() ? borderRightWidth() : borderLeftWidth();
    11651165    return isLeftToRightDirection() ? borderBottomWidth() : borderTopWidth();
    … …  
    11681168Length RenderStyle::marginBefore() const
    11691169{
    1170     switch (blockFlow()) {
    1171     case TopToBottomBlockFlow:
     1170    switch (writingMode()) {
     1171    case TopToBottomWritingMode:
    11721172        return marginTop();
    1173     case BottomToTopBlockFlow:
     1173    case BottomToTopWritingMode:
    11741174        return marginBottom();
    1175     case LeftToRightBlockFlow:
     1175    case LeftToRightWritingMode:
    11761176        return marginLeft();
    1177     case RightToLeftBlockFlow:
     1177    case RightToLeftWritingMode:
    11781178        return marginRight();
    11791179    }
    … …  
    11841184Length RenderStyle::marginAfter() const
    11851185{
    1186     switch (blockFlow()) {
    1187     case TopToBottomBlockFlow:
     1186    switch (writingMode()) {
     1187    case TopToBottomWritingMode:
    11881188        return marginBottom();
    1189     case BottomToTopBlockFlow:
     1189    case BottomToTopWritingMode:
    11901190        return marginTop();
    1191     case LeftToRightBlockFlow:
     1191    case LeftToRightWritingMode:
    11921192        return marginRight();
    1193     case RightToLeftBlockFlow:
     1193    case RightToLeftWritingMode:
    11941194        return marginLeft();
    11951195    }
    … …  
    12001200Length RenderStyle::marginBeforeUsing(const RenderStyle* otherStyle) const
    12011201{
    1202     switch (otherStyle->blockFlow()) {
    1203     case TopToBottomBlockFlow:
     1202    switch (otherStyle->writingMode()) {
     1203    case TopToBottomWritingMode:
    12041204        return marginTop();
    1205     case BottomToTopBlockFlow:
     1205    case BottomToTopWritingMode:
    12061206        return marginBottom();
    1207     case LeftToRightBlockFlow:
     1207    case LeftToRightWritingMode:
    12081208        return marginLeft();
    1209     case RightToLeftBlockFlow:
     1209    case RightToLeftWritingMode:
    12101210        return marginRight();
    12111211    }
    … …  
    12161216Length RenderStyle::marginAfterUsing(const RenderStyle* otherStyle) const
    12171217{
    1218     switch (otherStyle->blockFlow()) {
    1219     case TopToBottomBlockFlow:
     1218    switch (otherStyle->writingMode()) {
     1219    case TopToBottomWritingMode:
    12201220        return marginBottom();
    1221     case BottomToTopBlockFlow:
     1221    case BottomToTopWritingMode:
    12221222        return marginTop();
    1223     case LeftToRightBlockFlow:
     1223    case LeftToRightWritingMode:
    12241224        return marginRight();
    1225     case RightToLeftBlockFlow:
     1225    case RightToLeftWritingMode:
    12261226        return marginLeft();
    12271227    }
    … …  
    12321232Length RenderStyle::marginStart() const
    12331233{
    1234     if (isVerticalBlockFlow())
     1234    if (isHorizontalWritingMode())
    12351235        return isLeftToRightDirection() ? marginLeft() : marginRight();
    12361236    return isLeftToRightDirection() ? marginTop() : marginBottom();
    … …  
    12391239Length RenderStyle::marginEnd() const
    12401240{
    1241     if (isVerticalBlockFlow())
     1241    if (isHorizontalWritingMode())
    12421242        return isLeftToRightDirection() ? marginRight() : marginLeft();
    12431243    return isLeftToRightDirection() ? marginBottom() : marginTop();
    … …  
    12461246Length RenderStyle::marginStartUsing(const RenderStyle* otherStyle) const
    12471247{
    1248     if (otherStyle->isVerticalBlockFlow())
     1248    if (otherStyle->isHorizontalWritingMode())
    12491249        return otherStyle->isLeftToRightDirection() ? marginLeft() : marginRight();
    12501250    return otherStyle->isLeftToRightDirection() ? marginTop() : marginBottom();
    … …  
    12531253Length RenderStyle::marginEndUsing(const RenderStyle* otherStyle) const
    12541254{
    1255     if (otherStyle->isVerticalBlockFlow())
     1255    if (otherStyle->isHorizontalWritingMode())
    12561256        return otherStyle->isLeftToRightDirection() ? marginRight() : marginLeft();
    12571257    return otherStyle->isLeftToRightDirection() ? marginBottom() : marginTop();
    … …  
    12601260Length RenderStyle::paddingBefore() const
    12611261{
    1262     switch (blockFlow()) {
    1263     case TopToBottomBlockFlow:
     1262    switch (writingMode()) {
     1263    case TopToBottomWritingMode:
    12641264        return paddingTop();
    1265     case BottomToTopBlockFlow:
     1265    case BottomToTopWritingMode:
    12661266        return paddingBottom();
    1267     case LeftToRightBlockFlow:
     1267    case LeftToRightWritingMode:
    12681268        return paddingLeft();
    1269     case RightToLeftBlockFlow:
     1269    case RightToLeftWritingMode:
    12701270        return paddingRight();
    12711271    }
    … …  
    12761276Length RenderStyle::paddingAfter() const
    12771277{
    1278     switch (blockFlow()) {
    1279     case TopToBottomBlockFlow:
     1278    switch (writingMode()) {
     1279    case TopToBottomWritingMode:
    12801280        return paddingBottom();
    1281     case BottomToTopBlockFlow:
     1281    case BottomToTopWritingMode:
    12821282        return paddingTop();
    1283     case LeftToRightBlockFlow:
     1283    case LeftToRightWritingMode:
    12841284        return paddingRight();
    1285     case RightToLeftBlockFlow:
     1285    case RightToLeftWritingMode:
    12861286        return paddingLeft();
    12871287    }
    … …  
    12921292Length RenderStyle::paddingStart() const
    12931293{
    1294     if (isVerticalBlockFlow())
     1294    if (isHorizontalWritingMode())
    12951295        return isLeftToRightDirection() ? paddingLeft() : paddingRight();
    12961296    return isLeftToRightDirection() ? paddingTop() : paddingBottom();
    … …  
    12991299Length RenderStyle::paddingEnd() const
    13001300{
    1301     if (isVerticalBlockFlow())
     1301    if (isHorizontalWritingMode())
    13021302        return isLeftToRightDirection() ? paddingRight() : paddingLeft();
    13031303    return isLeftToRightDirection() ? paddingBottom() : paddingTop();

  • trunk/WebCore/rendering/style/RenderStyle.h

    r68899 r69220  
    179179                   (_pointerEvents == other._pointerEvents) &&
    180180                   (_insideLink == other._insideLink) &&
    181                    (_blockFlow == other._blockFlow);
     181                   (m_writingMode == other.m_writingMode);
    182182        }
    183183
    … …  
    207207
    208208        // CSS Text Layout Module Level 3: Vertical writing support
    209         unsigned _blockFlow : 2; // EBlockFlowDirection
     209        unsigned m_writingMode : 2; // WritingMode
    210210        // 45 bits
    211211    } inherited_flags;
    … …  
    284284        inherited_flags._pointerEvents = initialPointerEvents();
    285285        inherited_flags._insideLink = NotInsideLink;
    286         inherited_flags._blockFlow = initialBlockFlow();
     286        inherited_flags.m_writingMode = initialWritingMode();
    287287
    288288        noninherited_flags._effectiveDisplay = noninherited_flags._originalDisplay = initialDisplay();
    … …  
    744744    ETextSecurity textSecurity() const { return static_cast<ETextSecurity>(rareInheritedData->textSecurity); }
    745745
    746     EBlockFlowDirection blockFlow() const { return static_cast<EBlockFlowDirection>(inherited_flags._blockFlow); }
    747     bool isVerticalBlockFlow() const { return blockFlow() == TopToBottomBlockFlow || blockFlow() == BottomToTopBlockFlow; }
     746    WritingMode writingMode() const { return static_cast<WritingMode>(inherited_flags.m_writingMode); }
     747    bool isHorizontalWritingMode() const { return writingMode() == TopToBottomWritingMode || writingMode() == BottomToTopWritingMode; }
    748748
    749749    ESpeak speak() { return static_cast<ESpeak>(rareInheritedData->speak); }
    … …  
    11251125    }
    11261126
    1127     void setBlockFlow(EBlockFlowDirection v) { inherited_flags._blockFlow = v; }
     1127    void setWritingMode(WritingMode v) { inherited_flags.m_writingMode = v; }
    11281128
    11291129    // To tell if this style matched attribute selectors. This makes it impossible to share.
    … …  
    11661166    static EClear initialClear() { return CNONE; }
    11671167    static TextDirection initialDirection() { return LTR; }
    1168     static EBlockFlowDirection initialBlockFlow() { return TopToBottomBlockFlow; }
     1168    static WritingMode initialWritingMode() { return TopToBottomWritingMode; }
    11691169    static EDisplay initialDisplay() { return INLINE; }
    11701170    static EEmptyCell initialEmptyCells() { return SHOW; }

  • trunk/WebCore/rendering/style/RenderStyleConstants.h

    r68680 r69220  
    130130
    131131// CSS Text Layout Module Level 3: Vertical writing support
    132 enum EBlockFlowDirection {
    133     TopToBottomBlockFlow, RightToLeftBlockFlow, LeftToRightBlockFlow, BottomToTopBlockFlow
     132enum WritingMode {
     133    TopToBottomWritingMode, RightToLeftWritingMode, LeftToRightWritingMode, BottomToTopWritingMode
    134134};
    135135

  • trunk/WebCore/rendering/style/SVGRenderStyle.h

    r68976 r69220  
    6868    static EShapeRendering initialShapeRendering() { return SR_AUTO; }
    6969    static ETextAnchor initialTextAnchor() { return TA_START; }
    70     static EWritingMode initialWritingMode() { return WM_LRTB; }
     70    static SVGWritingMode initialWritingMode() { return WM_LRTB; }
    7171    static EGlyphOrientation initialGlyphOrientationHorizontal() { return GO_0DEG; }
    7272    static EGlyphOrientation initialGlyphOrientationVertical() { return GO_AUTO; }
    … …  
    133133    void setShapeRendering(EShapeRendering val) { svg_inherited_flags._shapeRendering = val; }
    134134    void setTextAnchor(ETextAnchor val) { svg_inherited_flags._textAnchor = val; }
    135     void setWritingMode(EWritingMode val) { svg_inherited_flags._writingMode = val; }
     135    void setWritingMode(SVGWritingMode val) { svg_inherited_flags._writingMode = val; }
    136136    void setGlyphOrientationHorizontal(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationHorizontal = val; }
    137137    void setGlyphOrientationVertical(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationVertical = val; }
    … …  
    282282    EShapeRendering shapeRendering() const { return (EShapeRendering) svg_inherited_flags._shapeRendering; }
    283283    ETextAnchor textAnchor() const { return (ETextAnchor) svg_inherited_flags._textAnchor; }
    284     EWritingMode writingMode() const { return (EWritingMode) svg_inherited_flags._writingMode; }
     284    SVGWritingMode writingMode() const { return (SVGWritingMode) svg_inherited_flags._writingMode; }
    285285    EGlyphOrientation glyphOrientationHorizontal() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationHorizontal; }
    286286    EGlyphOrientation glyphOrientationVertical() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationVertical; }
    … …  
    352352        unsigned _colorInterpolation : 2; // EColorInterpolation
    353353        unsigned _colorInterpolationFilters : 2; // EColorInterpolation
    354         unsigned _writingMode : 3; // EWritingMode
     354        unsigned _writingMode : 3; // SVGWritingMode
    355355        unsigned _glyphOrientationHorizontal : 3; // EGlyphOrientation
    356356        unsigned _glyphOrientationVertical : 3; // EGlyphOrientation

  • trunk/WebCore/rendering/style/SVGRenderStyleDefs.h

    r64830 r69220  
    6565    };
    6666
    67     enum EWritingMode {
     67    enum SVGWritingMode {
    6868        WM_LRTB, WM_LR, WM_RLTB, WM_RL, WM_TBRL, WM_TB
    6969    };
Note: See TracChangeset for help on using the changeset viewer.