Changeset 95750 in webkit


Ignore:
Timestamp:
Sep 22, 2011 1:50:41 PM (13 years ago)
Author:
hyatt@apple.com
Message:

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

Make determineStartPosition smart enough to not skip over clean lines that have moved to a new
region with a different available content logical width. When this happens, we go ahead and treat
the line as dirty.

Reviewed by Sam Weinig.

Source/WebCore:

Covered by existing fast/regions tests.

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::layoutBlock):
Disable region fitting if we detect that the regions all have uniform widths. In this case we know
the content width can't vary, so there's no reason to waste time worrying about it.

(WebCore::RenderBlock::computeLogicalLocationForFloat):
Pull the content width checking code into computeLogicalLocationForFloat, since we've incorporated
region fitting into the fixed offsets now rather than the line functions.

(WebCore::RenderBlock::positionNewFloats):
Changed because more code moved from here into computeLogicalLocationForFloat.

(WebCore::RenderBlock::adjustForRegionFittingIfNeeded):
No changes. Just moved the function above the left offset function.

(WebCore::RenderBlock::logicalLeftOffsetForContent):
(WebCore::RenderBlock::logicalRightOffsetForContent):
Added. These new functions give the fixed left and right offsets for lines in a particular region.
When no regions are present or when all the regions have a uniform width, they are identical
to the versions of the functions that take no arguments.

(WebCore::RenderBlock::logicalRightOffsetForLine):
Changed to no longer do region fitting, since that's built into logicalRightOffsetForContent now.

(WebCore::RenderBlock::lineWidthForPaginatedLineChanged):
New function that takes a root line box and compares its cached old content width with the width
available at the line's new location.

  • rendering/RenderBlock.h:

(WebCore::RenderBlock::logicalRightOffsetForLine):
(WebCore::RenderBlock::logicalLeftOffsetForLine):
Modified to call the logicalXXXOffsetForContent functions that take a block direction position.

(WebCore::RenderBlock::logicalRightOffsetForContent):
(WebCore::RenderBlock::logicalLeftOffsetForContent):
Added the new functions that take a position so that they can fit to the correct region.

(WebCore::RenderBlock::availableLogicalWidthForContent):
New helper function that calls right - left (similar to the corresponding line function that includes
floats).

  • rendering/RenderBlockLineLayout.cpp:

(WebCore::RenderBlock::determineStartPosition):
Patched to check if a line has moved to a place with a different available content width. If so, the line
is dirtied so that line layout can re-run.

  • rendering/RootInlineBox.cpp:

(WebCore::RootInlineBox::RootInlineBox):
(WebCore::RootInlineBox::alignBoxesInBlockDirection):
Sets the paginated line width from the current block logical height.

  • rendering/RootInlineBox.h:

(WebCore::RootInlineBox::paginationStrut):
(WebCore::RootInlineBox::setPaginationStrut):
Fixed paginationStrut to be LayoutUnit instead of int.

(WebCore::RootInlineBox::paginatedLineWidth):
(WebCore::RootInlineBox::setPaginatedLineWidth):
Added paginatedLineWidth getter/setter for caching the content width for a given root line.

LayoutTests:

  • platform/mac/fast/regions/webkit-flow-floats-inside-regions-bounds-expected.png:
  • platform/mac/fast/regions/webkit-flow-floats-inside-regions-bounds-expected.txt:
  • platform/mac/fast/regions/webkit-flow-inlines-inside-regions-bounds-expected.png:
  • platform/mac/fast/regions/webkit-flow-inlines-inside-regions-bounds-expected.txt:
Location:
trunk
Files:
1 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r95746 r95750  
     12011-09-22  David Hyatt  <hyatt@apple.com>
     2
     3        https://bugs.webkit.org/show_bug.cgi?id=68650
     4       
     5        Make determineStartPosition smart enough to not skip over clean lines that have moved to a new
     6        region with a different available content logical width. When this happens, we go ahead and treat
     7        the line as dirty.
     8
     9        Reviewed by Sam Weinig.
     10
     11        * platform/mac/fast/regions/webkit-flow-floats-inside-regions-bounds-expected.png:
     12        * platform/mac/fast/regions/webkit-flow-floats-inside-regions-bounds-expected.txt:
     13        * platform/mac/fast/regions/webkit-flow-inlines-inside-regions-bounds-expected.png:
     14        * platform/mac/fast/regions/webkit-flow-inlines-inside-regions-bounds-expected.txt:
     15
    1162011-09-22  Robert Hogan  <robert@webkit.org>
    217

  • trunk/LayoutTests/platform/mac/fast/regions/webkit-flow-floats-inside-regions-bounds-expected.txt

    r95741 r95750  
    2424              RenderBlock (anonymous) at (1,84) size 266x90
    2525                RenderText {#text} at (0,0) size 266x90
    26                   text run at (0,0) width 166: "This line of text should"
    27                   text run at (0,18) width 194: "not get out of the region. This"
    28                   text run at (0,36) width 194: "line of text should not get out"
    29                   text run at (0,54) width 266: "of the region. This line of text should not"
    30                   text run at (0,72) width 131: "get out of the region."
     26                  text run at (0,0) width 194: "This line of text should not get"
     27                  text run at (0,18) width 194: "out of the region. This line of"
     28                  text run at (0,36) width 194: "text should not get out of the"
     29                  text run at (0,54) width 266: "region. This line of text should not get out"
     30                  text run at (0,72) width 84: "of the region."
    3131              RenderBlock {P} at (1,190) size 266x0
    3232              RenderBlock {P} at (1,190) size 266x128

  • trunk/LayoutTests/platform/mac/fast/regions/webkit-flow-inlines-inside-regions-bounds-expected.txt

    r95741 r95750  
    1212    layer at (0,0) size 300x400
    1313      RenderFlowThread at (0,0) size 300x400
    14         RenderBlock {DIV} at (0,0) size 300x349
    15           RenderBlock {DIV} at (5,5) size 290x339 [border: (1px solid #0000FF)]
    16             RenderBlock {DIV} at (11,11) size 268x317 [border: (1px solid #008000)]
     14        RenderBlock {DIV} at (0,0) size 300x385
     15          RenderBlock {DIV} at (5,5) size 290x375 [border: (1px solid #0000FF)]
     16            RenderBlock {DIV} at (11,11) size 268x353 [border: (1px solid #008000)]
    1717              RenderBlock {P} at (1,17) size 266x121
    1818                RenderText {#text} at (0,0) size 266x121
    … …  
    3030                  text run at (0,54) width 266: "get out of the region. This line of text"
    3131                  text run at (0,72) width 201: "should not get out of the region."
    32               RenderBlock {P} at (1,264) size 266x36
    33                 RenderText {#text} at (0,0) size 266x36
    34                   text run at (0,0) width 266: "This line of text should not get out of the"
    35                   text run at (0,18) width 44: "region."
     32              RenderBlock {P} at (1,264) size 266x72
     33                RenderText {#text} at (0,0) size 86x72
     34                  text run at (0,0) width 86: "This line of"
     35                  text run at (0,18) width 86: "text should"
     36                  text run at (0,36) width 86: "not get out of"
     37                  text run at (0,54) width 67: "the region."
    3638  Regions for flow 'flow1'
    3739    RenderRegion {DIV} #region1 with index 0

  • trunk/Source/WebCore/ChangeLog

    r95749 r95750  
     12011-09-22  David Hyatt  <hyatt@apple.com>
     2
     3        https://bugs.webkit.org/show_bug.cgi?id=68650
     4       
     5        Make determineStartPosition smart enough to not skip over clean lines that have moved to a new
     6        region with a different available content logical width. When this happens, we go ahead and treat
     7        the line as dirty.
     8
     9        Reviewed by Sam Weinig.
     10
     11        Covered by existing fast/regions tests.
     12
     13        * rendering/RenderBlock.cpp:
     14        (WebCore::RenderBlock::layoutBlock):
     15        Disable region fitting if we detect that the regions all have uniform widths. In this case we know
     16        the content width can't vary, so there's no reason to waste time worrying about it.
     17
     18        (WebCore::RenderBlock::computeLogicalLocationForFloat):
     19        Pull the content width checking code into computeLogicalLocationForFloat, since we've incorporated
     20        region fitting into the fixed offsets now rather than the line functions.
     21
     22        (WebCore::RenderBlock::positionNewFloats):
     23        Changed because more code moved from here into computeLogicalLocationForFloat.
     24       
     25        (WebCore::RenderBlock::adjustForRegionFittingIfNeeded):
     26        No changes. Just moved the function above the left offset function.
     27
     28        (WebCore::RenderBlock::logicalLeftOffsetForContent):
     29        (WebCore::RenderBlock::logicalRightOffsetForContent):
     30        Added. These new functions give the fixed left and right offsets for lines in a particular region.
     31        When no regions are present or when all the regions have a uniform width, they are identical
     32        to the versions of the functions that take no arguments.
     33
     34        (WebCore::RenderBlock::logicalRightOffsetForLine):
     35        Changed to no longer do region fitting, since that's built into logicalRightOffsetForContent now.
     36
     37        (WebCore::RenderBlock::lineWidthForPaginatedLineChanged):
     38        New function that takes a root line box and compares its cached old content width with the width
     39        available at the line's new location.
     40   
     41        * rendering/RenderBlock.h:
     42        (WebCore::RenderBlock::logicalRightOffsetForLine):
     43        (WebCore::RenderBlock::logicalLeftOffsetForLine):
     44        Modified to call the logicalXXXOffsetForContent functions that take a block direction position.
     45
     46        (WebCore::RenderBlock::logicalRightOffsetForContent):
     47        (WebCore::RenderBlock::logicalLeftOffsetForContent):
     48        Added the new functions that take a position so that they can fit to the correct region.
     49
     50        (WebCore::RenderBlock::availableLogicalWidthForContent):
     51        New helper function that calls right - left (similar to the corresponding line function that includes
     52        floats).
     53
     54        * rendering/RenderBlockLineLayout.cpp:
     55        (WebCore::RenderBlock::determineStartPosition):
     56        Patched to check if a line has moved to a place with a different available content width. If so, the line
     57        is dirtied so that line layout can re-run.
     58
     59        * rendering/RootInlineBox.cpp:
     60        (WebCore::RootInlineBox::RootInlineBox):
     61        (WebCore::RootInlineBox::alignBoxesInBlockDirection):
     62        Sets the paginated line width from the current block logical height.
     63
     64        * rendering/RootInlineBox.h:
     65        (WebCore::RootInlineBox::paginationStrut):
     66        (WebCore::RootInlineBox::setPaginationStrut):
     67        Fixed paginationStrut to be LayoutUnit instead of int.
     68
     69        (WebCore::RootInlineBox::paginatedLineWidth):
     70        (WebCore::RootInlineBox::setPaginatedLineWidth):
     71        Added paginatedLineWidth getter/setter for caching the content width for a given root line.
     72
    1732011-09-21  Anders Carlsson  <andersca@apple.com>
    274

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r95724 r95750  
    12191219    LayoutStateMaintainer statePusher(renderView, this, locationOffset(), hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged, colInfo);
    12201220
    1221     bool disableRegionFitting = renderView->hasRenderFlowThread() && (hasColumns() || (isPositioned() && !isRenderFlowThread()) || isFloating());
     1221    bool disableRegionFitting = renderView->hasRenderFlowThread() && (renderView->currentRenderFlowThread()->regionsHaveUniformLogicalWidth()
     1222        || hasColumns() || (isPositioned() && !isRenderFlowThread()) || isFloating());
    12221223    RegionFittingDisabler regionFittingDisabler(renderView->currentRenderFlowThread(), disableRegionFitting);
    12231224
    … …  
    32703271}
    32713272
    3272 LayoutPoint RenderBlock::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset,
    3273     LayoutUnit logicalLeftOffset, LayoutUnit logicalRightOffset, LayoutUnit floatLogicalWidth) const
     3273LayoutPoint RenderBlock::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset) const
    32743274{
    32753275    RenderBox* childBox = floatingObject->renderer();
    3276 
     3276    LayoutUnit logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
     3277    LayoutUnit logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
     3278    LayoutUnit floatLogicalWidth = logicalWidthForFloat(floatingObject); // The width we look for.
     3279    if (logicalRightOffset - logicalLeftOffset < floatLogicalWidth)
     3280        floatLogicalWidth = logicalRightOffset - logicalLeftOffset; // Never look for more than what will be available.
     3281       
    32773282    LayoutUnit floatLogicalLeft;
    32783283
    … …  
    33503355        LayoutUnit childLogicalLeftMargin = style()->isLeftToRightDirection() ? marginStartForChild(childBox) : marginEndForChild(childBox);
    33513356
    3352         LayoutUnit rightOffset = logicalRightOffsetForContent(); // Constant part of right offset.
    3353         LayoutUnit leftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.
    3354         LayoutUnit floatLogicalWidth = logicalWidthForFloat(floatingObject); // The width we look for.
    3355         if (rightOffset - leftOffset < floatLogicalWidth)
    3356             floatLogicalWidth = rightOffset - leftOffset; // Never look for more than what will be available.
    3357        
    33583357        LayoutRect oldRect(childBox->x(), childBox->y() , childBox->width(), childBox->height());
    33593358
    … …  
    33633362            logicalTop = max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);
    33643363
    3365         LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, logicalTop, leftOffset, rightOffset, floatLogicalWidth);
     3364        LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, logicalTop);
    33663365
    33673366        setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
    … …  
    33913390                floatingObject->m_paginationStrut = newLogicalTop - floatLogicalLocation.y();
    33923391
    3393                 floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop, leftOffset, rightOffset, floatLogicalWidth);
     3392                floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop);
    33943393                setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
    33953394                setLogicalLeftForChild(childBox, floatLogicalLocation.x() + childLogicalLeftMargin);
    … …  
    35393538}
    35403539
     3540void RenderBlock::adjustForRegionFittingIfNeeded(LayoutUnit logicalTop, LayoutUnit& rightOffset) const
     3541{
     3542    RenderView* renderView = view();
     3543    if (!renderView->hasRenderFlowThread())
     3544        return;
     3545   
     3546    RenderFlowThread* flowThread = renderView->currentRenderFlowThread();
     3547    if (!flowThread->isRegionFittingEnabled() || !flowThread->hasValidRegions())
     3548        return;
     3549
     3550    LayoutUnit regionWidth = flowThread->regionLogicalWidthForLine(logicalPageOffset() + logicalTop);
     3551    rightOffset -= flowThread->logicalWidth() - regionWidth;
     3552}
     3553
     3554LayoutUnit RenderBlock::logicalLeftOffsetForContent(LayoutUnit) const
     3555{
     3556    // FIXME: For now we don't adjust this at all. Eventually when we have RTL blocks or centered blocks, where the left offset
     3557    // can shift, then we will have to make an adjustment.
     3558    return logicalLeftOffsetForContent();
     3559}
     3560
     3561LayoutUnit RenderBlock::logicalRightOffsetForContent(LayoutUnit position) const
     3562{
     3563    LayoutUnit logicalRightOffset = logicalRightOffsetForContent();
     3564    adjustForRegionFittingIfNeeded(position, logicalRightOffset);
     3565    return logicalRightOffset;
     3566}
     3567
    35413568LayoutUnit RenderBlock::logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
    35423569{
    … …  
    35563583}
    35573584
    3558 void RenderBlock::adjustForRegionFittingIfNeeded(LayoutUnit logicalTop, LayoutUnit& rightOffset) const
    3559 {
    3560     RenderView* renderView = view();
    3561     if (!renderView->hasRenderFlowThread())
    3562         return;
    3563    
    3564     RenderFlowThread* flowThread = renderView->currentRenderFlowThread();
    3565     if (!flowThread->isRegionFittingEnabled() || !flowThread->hasValidRegions())
    3566         return;
    3567 
    3568     LayoutUnit regionWidth = flowThread->regionLogicalWidthForLine(logicalPageOffset() + logicalTop);
    3569     rightOffset -= flowThread->logicalWidth() - regionWidth;
    3570 }
    3571 
    35723585LayoutUnit RenderBlock::logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
    35733586{
    35743587    LayoutUnit right = fixedOffset;
    3575     adjustForRegionFittingIfNeeded(logicalTop, right);
    3576 
    35773588    if (m_floatingObjects && m_floatingObjects->hasRightObjects()) {
    35783589        if (heightRemaining)
    … …  
    63396350}
    63406351
     6352bool RenderBlock::lineWidthForPaginatedLineChanged(RootInlineBox* rootBox) const
     6353{
     6354    if (!view()->hasRenderFlowThread() || view()->currentRenderFlowThread()->regionsHaveUniformLogicalWidth())
     6355        return false;
     6356
     6357    return rootBox->paginatedLineWidth() != availableLogicalWidthForContent(rootBox->lineTopWithLeading());
     6358}
     6359
    63416360LayoutUnit RenderBlock::collapsedMarginBeforeForChild(RenderBox* child) const
    63426361{

  • trunk/Source/WebCore/rendering/RenderBlock.h

    r95726 r95750  
    127127
    128128    LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool firstLine) const;
    129     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool firstLine) const { return logicalRightOffsetForLine(position, logicalRightOffsetForContent(), firstLine); }
    130     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool firstLine) const { return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(), firstLine); }
     129    LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool firstLine) const { return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), firstLine); }
     130    LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool firstLine) const { return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), firstLine); }
    131131    LayoutUnit startOffsetForLine(LayoutUnit position, bool firstLine) const { return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, firstLine) : width() - logicalRightOffsetForLine(position, firstLine); }
    132132    LayoutUnit startAlignedOffsetForLine(RenderBox* child, LayoutUnit position, bool firstLine);
    … …  
    260260    virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { };
    261261
    262     int logicalRightOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() + availableLogicalWidth() : borderTop() + paddingTop() + availableLogicalWidth(); }
    263     int logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
     262    LayoutUnit logicalRightOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() + availableLogicalWidth() : borderTop() + paddingTop() + availableLogicalWidth(); }
     263    LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
     264
     265    LayoutUnit logicalLeftOffsetForContent(LayoutUnit position) const;
     266    LayoutUnit logicalRightOffsetForContent(LayoutUnit position) const;
     267    LayoutUnit availableLogicalWidthForContent(LayoutUnit position) const { return max(0, logicalRightOffsetForContent(position) - logicalLeftOffsetForContent(position)); }
    264268
    265269#ifndef NDEBUG
    … …  
    556560    }
    557561
    558     LayoutPoint computeLogicalLocationForFloat(const FloatingObject*, LayoutUnit logicalTopOffset, LayoutUnit logicalLeftOffset,
    559         LayoutUnit logicalRightOffset, LayoutUnit floatLogicalWidth) const;
     562    LayoutPoint computeLogicalLocationForFloat(const FloatingObject*, LayoutUnit logicalTopOffset) const;
    560563
    561564    // The following functions' implementations are in RenderBlockLineLayout.cpp.
    … …  
    826829    LayoutUnit adjustBlockChildForPagination(LayoutUnit logicalTopAfterClear, LayoutUnit estimateWithoutPagination, RenderBox* child, bool atBeforeSideOfBlock);
    827830
     831    // This function is called to test a line box that has moved in the block direction to see if it has ended up in a new
     832    // region/page/column that has a different available line width than the old one. Used to know when you have to dirty a
     833    // line, i.e., that it can't be re-used.
     834    bool lineWidthForPaginatedLineChanged(RootInlineBox*) const;
     835
    828836    struct FloatingObjectHashFunctions {
    829837        static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->m_renderer); }

  • trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

    r95726 r95750  
    12361236            trailingFloatsLineBox->alignBoxesInBlockDirection(blockLogicalHeight, textBoxDataMap, verticalPositionCache);
    12371237            trailingFloatsLineBox->setLineTopBottomPositions(blockLogicalHeight, blockLogicalHeight, blockLogicalHeight, blockLogicalHeight);
     1238            trailingFloatsLineBox->setPaginatedLineWidth(availableLogicalWidthForContent(blockLogicalHeight));
    12381239            IntRect logicalLayoutOverflow(0, blockLogicalHeight, 1, bottomLayoutOverflow - blockLogicalHeight);
    12391240            IntRect logicalVisualOverflow(0, blockLogicalHeight, 1, bottomVisualOverflow - blockLogicalHeight);
    … …  
    14021403        for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
    14031404            if (paginated) {
     1405                if (lineWidthForPaginatedLineChanged(curr)) {
     1406                    curr->markDirty();
     1407                    break;
     1408                }
    14041409                paginationDelta -= curr->paginationStrut();
    14051410                adjustLinePositionForPagination(curr, paginationDelta);

  • trunk/Source/WebCore/rendering/RootInlineBox.cpp

    r94710 r95750  
    5252    , m_lineBottomWithLeading(0)
    5353    , m_paginationStrut(0)
     54    , m_paginatedLineWidth(0)
    5455    , m_baselineType(AlphabeticBaseline)
    5556    , m_hasAnnotationsBefore(false)
    … …  
    277278
    278279    setLineTopBottomPositions(lineTop, lineBottom, heightOfBlock, heightOfBlock + maxHeight);
     280    setPaginatedLineWidth(block()->availableLogicalWidthForContent(heightOfBlock));
    279281
    280282    int annotationsAdjustment = beforeAnnotationsAdjustment();

  • trunk/Source/WebCore/rendering/RootInlineBox.h

    r94710 r95750  
    5454    LayoutUnit lineBottomWithLeading() const { return m_lineBottomWithLeading; }
    5555   
    56     int paginationStrut() const { return m_paginationStrut; }
    57     void setPaginationStrut(int s) { m_paginationStrut = s; }
     56    LayoutUnit paginationStrut() const { return m_paginationStrut; }
     57    void setPaginationStrut(LayoutUnit s) { m_paginationStrut = s; }
     58
     59    LayoutUnit paginatedLineWidth() const { return m_paginatedLineWidth; }
     60    void setPaginatedLineWidth(LayoutUnit width) { m_paginatedLineWidth = width; }
    5861
    5962    LayoutUnit selectionTop() const;
    … …  
    194197    LayoutUnit m_lineBottomWithLeading;
    195198
    196     int m_paginationStrut;
     199    LayoutUnit m_paginationStrut;
     200    LayoutUnit m_paginatedLineWidth;
    197201
    198202    // Floats hanging off the line are pushed into this vector during layout. It is only
Note: See TracChangeset for help on using the changeset viewer.