RenderBlock.cpp

@@void RenderBlock::layoutBlock(bool relay

            // We need to go ahead and set our explicit page height if one exists, so that we can

            // avoid doing two layout passes.

            computeLogicalHeight();

1209 int columnHeight = contentLogicalHeight();

1209 LayoutUnit columnHeight = contentLogicalHeight();

            if (columnHeight > 0) {

                pageLogicalHeight = columnHeight;

                hasSpecifiedPageLogicalHeight = true;

@@void RenderBlock::layoutBlock(bool relay

            colInfo->clearForcedBreaks();

    }

1225 LayoutStateMaintainer statePusher(view(), this, In~~tSize(x(), y()~~), hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged, colInfo);

1225 LayoutStateMaintainer statePusher(view(), this, locationOffset(), hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged, colInfo);

    // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track

    // our current maximal positive and negative margins.  These values are used when we

@@void RenderBlock::layoutBlock(bool relay

            repaintRect.move(-layer()->scrolledContentOffset());

            // Don't allow this rect to spill out of our overflow box.

1349 repaintRect.intersect(IntRect(0, 0, width(), height()));

1349 repaintRect.intersect(LayoutRect(0, 0, width(), height()));

        }

        // Make sure the rect is still non-empty after intersecting for overflow above

@@void RenderBlock::computeOverflow(Layout

        LayoutRect clientRect(clientBoxRect());

        LayoutRect rectToApply;

        if (isHorizontalWritingMode())

1417 rectToApply = LayoutRect(clientRect.x(), clientRect.y(), 1, max(0, oldClientAfterEdge - clientRect.y()));

1417 rectToApply = LayoutRect(clientRect.x(), clientRect.y(), 1, max<LayoutUnit>(0, oldClientAfterEdge - clientRect.y()));

14181418 else

1419 rectToApply = LayoutRect(clientRect.x(), clientRect.y(), max(0, oldClientAfterEdge - clientRect.x()), 1);

1419 rectToApply = LayoutRect(clientRect.x(), clientRect.y(), max<LayoutUnit>(0, oldClientAfterEdge - clientRect.x()), 1);

        addLayoutOverflow(rectToApply);

    }

@@void RenderBlock::setCollapsedBottomMarg

    }

}

1846 void RenderBlock::handleAfterSideOfBlock(int beforeSide, int afterSide, MarginInfo& marginInfo)

1846void RenderBlock::handleAfterSideOfBlock(LayoutUnit beforeSide, LayoutUnit afterSide, MarginInfo& marginInfo)

{

    marginInfo.setAtAfterSideOfBlock(true);

@@void RenderBlock::layoutBlockChild(Rende

            setLogicalHeight(newHeight);

    }

2127 // FIXME: Needs to use epsilon once we move to float, see https://bugs.webkit.org/show_bug.cgi?id=64021

2127 // FIXME: Change to use roughlyEquals when we move to float.

2128 // See https://bugs.webkit.org/show_bug.cgi?id=66148

    ASSERT(oldLayoutDelta == view()->layoutDelta());

}

@@void RenderBlock::paintChildren(PaintInf

        if (checkAfterAlways

            && (absoluteChildY + child->height()) > paintInfo.rect.y()

            && (absoluteChildY + child->height()) < paintInfo.rect.maxY()) {

2498 view()->setBestTruncatedAt(absoluteChildY + child->height() + max(0, child->collapsedMarginAfter()), this, true);

2499 view()->setBestTruncatedAt(absoluteChildY + child->height() + max<LayoutUnit>(0, child->collapsedMarginAfter()), this, true);

            return;

        }

    }

@@GapRects RenderBlock::selectionGapRectsF

    // FIXME: this is broken with transforms

    TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());

    mapLocalToContainer(repaintContainer, false, false, transformState);

2800 IntPoint offsetFromRepaintContainer = roundedIntPoint(transformState.mappedPoint());

2801 LayoutPoint offsetFromRepaintContainer = roundedLayoutPoint(transformState.mappedPoint());

    if (hasOverflowClip())

        offsetFromRepaintContainer -= layer()->scrolledContentOffset();

@@void RenderBlock::paintSelection(PaintIn

    }

}

2836 static void clipOutPositionedObjects(const PaintInfo* paintInfo, const IntPoint& offset, RenderBlock::PositionedObjectsListHashSet* positionedObjects)

2837static void clipOutPositionedObjects(const PaintInfo* paintInfo, const LayoutPoint& offset, RenderBlock::PositionedObjectsListHashSet* positionedObjects)

{

    if (!positionedObjects)

        return;

@@static void clipOutPositionedObjects(con

    RenderBlock::PositionedObjectsListHashSet::const_iterator end = positionedObjects->end();

    for (RenderBlock::PositionedObjectsListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {

        RenderBox* r = *it;

2844 paintInfo->context->clipOut(IntRect(offset.x() + r->x(), offset.y() + r->y(), r->width(), r->height()));

2845 paintInfo->context->clipOut(LayoutRect(offset.x() + r->x(), offset.y() + r->y(), r->width(), r->height()));

    }

}

2848 static int blockDirectionOffset(RenderBlock* rootBlock, const IntSize& offsetFromRootBlock)

2849static int blockDirectionOffset(RenderBlock* rootBlock, const LayoutSize& offsetFromRootBlock)

{

    return rootBlock->isHorizontalWritingMode() ? offsetFromRootBlock.height() : offsetFromRootBlock.width();

}

2853 static int inlineDirectionOffset(RenderBlock* rootBlock, const IntSize& offsetFromRootBlock)

2854static int inlineDirectionOffset(RenderBlock* rootBlock, const LayoutSize& offsetFromRootBlock)

{

    return rootBlock->isHorizontalWritingMode() ? offsetFromRootBlock.width() : offsetFromRootBlock.height();

}

@@GapRects RenderBlock::selectionGaps(Rend

        clipOutPositionedObjects(paintInfo, flippedBlockRect.location(), m_positionedObjects.get());

        if (isBody() || isRoot()) // The <body> must make sure to examine its containingBlock's positioned objects.

            for (RenderBlock* cb = containingBlock(); cb && !cb->isRenderView(); cb = cb->containingBlock())

2883 clipOutPositionedObjects(paintInfo, IntPoint(cb->x(), cb->y()), cb->m_positionedObjects.get()); // FIXME: Not right for flipped writing modes.

2884 clipOutPositionedObjects(paintInfo, LayoutPoint(cb->x(), cb->y()), cb->m_positionedObjects.get()); // FIXME: Not right for flipped writing modes.

        if (m_floatingObjects) {

            const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

            FloatingObjectSetIterator end = floatingObjectSet.end();

@@GapRects RenderBlock::inlineSelectionGap

        
        LayoutRect logicalRect(curr->logicalLeft(), selTop, curr->logicalWidth(), selTop + selHeight);

        logicalRect.move(isHorizontalWritingMode() ? offsetFromRootBlock : offsetFromRootBlock.transposedSize());

2959 IntRect physicalRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);

2960 LayoutRect physicalRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);

        if (!paintInfo || (isHorizontalWritingMode() && physicalRect.y() < paintInfo->rect.maxY() && physicalRect.maxY() > paintInfo->rect.y())

            || (!isHorizontalWritingMode() && physicalRect.x() < paintInfo->rect.maxX() && physicalRect.maxX() > paintInfo->rect.x()))

            result.unite(curr->lineSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, selTop, selHeight, paintInfo));

@@bool RenderBlock::positionNewFloats()

        }

    }

3320 int logicalTop = logicalHeight();

3321 LayoutUnit logicalTop = logicalHeight();

    
    // The float cannot start above the top position of the last positioned float.

    if (lastPlacedFloatingObject)

@@bool RenderBlock::positionNewFloats()

            continue;

        RenderBox* childBox = floatingObject->renderer();

3337 int childLogicalLeftMargin = style()->isLeftToRightDirection() ? marginStartForChild(childBox) : marginEndForChild(childBox);

3338 LayoutUnit childLogicalLeftMargin = style()->isLeftToRightDirection() ? marginStartForChild(childBox) : marginEndForChild(childBox);

33383339

        int rightOffset = logicalRightOffsetForContent(); // Constant part of right offset.

        int leftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.

        int floatLogicalWidth = logicalWidthForFloat(floatingObject); // The width we look for.

        LayoutUnit rightOffset = logicalRightOffsetForContent(); // Constant part of right offset.

        LayoutUnit leftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.

        LayoutUnit floatLogicalWidth = logicalWidthForFloat(floatingObject); // The width we look for.

        if (rightOffset - leftOffset < floatLogicalWidth)

            floatLogicalWidth = rightOffset - leftOffset; // Never look for more than what will be available.

3345 IntRect oldRect(childBox->x(), childBox->y() , childBox->width(), childBox->height());

3346 LayoutRect oldRect(childBox->x(), childBox->y() , childBox->width(), childBox->height());

        if (childBox->style()->clear() & CLEFT)

            logicalTop = max(lowestFloatLogicalBottom(FloatingObject::FloatLeft), logicalTop);

        if (childBox->style()->clear() & CRIGHT)

            logicalTop = max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);

3352 int floatLogicalLeft;

3353 LayoutUnit floatLogicalLeft;

33533354 if (childBox->style()->floating() == LeftFloat) {

3354 int heightRemainingLeft = 1;

3355 int heightRemainingRight = 1;

3355 LayoutUnit heightRemainingLeft = 1;

3356 LayoutUnit heightRemainingRight = 1;

            floatLogicalLeft = logicalLeftOffsetForLine(logicalTop, leftOffset, false, &heightRemainingLeft);

            while (logicalRightOffsetForLine(logicalTop, rightOffset, false, &heightRemainingRight) - floatLogicalLeft < floatLogicalWidth) {

                logicalTop += min(heightRemainingLeft, heightRemainingRight);

                floatLogicalLeft = logicalLeftOffsetForLine(logicalTop, leftOffset, false, &heightRemainingLeft);

            }

3361 floatLogicalLeft = max(0, floatLogicalLeft);

3362 floatLogicalLeft = max<LayoutUnit>(0, floatLogicalLeft);

33623363 } else {

3363 int heightRemainingLeft = 1;

3364 int heightRemainingRight = 1;

3364 LayoutUnit heightRemainingLeft = 1;

3365 LayoutUnit heightRemainingRight = 1;

            floatLogicalLeft = logicalRightOffsetForLine(logicalTop, rightOffset, false, &heightRemainingRight);

            while (floatLogicalLeft - logicalLeftOffsetForLine(logicalTop, leftOffset, false, &heightRemainingLeft) < floatLogicalWidth) {

                logicalTop += min(heightRemainingLeft, heightRemainingRight);

@@bool RenderBlock::positionNewFloats()

            // If we are unsplittable and don't fit, then we need to move down.

            // We include our margins as part of the unsplittable area.

3388 int newLogicalTop = adjustForUnsplittableChild(childBox, logicalTop, true);

3389 LayoutUnit newLogicalTop = adjustForUnsplittableChild(childBox, logicalTop, true);

            
            // See if we have a pagination strut that is making us move down further.

            // Note that an unsplittable child can't also have a pagination strut, so this is

@@LayoutUnit RenderBlock::availableLogical

    return (result < 0) ? 0 : result;

}

3586 int RenderBlock::nextFloatLogicalBottomBelow(int logicalHeight) const

3587LayoutUnit RenderBlock::nextFloatLogicalBottomBelow(LayoutUnit logicalHeight) const

{

    if (!m_floatingObjects)

        return 0;

3591 int bottom = ~~INT_MAX~~;

3592 LayoutUnit bottom = numeric_limits<LayoutUnit>::max();

    const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

    FloatingObjectSetIterator end = floatingObjectSet.end();

    for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {

        FloatingObject* r = *it;

3596 int floatBottom = logicalBottomForFloat(r);

3597 LayoutUnit floatBottom = logicalBottomForFloat(r);

        if (floatBottom > logicalHeight)

            bottom = min(floatBottom, bottom);

    }

3601 return bottom == ~~INT_MAX~~ ? 0 : bottom;

3602 return bottom == numeric_limits<LayoutUnit>::max() ? 0 : bottom;

36023603}

36033604

3604 int RenderBlock::lowestFloatLogicalBottom(FloatingObject::Type floatType) const

3605LayoutUnit RenderBlock::lowestFloatLogicalBottom(FloatingObject::Type floatType) const

{

    if (!m_floatingObjects)

        return 0;

3608 int lowestFloatBottom = 0;

3609 LayoutUnit lowestFloatBottom = 0;

    const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

    FloatingObjectSetIterator end = floatingObjectSet.end();

    for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {

@@int RenderBlock::lowestFloatLogicalBotto

    return lowestFloatBottom;

}

3619 void RenderBlock::markLinesDirtyInBlockRange(int logicalTop, int logicalBottom, RootInlineBox* highest)

3620void RenderBlock::markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest)

{

    if (logicalTop >= logicalBottom)

        return;

    RootInlineBox* lowestDirtyLine = lastRootBox();

    RootInlineBox* afterLowest = lowestDirtyLine;

3626 while (lowestDirtyLine && lowestDirtyLine->blockLogicalHeight() >= logicalBottom && logicalBottom < numeric_limits<int>::max()) {

3627 while (lowestDirtyLine && lowestDirtyLine->blockLogicalHeight() >= logicalBottom && logicalBottom < numeric_limits<LayoutUnit>::max()) {

        afterLowest = lowestDirtyLine;

        lowestDirtyLine = lowestDirtyLine->prevRootBox();

    }

@@void RenderBlock::clearFloats(BlockLayou

    }

    // First add in floats from the parent.

3721 int logicalTopOffset = logicalTop();

3722 LayoutUnit logicalTopOffset = logicalTop();

    if (parentHasFloats)

        addIntrudingFloats(parentBlock, parentBlock->logicalLeftOffsetForContent(), logicalTopOffset);

3725 int logicalLeftOffset = 0;

3726 LayoutUnit logicalLeftOffset = 0;

    if (prev)

        logicalTopOffset -= toRenderBox(prev)->logicalTop();

    else if (!parentHasFloats) {

@@void RenderBlock::clearFloats(BlockLayou

        addIntrudingFloats(block, logicalLeftOffset, logicalTopOffset);

    if (childrenInline()) {

3739 int changeLogicalTop = numeric_limits<int>::max();

3740 int changeLogicalBottom = numeric_limits<int>::min();

3740 LayoutUnit changeLogicalTop = numeric_limits<LayoutUnit>::max();

3741 LayoutUnit changeLogicalBottom = numeric_limits<LayoutUnit>::min();

        if (m_floatingObjects) {

            const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

            FloatingObjectSetIterator end = floatingObjectSet.end();

            for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {

                FloatingObject* f = *it;

                FloatingObject* oldFloatingObject = floatMap.get(f->m_renderer);

3747 int logicalBottom = logicalBottomForFloat(f);

3748 LayoutUnit logicalBottom = logicalBottomForFloat(f);

37483749 if (oldFloatingObject) {

3749 int oldLogicalBottom = logicalBottomForFloat(oldFloatingObject);

3750 LayoutUnit oldLogicalBottom = logicalBottomForFloat(oldFloatingObject);

                    if (logicalWidthForFloat(f) != logicalWidthForFloat(oldFloatingObject) || logicalLeftForFloat(f) != logicalLeftForFloat(oldFloatingObject)) {

                        changeLogicalTop = 0;

                        changeLogicalBottom = max(changeLogicalBottom, max(logicalBottom, oldLogicalBottom));

@@void RenderBlock::clearFloats(BlockLayou

    }

}

3785 int RenderBlock::addOverhangingFloats(RenderBlock* child, int logicalLeftOffset, int logicalTopOffset, bool makeChildPaintOtherFloats)

3786LayoutUnit RenderBlock::addOverhangingFloats(RenderBlock* child, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset, bool makeChildPaintOtherFloats)

{

    // Prevent floats from being added to the canvas by the root element, e.g., <html>.

    if (child->hasOverflowClip() || !child->containsFloats() || child->isRoot() || child->hasColumns() || child->isWritingModeRoot())

        return 0;

3791 int childLogicalTop = child->logicalTop();

3792 int lowestFloatLogicalBottom = 0;

3792 LayoutUnit childLogicalTop = child->logicalTop();

3793 LayoutUnit lowestFloatLogicalBottom = 0;

    // Floats that will remain the child's responsibility to paint should factor into its

    // overflow.

    FloatingObjectSetIterator childEnd = child->m_floatingObjects->set().end();

    for (FloatingObjectSetIterator childIt = child->m_floatingObjects->set().begin(); childIt != childEnd; ++childIt) {

        FloatingObject* r = *childIt;

3799 int logicalBottomForFloat = min(this->logicalBottomForFloat(r), numeric_limits<int>::max() - childLogicalTop);

3800 int logicalBottom = childLogicalTop + logicalBottomForFloat;

3800 LayoutUnit logicalBottomForFloat = min(this->logicalBottomForFloat(r), numeric_limits<LayoutUnit>::max() - childLogicalTop);

3801 LayoutUnit logicalBottom = childLogicalTop + logicalBottomForFloat;

        lowestFloatLogicalBottom = max(lowestFloatLogicalBottom, logicalBottom);

        if (logicalBottom > logicalHeight()) {

            // If the object is not in the list, we add it now.

            if (!containsFloat(r->m_renderer)) {

                int leftOffset = isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;

                int topOffset = isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;

                FloatingObject* floatingObj = new FloatingObject(r->type(), IntRect(r->x() - leftOffset, r->y() - topOffset, r->width(), r->height()));

                LayoutUnit leftOffset = isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;

                LayoutUnit topOffset = isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;

                FloatingObject* floatingObj = new FloatingObject(r->type(), LayoutRect(r->x() - leftOffset, r->y() - topOffset, r->width(), r->height()));

                floatingObj->m_renderer = r->m_renderer;

                // The nearest enclosing layer always paints the float (so that zindex and stacking

@@int RenderBlock::addOverhangingFloats(Re

            // Since the float doesn't overhang, it didn't get put into our list.  We need to go ahead and add its overflow in to the

            // child now.

            if (r->m_isDescendant)

3842 child->addOverflowFromChild(r->m_renderer, IntSize(xPositionForFloatIncludingMargin(r), yPositionForFloatIncludingMargin(r)));

3843 child->addOverflowFromChild(r->m_renderer, LayoutSize(xPositionForFloatIncludingMargin(r), yPositionForFloatIncludingMargin(r)));

        }

    }

    return lowestFloatLogicalBottom;

@@bool RenderBlock::hasOverhangingFloat(Re

    return logicalBottomForFloat(*it) > logicalHeight();

}

3861 void RenderBlock::addIntrudingFloats(RenderBlock* prev, int logicalLeftOffset, int logicalTopOffset)

3862void RenderBlock::addIntrudingFloats(RenderBlock* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)

{

    // If the parent or previous sibling doesn't have any floats to add, don't bother.

    if (!prev->m_floatingObjects)

@@void RenderBlock::addIntrudingFloats(Ren

        FloatingObject* r = *prevIt;

        if (logicalBottomForFloat(r) > logicalTopOffset) {

            if (!m_floatingObjects || !m_floatingObjects->set().contains(r)) {

3875 int leftOffset = isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;

3876 int topOffset = isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;

3876 LayoutUnit leftOffset = isHorizontalWritingMode() ? logicalLeftOffset : logicalTopOffset;

3877 LayoutUnit topOffset = isHorizontalWritingMode() ? logicalTopOffset : logicalLeftOffset;

38773878

3878 FloatingObject* floatingObj = new FloatingObject(r->type(), IntRect(r->x() - leftOffset, r->y() - topOffset, r->width(), r->height()));

3879 FloatingObject* floatingObj = new FloatingObject(r->type(), LayoutRect(r->x() - leftOffset, r->y() - topOffset, r->width(), r->height()));

                // Applying the child's margin makes no sense in the case where the child was passed in.

                // since this margin was added already through the modification of the |logicalLeftOffset| variable

@@void RenderBlock::markSiblingsWithFloats

    }

}

3961 int RenderBlock::getClearDelta(RenderBox* child, int yPos)

3962LayoutUnit RenderBlock::getClearDelta(RenderBox* child, LayoutUnit yPos)

{

    // There is no need to compute clearance if we have no floats.

    if (!containsFloats())

@@int RenderBlock::getClearDelta(RenderBox

    
    // At least one float is present.  We need to perform the clearance computation.

    bool clearSet = child->style()->clear() != CNONE;

3969 int bottom = 0;

3970 LayoutUnit bottom = 0;

    switch (child->style()->clear()) {

        case CNONE:

            break;

@@int RenderBlock::getClearDelta(RenderBox

    }

    // We also clear floats if we are too big to sit on the same line as a float (and wish to avoid floats by default).

3985 int result = clearSet ? max(0, bottom - yPos) : 0;

3986 LayoutUnit result = clearSet ? max<LayoutUnit>(0, bottom - yPos) : 0;

39863987 if (!result && child->avoidsFloats()) {

3987 int y = yPos;

3988 LayoutUnit y = yPos;

39883989 while (true) {

3989 int widthAtY = availableLogicalWidthForLine(y, false);

            LayoutUnit widthAtY = availableLogicalWidthForLine(y, false);

            // FIXME: Change to use roughlyEquals when we move to float.

            // See https://bugs.webkit.org/show_bug.cgi?id=66148

            if (widthAtY == availableLogicalWidth())

                return y - yPos;

3993 int oldChildY = child->y();

3994 int oldChildWidth = child->width();

3996 LayoutUnit oldChildY = child->y();

3997 LayoutUnit oldChildWidth = child->width();

39953998 child->setY(y);

39963999 child->computeLogicalWidth();

3997 int childWidthAtY = child->width();

4000 LayoutUnit childWidthAtY = child->width();

            child->setY(oldChildY);

            child->setWidth(oldChildWidth);

4004 // FIXME: Change to use roughlyEquals when we move to float.

4005 // See https://bugs.webkit.org/show_bug.cgi?id=66148

            if (childWidthAtY <= widthAtY)

                return y - yPos;

@@VisiblePosition RenderBlock::positionFor

        }

        // pass the box a top position that is inside it

4267 IntPoint point(pointInLogicalContents.x(), closestBox->logicalTop());

4272 LayoutPoint point(pointInLogicalContents.x(), closestBox->logicalTop());

        if (!isHorizontalWritingMode())

            point = point.transposedPoint();

        if (closestBox->renderer()->isReplaced())

@@VisiblePosition RenderBlock::positionFor

    return RenderBox::positionForPoint(point);

}

4336 void RenderBlock::offsetForContents(IntPoint& offset) const

4341void RenderBlock::offsetForContents(LayoutPoint& offset) const

{

    if (hasOverflowClip())

        offset += layer()->scrolledContentOffset();

@@void RenderBlock::calcColumnWidth()

    setDesiredColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);

}

4390 void RenderBlock::setDesiredColumnCountAndWidth(int count, int width)

4395void RenderBlock::setDesiredColumnCountAndWidth(int count, LayoutUnit width)

{

    bool destroyColumns = !firstChild()

                          || (count == 1 && style()->hasAutoColumnWidth())

@@bool RenderBlock::layoutColumns(bool has

    ColumnInfo* colInfo = columnInfo();

    int desiredColumnCount = colInfo->desiredColumnCount();

    if (!hasSpecifiedPageLogicalHeight) {

4472 int columnHeight = pageLogicalHeight;

4477 LayoutUnit columnHeight = pageLogicalHeight;

        int minColumnCount = colInfo->forcedBreaks() + 1;

        if (minColumnCount >= desiredColumnCount) {

            // The forced page breaks are in control of the balancing.  Just set the column height to the

            // maximum page break distance.

            if (!pageLogicalHeight) {

4478 int distanceBetweenBreaks = max(colInfo->maximumDistanceBetweenForcedBreaks(),

4483 LayoutUnit distanceBetweenBreaks = max(colInfo->maximumDistanceBetweenForcedBreaks(),

                                                view()->layoutState()->pageLogicalOffset(borderBefore() + paddingBefore() + contentLogicalHeight()) - colInfo->forcedBreakOffset());

                columnHeight = max(colInfo->minimumColumnHeight(), distanceBetweenBreaks);

            }

        } else if (contentLogicalHeight() > pageLogicalHeight * desiredColumnCount) {

            // Now that we know the intrinsic height of the columns, we have to rebalance them.

4484 columnHeight = max(colInfo->minimumColumnHeight(), ~~(int)~~ceilf((float)contentLogicalHeight() / desiredColumnCount));

4489 columnHeight = max(colInfo->minimumColumnHeight(), ceiledLayoutUnit((float)contentLogicalHeight() / desiredColumnCount));

        }

        if (columnHeight && columnHeight != pageLogicalHeight) {

@@bool RenderBlock::layoutColumns(bool has

    return false;

}

4506 void RenderBlock::adjustPointToColumnContents(IntPoint& point) const

4511void RenderBlock::adjustPointToColumnContents(LayoutPoint& point) const

{

    // Just bail if we have no columns.

    if (!hasColumns())

@@void RenderBlock::adjustPointToColumnCon

        return;

    // Determine which columns we intersect.

    int colGap = columnGap();

    int halfColGap = colGap / 2;

    IntPoint columnPoint(columnRectAt(colInfo, 0).location());

    int logicalOffset = 0;

    LayoutUnit colGap = columnGap();

    LayoutUnit halfColGap = colGap / 2;

    LayoutPoint columnPoint(columnRectAt(colInfo, 0).location());

    LayoutUnit logicalOffset = 0;

45214526 for (unsigned i = 0; i < colInfo->columnCount(); i++) {

45224527 // Add in half the column gap to the left and right of the rect.

4523 IntRect colRect = columnRectAt(colInfo, i);

4528 LayoutRect colRect = columnRectAt(colInfo, i);

45244529 if (isHorizontalWritingMode()) {

4525 IntRect gapAndColumnRect(colRect.x() - halfColGap, colRect.y(), colRect.width() + colGap, colRect.height());

4530 LayoutRect gapAndColumnRect(colRect.x() - halfColGap, colRect.y(), colRect.width() + colGap, colRect.height());

            if (point.x() >= gapAndColumnRect.x() && point.x() < gapAndColumnRect.maxX()) {

                // FIXME: The clamping that follows is not completely right for right-to-left

                // content.

@@void RenderBlock::adjustPointToColumnCon

            // Move to the next position.

            logicalOffset += colRect.height();

        } else {

4547 IntRect gapAndColumnRect(colRect.x(), colRect.y() - halfColGap, colRect.width(), colRect.height() + colGap);

4552 LayoutRect gapAndColumnRect(colRect.x(), colRect.y() - halfColGap, colRect.width(), colRect.height() + colGap);

            if (point.y() >= gapAndColumnRect.y() && point.y() < gapAndColumnRect.maxY()) {

                // FIXME: The clamping that follows is not completely right for right-to-left

                // content.

@@void RenderBlock::computeBlockPreferredL

    }

    // Always make sure these values are non-negative.

5208 m_minPreferredLogicalWidth = max(0, m_minPreferredLogicalWidth);

5209 m_maxPreferredLogicalWidth = max(0, m_maxPreferredLogicalWidth);

5213 m_minPreferredLogicalWidth = max<LayoutUnit>(0, m_minPreferredLogicalWidth);

5214 m_maxPreferredLogicalWidth = max<LayoutUnit>(0, m_maxPreferredLogicalWidth);

    m_maxPreferredLogicalWidth = max(floatLeftWidth + floatRightWidth, m_maxPreferredLogicalWidth);

}

@@bool RenderBlock::hasLineIfEmpty() const

    return false;

}

5228 int RenderBlock::lineHeight(bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const

5233LayoutUnit RenderBlock::lineHeight(bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const

{

    // Inline blocks are replaced elements. Otherwise, just pass off to

    // the base class.  If we're being queried as though we're the root line

@@int RenderBlock::lineHeight(bool firstLi

    return m_lineHeight;

}

5249 int RenderBlock::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const

5254LayoutUnit RenderBlock::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const

{

    // Inline blocks are replaced elements. Otherwise, just pass off to

    // the base class.  If we're being queried as though we're the root line

@@int RenderBlock::baselinePosition(FontBa

    return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;

}

5285 int RenderBlock::firstLineBoxBaseline() const

5290LayoutUnit RenderBlock::firstLineBoxBaseline() const

{

    if (!isBlockFlow() || (isWritingModeRoot() && !isRubyRun()))

        return -1;

@@int RenderBlock::firstLineBoxBaseline()

    else {

        for (RenderBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {

            if (!curr->isFloatingOrPositioned()) {

5299 int result = curr->firstLineBoxBaseline();

5304 LayoutUnit result = curr->firstLineBoxBaseline();

                if (result != -1)

                    return curr->logicalTop() + result; // Translate to our coordinate space.

            }

@@int RenderBlock::firstLineBoxBaseline()

    return -1;

}

5309 int RenderBlock::lastLineBoxBaseline() const

5314LayoutUnit RenderBlock::lastLineBoxBaseline() const

{

    if (!isBlockFlow() || (isWritingModeRoot() && !isRubyRun()))

        return -1;

@@int RenderBlock::lastLineBoxBaseline() c

        for (RenderBox* curr = lastChildBox(); curr; curr = curr->previousSiblingBox()) {

            if (!curr->isFloatingOrPositioned()) {

                haveNormalFlowChild = true;

5331 int result = curr->lastLineBoxBaseline();

5336 LayoutUnit result = curr->lastLineBoxBaseline();

                if (result != -1)

                    return curr->logicalTop() + result; // Translate to our coordinate space.

            }

@@int RenderBlock::heightForLineCount(int

    return getHeightForLineCount(this, l, true, count);

}

5670 void RenderBlock::adjustForBorderFit(int x, int& left, int& right) const

5675void RenderBlock::adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const

{

    // We don't deal with relative positioning.  Our assumption is that you shrink to fit the lines without accounting

    // for either overflow or translations via relative positioning.

@@void RenderBlock::adjustForBorderFit(int

        if (childrenInline()) {

            for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {

                if (box->firstChild())

5678 left = min(left, x + static_cast<int>(box->firstChild()->x()));

5683 left = min(left, x + static_cast<LayoutUnit>(box->firstChild()->x()));

56795684 if (box->lastChild())

5680 right = max(right, x + static_cast<int>(ceilf(box->lastChild()->logicalRight())));

5685 right = max(right, x + static_cast<LayoutUnit>(ceilf(box->lastChild()->logicalRight())));

@@void RenderBlock::adjustForBorderFit(int

                FloatingObject* r = *it;

                // Only examine the object if our m_shouldPaint flag is set.

                if (r->m_shouldPaint) {

5704 int floatLeft = xPositionForFloatIncludingMargin(r) - r->m_renderer->x();

5705 int floatRight = floatLeft + r->m_renderer->width();

5709 LayoutUnit floatLeft = xPositionForFloatIncludingMargin(r) - r->m_renderer->x();

5710 LayoutUnit floatRight = floatLeft + r->m_renderer->width();

                    left = min(left, floatLeft);

                    right = max(right, floatRight);

                }

@@void RenderBlock::adjustForBorderFit(int

    }

}

5714 void RenderBlock::borderFitAdjust(IntRect& rect) const

5719void RenderBlock::borderFitAdjust(LayoutRect& rect) const

{

    if (style()->borderFit() == BorderFitBorder)

        return;

    // Walk any normal flow lines to snugly fit.

    int left = INT_MAX;

    int right = INT_MIN;

    int oldWidth = rect.width();

    LayoutUnit left = numeric_limits<LayoutUnit>::max();

    LayoutUnit right = numeric_limits<LayoutUnit>::min();

    LayoutUnit oldWidth = rect.width();

57235728 adjustForBorderFit(0, left, right);

5724 if (left != ~~INT_MAX~~) {

5729 if (left != numeric_limits<LayoutUnit>::max()) {

        left -= (borderLeft() + paddingLeft());

        if (left > 0) {

            rect.move(left, 0);

            rect.expand(-left, 0);

        }

    }

5731 if (right != ~~INT_MIN~~) {

5736 if (right != numeric_limits<LayoutUnit>::min()) {

        right += (borderRight() + paddingRight());

        if (right < oldWidth)

            rect.expand(-(oldWidth - right), 0);

@@void RenderBlock::clearTruncation()

    }

}

5753 void RenderBlock::setMaxMarginBeforeValues(int pos, int neg)

5758void RenderBlock::setMaxMarginBeforeValues(LayoutUnit pos, LayoutUnit neg)

{

    if (!m_rareData) {

        if (pos == RenderBlockRareData::positiveMarginBeforeDefault(this) && neg == RenderBlockRareData::negativeMarginBeforeDefault(this))

@@void RenderBlock::setMaxMarginBeforeValu

    m_rareData->m_margins.setNegativeMarginBefore(neg);

}

5764 void RenderBlock::setMaxMarginAfterValues(int pos, int neg)

5769void RenderBlock::setMaxMarginAfterValues(LayoutUnit pos, LayoutUnit neg)

{

    if (!m_rareData) {

        if (pos == RenderBlockRareData::positiveMarginAfterDefault(this) && neg == RenderBlockRareData::negativeMarginAfterDefault(this))

@@void RenderBlock::absoluteQuads(Vector<F

        quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width(), height()), false, wasFixed));

}

5827 IntRect RenderBlock::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth) const

5832LayoutRect RenderBlock::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, LayoutUnit outlineWidth) const

58285833{

5829 IntRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));

5834 LayoutRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));

    if (isAnonymousBlockContinuation())

        r.inflateY(collapsedMarginBefore()); // FIXME: This is wrong for block-flows that are horizontal.

    return r;

@@void RenderBlock::updateHitTestResult(Hi

    }

}

5880 IntRect RenderBlock::localCaretRect(InlineBox* inlineBox, int caretOffset, int* extraWidthToEndOfLine)

5885LayoutRect RenderBlock::localCaretRect(InlineBox* inlineBox, int caretOffset, LayoutUnit* extraWidthToEndOfLine)

{

    // Do the normal calculation in most cases.

    if (firstChild())

@@IntRect RenderBlock::localCaretRect(Inli

    // constructed and this kludge is not called any more. So only the caret size

    // of an empty :first-line'd block is wrong. I think we can live with that.

    RenderStyle* currentStyle = firstLineStyle();

5895 int height = lineHeight(true, currentStyle->isHorizontalWritingMode() ? HorizontalLine : VerticalLine);

5900 LayoutUnit height = lineHeight(true, currentStyle->isHorizontalWritingMode() ? HorizontalLine : VerticalLine);

    enum CaretAlignment { alignLeft, alignRight, alignCenter };

@@IntRect RenderBlock::localCaretRect(Inli

            break;

    }

5928 int x = borderLeft() + paddingLeft();

5929 int w = width();

5933 LayoutUnit x = borderLeft() + paddingLeft();

5934 LayoutUnit w = width();

    switch (alignment) {

        case alignLeft:

@@IntRect RenderBlock::localCaretRect(Inli

            // myRight and containerRight are set up, but then clobbered.

            // So *extraWidthToEndOfLine will always be 0 here.

5950 int myRight = x + caretWidth;

5955 LayoutUnit myRight = x + caretWidth;

            // FIXME: why call localToAbsoluteForContent() twice here, too?

            FloatPoint absRightPoint = localToAbsolute(FloatPoint(myRight, 0));

5954 int containerRight = containingBlock()->x() + containingBlockLogicalWidthForContent();

5959 LayoutUnit containerRight = containingBlock()->x() + containingBlockLogicalWidthForContent();

            FloatPoint absContainerPoint = localToAbsolute(FloatPoint(containerRight, 0));

            *extraWidthToEndOfLine = absContainerPoint.x() - absRightPoint.x();

        }

    }

5961 int y = paddingTop() + borderTop();

5966 LayoutUnit y = paddingTop() + borderTop();

59625967

5963 return IntRect(x, y, caretWidth, height);

5968 return LayoutRect(x, y, caretWidth, height);

}

void RenderBlock::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset)

@@void RenderBlock::addFocusRingRects(Vect

                    pos = curr->localToAbsolute();

                else

                    pos = FloatPoint(additionalOffset.x() + box->x(), additionalOffset.y() + box->y());

6004 box->addFocusRingRects(rects, flooredIntPoint(pos));

6009 box->addFocusRingRects(rects, flooredLayoutPoint(pos));

@@RenderBlock* RenderBlock::createAnonymou

    return newBox;

}

6061 int RenderBlock::nextPageLogicalTopExcludingBoundaryPoint(int logicalOffset) const

6066LayoutUnit RenderBlock::nextPageLogicalTopExcludingBoundaryPoint(LayoutUnit logicalOffset) const

{

    LayoutState* layoutState = view()->layoutState();

    if (!layoutState->m_pageLogicalHeight)

        return logicalOffset;

    // The logicalOffset is in our coordinate space.  We can add in our pushed offset.

    int pageLogicalHeight = layoutState->m_pageLogicalHeight;

    IntSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    int offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    int remainingLogicalHeight = (pageLogicalHeight - (offset + logicalOffset) % pageLogicalHeight) % pageLogicalHeight;

    LayoutUnit pageLogicalHeight = layoutState->m_pageLogicalHeight;

    LayoutSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    LayoutUnit offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    LayoutUnit remainingLogicalHeight = layoutMod(pageLogicalHeight - layoutMod(offset + logicalOffset, pageLogicalHeight), pageLogicalHeight);

    return logicalOffset + (remainingLogicalHeight ? remainingLogicalHeight : pageLogicalHeight);

}

6075 int RenderBlock::nextPageLogicalTopIncludingBoundaryPoint(int logicalOffset) const

6080LayoutUnit RenderBlock::nextPageLogicalTopIncludingBoundaryPoint(LayoutUnit logicalOffset) const

{

    LayoutState* layoutState = view()->layoutState();

    if (!layoutState->m_pageLogicalHeight)

        return logicalOffset;

    // The logicalOffset is in our coordinate space.  We can add in our pushed offset.

    int pageLogicalHeight = layoutState->m_pageLogicalHeight;

    IntSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    int offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    int remainingLogicalHeight = (pageLogicalHeight - (offset + logicalOffset) % pageLogicalHeight) % pageLogicalHeight;

    LayoutUnit pageLogicalHeight = layoutState->m_pageLogicalHeight;

    LayoutSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    LayoutUnit offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    LayoutUnit remainingLogicalHeight = layoutMod(pageLogicalHeight - layoutMod(offset + logicalOffset, pageLogicalHeight), pageLogicalHeight);

    return logicalOffset + remainingLogicalHeight;

}

@@int RenderBlock::applyAfterBreak(RenderB

    return logicalOffset;

}

6132 int RenderBlock::adjustForUnsplittableChild(RenderBox* child, int logicalOffset, bool includeMargins)

6137LayoutUnit RenderBlock::adjustForUnsplittableChild(RenderBox* child, LayoutUnit logicalOffset, bool includeMargins)

{

    bool isUnsplittable = child->isReplaced() || child->scrollsOverflow() || child->style()->columnBreakInside() == PBAVOID;

    if (!isUnsplittable)

        return logicalOffset;

6137 int childLogicalHeight = logicalHeightForChild(child) + (includeMargins ? marginBeforeForChild(child) + marginAfterForChild(child) : 0);

6142 LayoutUnit childLogicalHeight = logicalHeightForChild(child) + (includeMargins ? marginBeforeForChild(child) + marginAfterForChild(child) : 0);

    LayoutState* layoutState = view()->layoutState();

    if (layoutState->m_columnInfo)

        layoutState->m_columnInfo->updateMinimumColumnHeight(childLogicalHeight);

6141 int pageLogicalHeight = layoutState->m_pageLogicalHeight;

6146 LayoutUnit pageLogicalHeight = layoutState->m_pageLogicalHeight;

61426147 if (!pageLogicalHeight || childLogicalHeight > pageLogicalHeight)

61436148 return logicalOffset;

    IntSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    int offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    int remainingLogicalHeight = (pageLogicalHeight - (offset + logicalOffset) % pageLogicalHeight) % pageLogicalHeight;

    LayoutSize delta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    LayoutUnit offset = isHorizontalWritingMode() ? delta.height() : delta.width();

    LayoutUnit remainingLogicalHeight = layoutMod(pageLogicalHeight - layoutMod(offset + logicalOffset, pageLogicalHeight), pageLogicalHeight);

    if (remainingLogicalHeight < childLogicalHeight)

        return logicalOffset + remainingLogicalHeight;

    return logicalOffset;

}

6152 void RenderBlock::adjustLinePositionForPagination(RootInlineBox* lineBox, int& delta)

6157void RenderBlock::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta)

{

    // FIXME: For now we paginate using line overflow.  This ensures that lines don't overlap at all when we

    // put a strut between them for pagination purposes.  However, this really isn't the desired rendering, since

@@void RenderBlock::adjustLinePositionForP

    // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the

    // line and all following lines.

    LayoutState* layoutState = view()->layoutState();

    int pageLogicalHeight = layoutState->m_pageLogicalHeight;

    IntRect logicalVisualOverflow = lineBox->logicalVisualOverflowRect(lineBox->lineTop(), lineBox->lineBottom());

    int logicalOffset = logicalVisualOverflow.y();

    int lineHeight = logicalVisualOverflow.maxY() - logicalOffset;

    LayoutUnit pageLogicalHeight = layoutState->m_pageLogicalHeight;

    LayoutRect logicalVisualOverflow = lineBox->logicalVisualOverflowRect(lineBox->lineTop(), lineBox->lineBottom());

    LayoutUnit logicalOffset = logicalVisualOverflow.y();

    LayoutUnit lineHeight = logicalVisualOverflow.maxY() - logicalOffset;

    if (layoutState->m_columnInfo)

        layoutState->m_columnInfo->updateMinimumColumnHeight(lineHeight);

    logicalOffset += delta;

    lineBox->setPaginationStrut(0);

    if (!pageLogicalHeight || lineHeight > pageLogicalHeight)

        return;

    IntSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    int offset = isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width();

    int remainingLogicalHeight = pageLogicalHeight - (offset + logicalOffset) % pageLogicalHeight;

    LayoutSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;

    LayoutUnit offset = isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width();

    LayoutUnit remainingLogicalHeight = pageLogicalHeight - layoutMod(offset + logicalOffset, pageLogicalHeight);

61846189 if (remainingLogicalHeight < lineHeight) {

6185 int totalLogicalHeight = lineHeight + max(0, logicalOffset);

6190 LayoutUnit totalLogicalHeight = lineHeight + max<LayoutUnit>(0, logicalOffset);

61866191 if (lineBox == firstRootBox() && totalLogicalHeight < pageLogicalHeight && !isPositioned() && !isTableCell())

6187 setPaginationStrut(remainingLogicalHeight + max(0, logicalOffset));

6192 setPaginationStrut(remainingLogicalHeight + max<LayoutUnit>(0, logicalOffset));

        else {

            delta += remainingLogicalHeight;

            lineBox->setPaginationStrut(remainingLogicalHeight);

93343

Source/WebCore/rendering/RenderBlock.h

@@public:

    bool beingDestroyed() const { return m_beingDestroyed; }

    // These two functions are overridden for inline-block.

85 virtual int lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;

86 virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;

85 virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;

86 virtual LayoutUnit baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;

    RenderLineBoxList* lineBoxes() { return &m_lineBoxes; }

    const RenderLineBoxList* lineBoxes() const { return &m_lineBoxes; }

@@public:

    // Accessors for logical width/height and margins in the containing block's block-flow direction.

    enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };

    int logicalWidthForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->width() : child->height(); }

    int logicalHeightForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->height() : child->width(); }

    int logicalTopForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->y() : child->x(); }

    int logicalLeftForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->x() : child->y(); }

    LayoutUnit logicalWidthForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->width() : child->height(); }

    LayoutUnit logicalHeightForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->height() : child->width(); }

    LayoutUnit logicalTopForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->y() : child->x(); }

    LayoutUnit logicalLeftForChild(RenderBox* child) { return isHorizontalWritingMode() ? child->x() : child->y(); }

    void setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);

    void setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);

    LayoutUnit marginBeforeForChild(RenderBoxModelObject* child) const;

@@public:

    void setMarginEndForChild(RenderBox* child, LayoutUnit);

    void setMarginBeforeForChild(RenderBox* child, LayoutUnit);

    void setMarginAfterForChild(RenderBox* child, LayoutUnit);

222 int collapsedMarginBeforeForChild(RenderBox* child) const;

223 int collapsedMarginAfterForChild(RenderBox* child) const;

222 LayoutUnit collapsedMarginBeforeForChild(RenderBox* child) const;

223 LayoutUnit collapsedMarginAfterForChild(RenderBox* child) const;

    virtual void updateFirstLetter();

    class MarginValues {

    public:

229 MarginValues(int beforePos, int beforeNeg, int afterPos, int afterNeg)

229 MarginValues(LayoutUnit beforePos, LayoutUnit beforeNeg, LayoutUnit afterPos, LayoutUnit afterNeg)

            : m_positiveMarginBefore(beforePos)

            , m_negativeMarginBefore(beforeNeg)

            , m_positiveMarginAfter(afterPos)

            , m_negativeMarginAfter(afterNeg)

        { }

        int positiveMarginBefore() const { return m_positiveMarginBefore; }

        int negativeMarginBefore() const { return m_negativeMarginBefore; }

        int positiveMarginAfter() const { return m_positiveMarginAfter; }

        int negativeMarginAfter() const { return m_negativeMarginAfter; }

        void setPositiveMarginBefore(int pos) { m_positiveMarginBefore = pos; }

        void setNegativeMarginBefore(int neg) { m_negativeMarginBefore = neg; }

        void setPositiveMarginAfter(int pos) { m_positiveMarginAfter = pos; }

        void setNegativeMarginAfter(int neg) { m_negativeMarginAfter = neg; }

        LayoutUnit positiveMarginBefore() const { return m_positiveMarginBefore; }

        LayoutUnit negativeMarginBefore() const { return m_negativeMarginBefore; }

        LayoutUnit positiveMarginAfter() const { return m_positiveMarginAfter; }

        LayoutUnit negativeMarginAfter() const { return m_negativeMarginAfter; }

        void setPositiveMarginBefore(LayoutUnit pos) { m_positiveMarginBefore = pos; }

        void setNegativeMarginBefore(LayoutUnit neg) { m_negativeMarginBefore = neg; }

        void setPositiveMarginAfter(LayoutUnit pos) { m_positiveMarginAfter = pos; }

        void setNegativeMarginAfter(LayoutUnit neg) { m_negativeMarginAfter = neg; }

245245

246246 private:

        int m_positiveMarginBefore;

        int m_negativeMarginBefore;

        int m_positiveMarginAfter;

        int m_negativeMarginAfter;

        LayoutUnit m_positiveMarginBefore;

        LayoutUnit m_negativeMarginBefore;

        LayoutUnit m_positiveMarginAfter;

        LayoutUnit m_negativeMarginAfter;

    };

    MarginValues marginValuesForChild(RenderBox* child);

@@protected:

    }

    void moveChildrenTo(RenderBlock* to, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, bool fullRemoveInsert = false);

    int maxPositiveMarginBefore() const { return m_rareData ? m_rareData->m_margins.positiveMarginBefore() : RenderBlockRareData::positiveMarginBeforeDefault(this); }

    int maxNegativeMarginBefore() const { return m_rareData ? m_rareData->m_margins.negativeMarginBefore() : RenderBlockRareData::negativeMarginBeforeDefault(this); }

    int maxPositiveMarginAfter() const { return m_rareData ? m_rareData->m_margins.positiveMarginAfter() : RenderBlockRareData::positiveMarginAfterDefault(this); }

    int maxNegativeMarginAfter() const { return m_rareData ? m_rareData->m_margins.negativeMarginAfter() : RenderBlockRareData::negativeMarginAfterDefault(this); }

    LayoutUnit maxPositiveMarginBefore() const { return m_rareData ? m_rareData->m_margins.positiveMarginBefore() : RenderBlockRareData::positiveMarginBeforeDefault(this); }

    LayoutUnit maxNegativeMarginBefore() const { return m_rareData ? m_rareData->m_margins.negativeMarginBefore() : RenderBlockRareData::negativeMarginBeforeDefault(this); }

    LayoutUnit maxPositiveMarginAfter() const { return m_rareData ? m_rareData->m_margins.positiveMarginAfter() : RenderBlockRareData::positiveMarginAfterDefault(this); }

    LayoutUnit maxNegativeMarginAfter() const { return m_rareData ? m_rareData->m_margins.negativeMarginAfter() : RenderBlockRareData::negativeMarginAfterDefault(this); }

294294

295 void setMaxMarginBeforeValues(int pos, int neg);

296 void setMaxMarginAfterValues(int pos, int neg);

295 void setMaxMarginBeforeValues(LayoutUnit pos, LayoutUnit neg);

296 void setMaxMarginAfterValues(LayoutUnit pos, LayoutUnit neg);

    void initMaxMarginValues()

    {

@@protected:

    virtual void paint(PaintInfo&, const LayoutPoint&);

    virtual void paintObject(PaintInfo&, const LayoutPoint&);

314 LayoutUnit logicalRightOffsetForLine(LayoutUnit position, LayoutUnit fixedOffset, bool applyTextIndent = true, int* logicalHeightRemaining = 0) const;

315 LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, LayoutUnit fixedOffset, bool applyTextIndent = true, int* logicalHeightRemaining = 0) const;

314 LayoutUnit logicalRightOffsetForLine(LayoutUnit position, LayoutUnit fixedOffset, bool applyTextIndent = true, LayoutUnit* logicalHeightRemaining = 0) const;

315 LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, LayoutUnit fixedOffset, bool applyTextIndent = true, LayoutUnit* logicalHeightRemaining = 0) const;

    virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;

    virtual void adjustInlineDirectionLineBounds(int /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }

@@protected:

    virtual void computePreferredLogicalWidths();

324 virtual int firstLineBoxBaseline() const;

325 virtual int lastLineBoxBaseline() const;

324 virtual LayoutUnit firstLineBoxBaseline() const;

325 virtual LayoutUnit lastLineBoxBaseline() const;

    virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&);

@@protected:

    // Only used by RenderSVGText, which explicitely overrides RenderBlock::layoutBlock(), do NOT use for anything else.

    void forceLayoutInlineChildren()

    {

358 int repaintLogicalTop = 0;

359 int repaintLogicalBottom = 0;

358 LayoutUnit repaintLogicalTop = 0;

359 LayoutUnit repaintLogicalBottom = 0;

        layoutInlineChildren(true, repaintLogicalTop, repaintLogicalBottom);

    }

#endif

@@private:

    virtual void repaintOverhangingFloats(bool paintAllDescendants);

    void layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom);

392 void layoutInlineChildren(bool relayoutChildren, int& repaintLogicalTop, int& repaintLogicalBottom);

392 void layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);

393393 BidiRun* handleTrailingSpaces(BidiRunList<BidiRun>&, BidiContext*);

394394

395 virtual void borderFitAdjust(IntRect&) const; // Shrink the box in which the border paints if border-fit is set.

395 virtual void borderFitAdjust(LayoutRect&) const; // Shrink the box in which the border paints if border-fit is set.

    virtual void updateBeforeAfterContent(PseudoId);

@@private:

                m_type = FloatPositioned;

        }

444 FloatingObject(Type type, const IntRect& frameRect)

444 FloatingObject(Type type, const LayoutRect& frameRect)

            : m_renderer(0)

            , m_originatingLine(0)

            , m_frameRect(frameRect)

@@private:

        bool isPlaced() const { return m_isPlaced; }

        void setIsPlaced(bool placed = true) { m_isPlaced = placed; }

        int x() const { ASSERT(isPlaced()); return m_frameRect.x(); }

        int maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }

        int y() const { ASSERT(isPlaced()); return m_frameRect.y(); }

        int maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }

        int width() const { return m_frameRect.width(); }

        int height() const { return m_frameRect.height(); }

        void setX(int x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }

        void setY(int y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }

        void setWidth(int width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }

        void setHeight(int height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }

        LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }

        LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }

        LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }

        LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }

        LayoutUnit width() const { return m_frameRect.width(); }

        LayoutUnit height() const { return m_frameRect.height(); }

        void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }

        void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }

        void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }

        void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }

476476

477 const IntRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }

478 void setFrameRect(const IntRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }

477 const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }

478 void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }

#ifndef NDEBUG

        bool isInPlacedTree() const { return m_isInPlacedTree; }

@@private:

        RenderBox* m_renderer;

        RootInlineBox* m_originatingLine;

487 IntRect m_frameRect;

487 LayoutRect m_frameRect;

        int m_paginationStrut;

        unsigned m_type : 3; // Type (left/right aligned or positioned)

        bool m_shouldPaint : 1;

@@private:

    bool positionedFloatsNeedRelayout();

    void clearFloats(BlockLayoutPass);

621 int getClearDelta(RenderBox* child, int yPos);

621 LayoutUnit getClearDelta(RenderBox* child, LayoutUnit yPos);

    virtual bool avoidsFloats() const;

    bool hasOverhangingFloats() { return parent() && !hasColumns() && containsFloats() && lowestFloatLogicalBottomIncludingPositionedFloats() > logicalHeight(); }

    bool hasOverhangingFloat(RenderBox*);

627 void addIntrudingFloats(RenderBlock* prev, int xoffset, int yoffset);

628 int addOverhangingFloats(RenderBlock* child, int xoffset, int yoffset, bool makeChildPaintOtherFloats);

627 void addIntrudingFloats(RenderBlock* prev, LayoutUnit xoffset, LayoutUnit yoffset);

628 LayoutUnit addOverhangingFloats(RenderBlock* child, LayoutUnit xoffset, LayoutUnit yoffset, bool makeChildPaintOtherFloats);

629629

    int lowestFloatLogicalBottom() const { return lowestFloatLogicalBottom(FloatingObject::FloatLeftRight); }

    int lowestFloatLogicalBottomIncludingPositionedFloats() const { return lowestFloatLogicalBottom(FloatingObject::FloatAll); }

    int lowestFloatLogicalBottom(FloatingObject::Type) const;

    int nextFloatLogicalBottomBelow(int) const;

    LayoutUnit lowestFloatLogicalBottom() const { return lowestFloatLogicalBottom(FloatingObject::FloatLeftRight); }

    LayoutUnit lowestFloatLogicalBottomIncludingPositionedFloats() const { return lowestFloatLogicalBottom(FloatingObject::FloatAll); }

    LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type) const;

    LayoutUnit nextFloatLogicalBottomBelow(LayoutUnit) const;

    
    virtual bool hitTestColumns(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);

    virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);

@@private:

    // children.

    virtual RenderBlock* firstLineBlock() const;

648 virtual IntRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth) const;

648 virtual LayoutRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, LayoutUnit outlineWidth) const;

    virtual RenderStyle* outlineStyleForRepaint() const;

    virtual RenderObject* hoverAncestor() const;

@@private:

    LayoutUnit desiredColumnWidth() const;

    unsigned desiredColumnCount() const;

677 void setDesiredColumnCountAndWidth(int count, int width);

677 void setDesiredColumnCountAndWidth(int count, LayoutUnit width);

678678

679 void paintContinuationOutlines(PaintInfo&, const IntPoint&);

679 void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);

680680

681 virtual IntRect localCaretRect(InlineBox*, int caretOffset, int* extraWidthToEndOfLine = 0);

681 virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0);

682682

683 void adjustPointToColumnContents(IntPoint&) const;

684 void adjustForBorderFit(int x, int& left, int& right) const; // Helper function for borderFitAdjust

683 void adjustPointToColumnContents(LayoutPoint&) const;

684 void adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const; // Helper function for borderFitAdjust

685685

686 void markLinesDirtyInBlockRange(int logicalTop, int logicalBottom, RootInlineBox* highest = 0);

686 void markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest = 0);

    void newLine(EClear);

@@private:

    VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);

    // Adjust from painting offsets to the local coords of this renderer

694 void offsetForContents(IntPoint&) const;

694 void offsetForContents(LayoutPoint&) const;

    void calcColumnWidth();

    bool layoutColumns(bool hasSpecifiedPageLogicalHeight, int pageLogicalHeight, LayoutStateMaintainer&);

@@private:

        bool m_determinedMarginBeforeQuirk : 1;

        // These flags track the previous maximal positive and negative margins.

741 int m_positiveMargin;

742 int m_negativeMargin;

741 LayoutUnit m_positiveMargin;

742 LayoutUnit m_negativeMargin;

    public:

        MarginInfo(RenderBlock*, LayoutUnit beforeBorderPadding, LayoutUnit afterBorderPadding);

@@private:

        bool determinedMarginBeforeQuirk() const { return m_determinedMarginBeforeQuirk; }

        bool marginBeforeQuirk() const { return m_marginBeforeQuirk; }

        bool marginAfterQuirk() const { return m_marginAfterQuirk; }

        int positiveMargin() const { return m_positiveMargin; }

        int negativeMargin() const { return m_negativeMargin; }

        int margin() const { return m_positiveMargin - m_negativeMargin; }

        LayoutUnit positiveMargin() const { return m_positiveMargin; }

        LayoutUnit negativeMargin() const { return m_negativeMargin; }

        LayoutUnit margin() const { return m_positiveMargin - m_negativeMargin; }

    };

    void layoutBlockChild(RenderBox* child, MarginInfo&, LayoutUnit& previousFloatLogicalBottom, LayoutUnit& maxFloatLogicalBottom);

@@private:

    LayoutUnit clearFloatsIfNeeded(RenderBox* child, MarginInfo&, int oldTopPosMargin, int oldTopNegMargin, int yPos);

    LayoutUnit estimateLogicalTopPosition(RenderBox* child, const MarginInfo&);

    void determineLogicalLeftPositionForChild(RenderBox* child);

785 void handleAfterSideOfBlock(int top, int bottom, MarginInfo&);

785 void handleAfterSideOfBlock(LayoutUnit top, LayoutUnit bottom, MarginInfo&);

    void setCollapsedBottomMargin(const MarginInfo&);

    // End helper functions and structs used by layoutBlockChildren.

@@private:

    // will not.

    //

    // For a page height of 800px, the first function will return 800 if the value passed in is 0. The second function will simply return 0.

803 int nextPageLogicalTopExcludingBoundaryPoint(int logicalOffset) const;

804 int nextPageLogicalTopIncludingBoundaryPoint(int logicalOffset) const;

803 LayoutUnit nextPageLogicalTopExcludingBoundaryPoint(LayoutUnit logicalOffset) const;

804 LayoutUnit nextPageLogicalTopIncludingBoundaryPoint(LayoutUnit logicalOffset) const;

    int applyBeforeBreak(RenderBox* child, int logicalOffset); // If the child has a before break, then return a new yPos that shifts to the top of the next page/column.

    int applyAfterBreak(RenderBox* child, int logicalOffset, MarginInfo& marginInfo); // If the child has an after break, then return a new offset that shifts to the top of the next page/column.

808 int adjustForUnsplittableChild(RenderBox* child, int logicalOffset, bool includeMargins = false); // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.

809 void adjustLinePositionForPagination(RootInlineBox*, int& deltaOffset); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.

808 LayoutUnit adjustForUnsplittableChild(RenderBox* child, LayoutUnit logicalOffset, bool includeMargins = false); // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.

809 void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.

    struct FloatingObjectHashFunctions {

        static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->m_renderer); }

@@private:

    };

    typedef ListHashSet<FloatingObject*, 4, FloatingObjectHashFunctions> FloatingObjectSet;

    typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;

822 typedef PODInterval<~~LayoutU~~nit, FloatingObject*> FloatingObjectInterval;

823 typedef PODIntervalTree<~~LayoutU~~nit, FloatingObject*> FloatingObjectTree;

822 typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;

823 typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;

    
    template <FloatingObject::Type FloatTypeValue>

    class FloatIntervalSearchAdapter {

93343

Source/WebCore/ChangeLog

Source/WebCore/rendering/RenderBlock.cpp

Source/WebCore/rendering/RenderBlock.h