Changeset 74048 in webkit


Ignore:
Timestamp:
Dec 14, 2010 11:58:38 AM (13 years ago)
Author:
hyatt@apple.com
Message:

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

Reviewed by Tim Hatcher.

Rename pageHeight variables and members in WebCore to pageLogicalHeight in preparation for
making printing and pagination work with vertical writing modes.

  • page/FrameView.cpp:

(WebCore::FrameView::forceLayoutForPagination):

  • rendering/LayoutState.cpp:

(WebCore::LayoutState::LayoutState):
(WebCore::LayoutState::clearPaginationInformation):

  • rendering/LayoutState.h:

(WebCore::LayoutState::LayoutState):
(WebCore::LayoutState::isPaginated):
(WebCore::LayoutState::pageLogicalHeight):
(WebCore::LayoutState::pageLogicalHeightChanged):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::layoutBlock):
(WebCore::RenderBlock::markForPaginationRelayoutIfNeeded):
(WebCore::RenderBlock::insertFloatingObject):
(WebCore::RenderBlock::layoutColumns):
(WebCore::RenderBlock::nextPageTop):
(WebCore::RenderBlock::applyBeforeBreak):
(WebCore::RenderBlock::applyAfterBreak):
(WebCore::RenderBlock::adjustForUnsplittableChild):
(WebCore::RenderBlock::adjustLinePositionForPagination):

  • rendering/RenderBlock.h:
  • rendering/RenderBox.cpp:

(WebCore::RenderBox::computeLogicalHeight):

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::layoutBlock):

  • rendering/RenderTable.cpp:

(WebCore::RenderTable::layout):

  • rendering/RenderTableRow.cpp:

(WebCore::RenderTableRow::layout):

  • rendering/RenderTableSection.cpp:

(WebCore::RenderTableSection::layoutRows):

  • rendering/RenderView.cpp:

(WebCore::RenderView::RenderView):
(WebCore::RenderView::layout):

  • rendering/RenderView.h:

(WebCore::RenderView::pageLogicalHeight):
(WebCore::RenderView::setPageLogicalHeight):

Location:
trunk/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r74047 r74048  
     12010-12-14  David Hyatt  <hyatt@apple.com>
     2
     3        Reviewed by Tim Hatcher.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=46422
     6
     7        Rename pageHeight variables and members in WebCore to pageLogicalHeight in preparation for
     8        making printing and pagination work with vertical writing modes.
     9
     10        * page/FrameView.cpp:
     11        (WebCore::FrameView::forceLayoutForPagination):
     12        * rendering/LayoutState.cpp:
     13        (WebCore::LayoutState::LayoutState):
     14        (WebCore::LayoutState::clearPaginationInformation):
     15        * rendering/LayoutState.h:
     16        (WebCore::LayoutState::LayoutState):
     17        (WebCore::LayoutState::isPaginated):
     18        (WebCore::LayoutState::pageLogicalHeight):
     19        (WebCore::LayoutState::pageLogicalHeightChanged):
     20        * rendering/RenderBlock.cpp:
     21        (WebCore::RenderBlock::layoutBlock):
     22        (WebCore::RenderBlock::markForPaginationRelayoutIfNeeded):
     23        (WebCore::RenderBlock::insertFloatingObject):
     24        (WebCore::RenderBlock::layoutColumns):
     25        (WebCore::RenderBlock::nextPageTop):
     26        (WebCore::RenderBlock::applyBeforeBreak):
     27        (WebCore::RenderBlock::applyAfterBreak):
     28        (WebCore::RenderBlock::adjustForUnsplittableChild):
     29        (WebCore::RenderBlock::adjustLinePositionForPagination):
     30        * rendering/RenderBlock.h:
     31        * rendering/RenderBox.cpp:
     32        (WebCore::RenderBox::computeLogicalHeight):
     33        * rendering/RenderFlexibleBox.cpp:
     34        (WebCore::RenderFlexibleBox::layoutBlock):
     35        * rendering/RenderTable.cpp:
     36        (WebCore::RenderTable::layout):
     37        * rendering/RenderTableRow.cpp:
     38        (WebCore::RenderTableRow::layout):
     39        * rendering/RenderTableSection.cpp:
     40        (WebCore::RenderTableSection::layoutRows):
     41        * rendering/RenderView.cpp:
     42        (WebCore::RenderView::RenderView):
     43        (WebCore::RenderView::layout):
     44        * rendering/RenderView.h:
     45        (WebCore::RenderView::pageLogicalHeight):
     46        (WebCore::RenderView::setPageLogicalHeight):
     47
    1482010-12-14  Dimitri Glazkov  <dglazkov@chromium.org>
    249

  • trunk/WebCore/page/FrameView.cpp

    r73941 r74048  
    22322232        int pageW = ceilf(pageSize.width());
    22332233        root->setWidth(pageW);
    2234         root->setPageHeight(pageSize.height());
     2234        root->setPageLogicalHeight(pageSize.height());
    22352235        root->setNeedsLayoutAndPrefWidthsRecalc();
    22362236        forceLayout();
    … …  
    22442244            pageW = std::min<int>(docWidth, ceilf(pageSize.width() * maximumShrinkFactor));
    22452245            if (pageSize.height())
    2246                 root->setPageHeight(pageW / pageSize.width() * pageSize.height());
     2246                root->setPageLogicalHeight(pageW / pageSize.width() * pageSize.height());
    22472247            root->setWidth(pageW);
    22482248            root->setNeedsLayoutAndPrefWidthsRecalc();

  • trunk/WebCore/rendering/LayoutState.cpp

    r69628 r74048  
    3535namespace WebCore {
    3636
    37 LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const IntSize& offset, int pageHeight, bool pageHeightChanged, ColumnInfo* columnInfo)
     37LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const IntSize& offset, int pageLogicalHeight, bool pageLogicalHeightChanged, ColumnInfo* columnInfo)
    3838    : m_columnInfo(columnInfo)
    3939    , m_next(prev)
    … …  
    8383    // If we establish a new page height, then cache the offset to the top of the first page.
    8484    // We can compare this later on to figure out what part of the page we're actually on,
    85     if (pageHeight || m_columnInfo) {
    86         m_pageHeight = pageHeight;
     85    if (pageLogicalHeight || m_columnInfo) {
     86        m_pageLogicalHeight = pageLogicalHeight;
    8787        m_pageOffset = IntSize(m_layoutOffset.width() + renderer->borderLeft() + renderer->paddingLeft(),
    8888                               m_layoutOffset.height() + renderer->borderTop() + renderer->paddingTop());
    89         m_pageHeightChanged = pageHeightChanged;
     89        m_pageLogicalHeightChanged = pageLogicalHeightChanged;
    9090    } else {
    9191        // If we don't establish a new page height, then propagate the old page height and offset down.
    92         m_pageHeight = m_next->m_pageHeight;
    93         m_pageHeightChanged = m_next->m_pageHeightChanged;
     92        m_pageLogicalHeight = m_next->m_pageLogicalHeight;
     93        m_pageLogicalHeightChanged = m_next->m_pageLogicalHeightChanged;
    9494        m_pageOffset = m_next->m_pageOffset;
    9595       
    9696        // Disable pagination for objects we don't support.  For now this includes overflow:scroll/auto and inline blocks.
    9797        if (renderer->isReplaced() || renderer->scrollsOverflow())
    98             m_pageHeight = 0;
     98            m_pageLogicalHeight = 0;
    9999    }
    100100   
    … …  
    109109LayoutState::LayoutState(RenderObject* root)
    110110    : m_clipped(false)
    111     , m_pageHeight(0)
    112     , m_pageHeightChanged(false)
     111    , m_pageLogicalHeight(0)
     112    , m_pageLogicalHeightChanged(false)
    113113    , m_columnInfo(0)
    114114    , m_next(0)
    … …  
    158158void LayoutState::clearPaginationInformation()
    159159{
    160     m_pageHeight = m_next->m_pageHeight;
     160    m_pageLogicalHeight = m_next->m_pageLogicalHeight;
    161161    m_pageOffset = m_next->m_pageOffset;
    162162    m_columnInfo = m_next->m_columnInfo;

  • trunk/WebCore/rendering/LayoutState.h

    r69628 r74048  
    4242    LayoutState()
    4343        : m_clipped(false)
    44         , m_pageHeight(0)
    45         , m_pageHeightChanged(false)
     44        , m_pageLogicalHeight(0)
     45        , m_pageLogicalHeightChanged(false)
    4646        , m_columnInfo(0)
    4747        , m_next(0)
    … …  
    6565    void clearPaginationInformation();
    6666    bool isPaginatingColumns() const { return m_columnInfo; }
    67     bool isPaginated() const { return m_pageHeight || m_columnInfo; }
     67    bool isPaginated() const { return m_pageLogicalHeight || m_columnInfo; }
    6868    int pageY(int childY) const;
    6969    void addForcedColumnBreak(int childY);
    7070   
    71     bool pageHeight() const { return m_pageHeight; }
    72     bool pageHeightChanged() const { return m_pageHeightChanged; }
     71    bool pageLogicalHeight() const { return m_pageLogicalHeight; }
     72    bool pageLogicalHeightChanged() const { return m_pageLogicalHeightChanged; }
    7373
    7474private:
    … …  
    8585                           // This is a total delta accumulated from the root.
    8686
    87     int m_pageHeight; // The current page height for the pagination model that encloses us.
    88     bool m_pageHeightChanged; // If our page height has changed, this will force all blocks to relayout.
     87    int m_pageLogicalHeight; // The current page height for the pagination model that encloses us.
     88    bool m_pageLogicalHeightChanged; // If our page height has changed, this will force all blocks to relayout.
    8989    IntSize m_pageOffset; // The offset of the start of the first page in the nearest enclosing pagination model.
    9090    ColumnInfo* m_columnInfo; // If the enclosing pagination model is a column model, then this will store column information for easy retrieval/manipulation.

  • trunk/WebCore/rendering/RenderBlock.cpp

    r73385 r74048  
    11101110}
    11111111
    1112 void RenderBlock::layoutBlock(bool relayoutChildren, int pageHeight)
     1112void RenderBlock::layoutBlock(bool relayoutChildren, int pageLogicalHeight)
    11131113{
    11141114    ASSERT(needsLayout());
    … …  
    11371137    int previousHeight = logicalHeight();
    11381138    setLogicalHeight(0);
    1139     bool hasSpecifiedPageHeight = false;
    1140     bool pageHeightChanged = false;
     1139    bool hasSpecifiedPageLogicalHeight = false;
     1140    bool pageLogicalHeightChanged = false;
    11411141    ColumnInfo* colInfo = columnInfo();
    11421142    if (hasColumns()) {
    1143         if (!pageHeight) {
     1143        if (!pageLogicalHeight) {
    11441144            // We need to go ahead and set our explicit page height if one exists, so that we can
    11451145            // avoid doing two layout passes.
    … …  
    11471147            int columnHeight = contentLogicalHeight();
    11481148            if (columnHeight > 0) {
    1149                 pageHeight = columnHeight;
    1150                 hasSpecifiedPageHeight = true;
     1149                pageLogicalHeight = columnHeight;
     1150                hasSpecifiedPageLogicalHeight = true;
    11511151            }
    11521152            setLogicalHeight(0);
    11531153        }
    1154         if (colInfo->columnHeight() != pageHeight && m_everHadLayout) {
    1155             colInfo->setColumnHeight(pageHeight);
    1156             pageHeightChanged = true;
     1154        if (colInfo->columnHeight() != pageLogicalHeight && m_everHadLayout) {
     1155            colInfo->setColumnHeight(pageLogicalHeight);
     1156            pageLogicalHeightChanged = true;
    11571157        }
    11581158       
    1159         if (!hasSpecifiedPageHeight && !pageHeight)
     1159        if (!hasSpecifiedPageLogicalHeight && !pageLogicalHeight)
    11601160            colInfo->clearForcedBreaks();
    11611161    }
    11621162
    1163     LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(), pageHeight, pageHeightChanged, colInfo);
     1163    LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged, colInfo);
    11641164
    11651165    // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track
    … …  
    12131213        setLogicalHeight(lowestFloatLogicalBottom() + toAdd);
    12141214   
    1215     if (layoutColumns(hasSpecifiedPageHeight, pageHeight, statePusher))
     1215    if (layoutColumns(hasSpecifiedPageLogicalHeight, pageLogicalHeight, statePusher))
    12161216        return;
    12171217 
    … …  
    12441244    statePusher.pop();
    12451245
    1246     if (view()->layoutState()->m_pageHeight)
     1246    if (view()->layoutState()->m_pageLogicalHeight)
    12471247        setPageY(view()->layoutState()->pageY(y()));
    12481248
    … …  
    21372137        return;
    21382138
    2139     if (view()->layoutState()->pageHeightChanged() || (view()->layoutState()->pageHeight() && view()->layoutState()->pageY(y()) != pageY()))
     2139    if (view()->layoutState()->pageLogicalHeightChanged() || (view()->layoutState()->pageLogicalHeight() && view()->layoutState()->pageY(y()) != pageY()))
    21402140        setChildNeedsLayout(true, false);
    21412141}
    … …  
    30333033    // Just go ahead and lay out the float.
    30343034    bool isChildRenderBlock = o->isRenderBlock();
    3035     if (isChildRenderBlock && !o->needsLayout() && view()->layoutState()->pageHeightChanged())
     3035    if (isChildRenderBlock && !o->needsLayout() && view()->layoutState()->pageLogicalHeightChanged())
    30363036        o->setChildNeedsLayout(true, false);
    30373037       
    3038     bool affectedByPagination = isChildRenderBlock && view()->layoutState()->m_pageHeight;
     3038    bool affectedByPagination = isChildRenderBlock && view()->layoutState()->m_pageLogicalHeight;
    30393039    if (!affectedByPagination || isWritingModeRoot()) // We are unsplittable if we're a block flow root.
    30403040        o->layoutIfNeeded();
    … …  
    42224222}
    42234223
    4224 bool RenderBlock::layoutColumns(bool hasSpecifiedPageHeight, int pageHeight, LayoutStateMaintainer& statePusher)
     4224bool RenderBlock::layoutColumns(bool hasSpecifiedPageLogicalHeight, int pageLogicalHeight, LayoutStateMaintainer& statePusher)
    42254225{
    42264226    if (!hasColumns())
    … …  
    42314231    ColumnInfo* colInfo = columnInfo();
    42324232    int desiredColumnCount = colInfo->desiredColumnCount();
    4233     if (!hasSpecifiedPageHeight) {
    4234         int columnHeight = pageHeight;
     4233    if (!hasSpecifiedPageLogicalHeight) {
     4234        int columnHeight = pageLogicalHeight;
    42354235        int minColumnCount = colInfo->forcedBreaks() + 1;
    42364236        if (minColumnCount >= desiredColumnCount) {
    42374237            // The forced page breaks are in control of the balancing.  Just set the column height to the
    42384238            // maximum page break distance.
    4239             if (!pageHeight) {
     4239            if (!pageLogicalHeight) {
    42404240                int distanceBetweenBreaks = max(colInfo->maximumDistanceBetweenForcedBreaks(),
    42414241                                                view()->layoutState()->pageY(borderTop() + paddingTop() + contentHeight()) - colInfo->forcedBreakOffset());
    42424242                columnHeight = max(colInfo->minimumColumnHeight(), distanceBetweenBreaks);
    42434243            }
    4244         } else if (contentHeight() > pageHeight * desiredColumnCount) {
     4244        } else if (contentHeight() > pageLogicalHeight * desiredColumnCount) {
    42454245            // Now that we know the intrinsic height of the columns, we have to rebalance them.
    42464246            columnHeight = max(colInfo->minimumColumnHeight(), (int)ceilf((float)contentHeight() / desiredColumnCount));
    42474247        }
    42484248       
    4249         if (columnHeight && columnHeight != pageHeight) {
     4249        if (columnHeight && columnHeight != pageLogicalHeight) {
    42504250            statePusher.pop();
    42514251            m_everHadLayout = true;
    … …  
    42554255    }
    42564256   
    4257     if (pageHeight) // FIXME: Should we use lowestPosition (excluding our positioned objects) instead of contentHeight()?
    4258         colInfo->setColumnCountAndHeight(ceilf((float)contentHeight() / pageHeight), pageHeight);
     4257    if (pageLogicalHeight)
     4258        colInfo->setColumnCountAndHeight(ceilf((float)contentHeight() / pageLogicalHeight), pageLogicalHeight);
    42594259
    42604260    if (columnCount(colInfo)) {
    … …  
    57285728{
    57295729    LayoutState* layoutState = view()->layoutState();
    5730     if (!layoutState->m_pageHeight)
     5730    if (!layoutState->m_pageLogicalHeight)
    57315731        return yPos;
    57325732   
    57335733    // The yPos is in our coordinate space.  We can add in our pushed offset.
    5734     int pageHeight = layoutState->m_pageHeight;
    5735     int remainingHeight = (pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight) % pageHeight;
     5734    int pageLogicalHeight = layoutState->m_pageLogicalHeight;
     5735    int remainingHeight = (pageLogicalHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageLogicalHeight) % pageLogicalHeight;
    57365736    return yPos + remainingHeight;
    57375737}
    … …  
    57555755    // FIXME: Add page break checking here when we support printing.
    57565756    bool checkColumnBreaks = view()->layoutState()->isPaginatingColumns();
    5757     bool checkPageBreaks = !checkColumnBreaks && view()->layoutState()->m_pageHeight; // FIXME: Once columns can print we have to check this.
     5757    bool checkPageBreaks = !checkColumnBreaks && view()->layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
    57585758    bool checkBeforeAlways = (checkColumnBreaks && child->style()->columnBreakBefore() == PBALWAYS) || (checkPageBreaks && child->style()->pageBreakBefore() == PBALWAYS);
    57595759    if (checkBeforeAlways && inNormalFlow(child)) {
    … …  
    57695769    // FIXME: Add page break checking here when we support printing.
    57705770    bool checkColumnBreaks = view()->layoutState()->isPaginatingColumns();
    5771     bool checkPageBreaks = !checkColumnBreaks && view()->layoutState()->m_pageHeight; // FIXME: Once columns can print we have to check this.
     5771    bool checkPageBreaks = !checkColumnBreaks && view()->layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
    57725772    bool checkAfterAlways = (checkColumnBreaks && child->style()->columnBreakAfter() == PBALWAYS) || (checkPageBreaks && child->style()->pageBreakAfter() == PBALWAYS);
    57735773    if (checkAfterAlways && inNormalFlow(child)) {
    … …  
    57895789    if (layoutState->m_columnInfo)
    57905790        layoutState->m_columnInfo->updateMinimumColumnHeight(childHeight);
    5791     int pageHeight = layoutState->m_pageHeight;
    5792     if (!pageHeight || childHeight > pageHeight)
     5791    int pageLogicalHeight = layoutState->m_pageLogicalHeight;
     5792    if (!pageLogicalHeight || childHeight > pageLogicalHeight)
    57935793        return yPos;
    5794     int remainingHeight = (pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight) % pageHeight;
     5794    int remainingHeight = (pageLogicalHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageLogicalHeight) % pageLogicalHeight;
    57955795    if (remainingHeight < childHeight)
    57965796        return yPos + remainingHeight;
    … …  
    58175817    // line and all following lines.
    58185818    LayoutState* layoutState = view()->layoutState();
    5819     int pageHeight = layoutState->m_pageHeight;
     5819    int pageLogicalHeight = layoutState->m_pageLogicalHeight;
    58205820    int yPos = lineBox->topVisualOverflow();
    58215821    int lineHeight = lineBox->bottomVisualOverflow() - yPos;
    … …  
    58245824    yPos += delta;
    58255825    lineBox->setPaginationStrut(0);
    5826     if (!pageHeight || lineHeight > pageHeight)
     5826    if (!pageLogicalHeight || lineHeight > pageLogicalHeight)
    58275827        return;
    5828     int remainingHeight = pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight;
     5828    int remainingHeight = pageLogicalHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageLogicalHeight;
    58295829    if (remainingHeight < lineHeight) {
    58305830        int totalHeight = lineHeight + max(0, yPos);
    5831         if (lineBox == firstRootBox() && totalHeight < pageHeight && !isPositioned() && !isTableCell())
     5831        if (lineBox == firstRootBox() && totalHeight < pageLogicalHeight && !isPositioned() && !isTableCell())
    58325832            setPaginationStrut(remainingHeight + max(0, yPos));
    58335833        else {

  • trunk/WebCore/rendering/RenderBlock.h

    r73385 r74048  
    7272    virtual void removeChild(RenderObject*);
    7373
    74     virtual void layoutBlock(bool relayoutChildren, int pageHeight = 0);
     74    virtual void layoutBlock(bool relayoutChildren, int pageLogicalHeight = 0);
    7575
    7676    void insertPositionedObject(RenderBox*);
    … …  
    568568
    569569    void calcColumnWidth();
    570     bool layoutColumns(bool hasSpecifiedPageHeight, int pageHeight, LayoutStateMaintainer&);
     570    bool layoutColumns(bool hasSpecifiedPageLogicalHeight, int pageLogicalHeight, LayoutStateMaintainer&);
    571571    void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
    572572

  • trunk/WebCore/rendering/RenderBox.cpp

    r73941 r74048  
    17531753        int visHeight;
    17541754        if (document()->printing())
    1755             visHeight = static_cast<int>(view()->pageHeight());
     1755            visHeight = static_cast<int>(view()->pageLogicalHeight());
    17561756        else  {
    17571757            if (style()->isHorizontalWritingMode())

  • trunk/WebCore/rendering/RenderFlexibleBox.cpp

    r73385 r74048  
    279279    updateLayerTransform();
    280280
    281     if (view()->layoutState()->m_pageHeight)
     281    if (view()->layoutState()->pageLogicalHeight())
    282282        setPageY(view()->layoutState()->pageY(y()));
    283283

  • trunk/WebCore/rendering/RenderTable.cpp

    r73385 r74048  
    391391    statePusher.pop();
    392392
    393     if (view()->layoutState()->m_pageHeight)
     393    if (view()->layoutState()->pageLogicalHeight())
    394394        setPageY(view()->layoutState()->pageY(y()));
    395395

  • trunk/WebCore/rendering/RenderTableRow.cpp

    r72850 r74048  
    123123        if (child->isTableCell()) {
    124124            RenderTableCell* cell = toRenderTableCell(child);
    125             if (!cell->needsLayout() && paginated && view()->layoutState()->m_pageHeight && view()->layoutState()->pageY(cell->y()) != cell->pageY())
     125            if (!cell->needsLayout() && paginated && view()->layoutState()->pageLogicalHeight() && view()->layoutState()->pageY(cell->y()) != cell->pageY())
    126126                cell->setChildNeedsLayout(true, false);
    127127

  • trunk/WebCore/rendering/RenderTableSection.cpp

    r73484 r74048  
    615615                cell->setNeedsLayout(true, false);
    616616
    617             if (!cell->needsLayout() && view()->layoutState()->m_pageHeight && view()->layoutState()->pageY(cell->y()) != cell->pageY())
     617            if (!cell->needsLayout() && view()->layoutState()->pageLogicalHeight() && view()->layoutState()->pageY(cell->y()) != cell->pageY())
    618618                cell->setChildNeedsLayout(true, false);
    619619
    … …  
    621621
    622622            // FIXME: Make pagination work with vertical tables.
    623             if (style()->isHorizontalWritingMode() && view()->layoutState()->m_pageHeight && cell->height() != rHeight)
     623            if (style()->isHorizontalWritingMode() && view()->layoutState()->pageLogicalHeight() && cell->height() != rHeight)
    624624                cell->setHeight(rHeight); // FIXME: Pagination might have made us change size.  For now just shrink or grow the cell to fit without doing a relayout.
    625625

  • trunk/WebCore/rendering/RenderView.cpp

    r73729 r74048  
    5050    , m_selectionEndPos(-1)
    5151    , m_maximalOutlineSize(0)
    52     , m_pageHeight(0)
    53     , m_pageHeightChanged(false)
     52    , m_pageLogicalHeight(0)
     53    , m_pageLogicalHeightChanged(false)
    5454    , m_layoutState(0)
    5555    , m_layoutStateDisableCount(0)
    … …  
    103103{
    104104    if (!document()->paginated())
    105         setPageHeight(0);
     105        setPageLogicalHeight(0);
    106106
    107107    if (printing())
    … …  
    122122    // FIXME: May be better to push a clip and avoid issuing offscreen repaints.
    123123    state.m_clipped = false;
    124     state.m_pageHeight = m_pageHeight;
    125     state.m_pageHeightChanged = m_pageHeightChanged;
    126     m_pageHeightChanged = false;
     124    state.m_pageLogicalHeight = m_pageLogicalHeight;
     125    state.m_pageLogicalHeightChanged = m_pageLogicalHeightChanged;
     126    m_pageLogicalHeightChanged = false;
    127127    m_layoutState = &state;
    128128

  • trunk/WebCore/rendering/RenderView.h

    r73972 r74048  
    133133    virtual void updateHitTestResult(HitTestResult&, const IntPoint&);
    134134
    135     unsigned pageHeight() const { return m_pageHeight; }
    136     void setPageHeight(unsigned height)
    137     {
    138         if (m_pageHeight != height) {
    139             m_pageHeight = height;
    140             m_pageHeightChanged = true;
     135    unsigned pageLogicalHeight() const { return m_pageLogicalHeight; }
     136    void setPageLogicalHeight(unsigned height)
     137    {
     138        if (m_pageLogicalHeight != height) {
     139            m_pageLogicalHeight = height;
     140            m_pageLogicalHeightChanged = true;
    141141        }
    142142    }
    … …  
    234234   
    235235private:
    236     unsigned m_pageHeight;
    237     bool m_pageHeightChanged;
     236    unsigned m_pageLogicalHeight;
     237    bool m_pageLogicalHeightChanged;
    238238    LayoutState* m_layoutState;
    239239    unsigned m_layoutStateDisableCount;
Note: See TracChangeset for help on using the changeset viewer.