#include "core/rendering/FlowThreadController.h"
#include "core/rendering/HitTestRequest.h"
#include "core/rendering/HitTestResult.h"
-#include "core/rendering/LayoutRectRecorder.h"
#include "core/rendering/PaintInfo.h"
-#include "core/rendering/RenderBoxRegionInfo.h"
-#include "core/rendering/RenderInline.h"
#include "core/rendering/RenderLayer.h"
-#include "core/rendering/RenderRegion.h"
+#include "core/rendering/RenderMultiColumnSet.h"
#include "core/rendering/RenderView.h"
#include "platform/PODIntervalTree.h"
#include "platform/geometry/TransformState.h"
-namespace WebCore {
+namespace blink {
RenderFlowThread::RenderFlowThread()
: RenderBlockFlow(0)
- , m_previousRegionCount(0)
- , m_autoLogicalHeightRegionsCount(0)
, m_regionsInvalidated(false)
- , m_regionsHaveUniformLogicalWidth(true)
, m_regionsHaveUniformLogicalHeight(true)
- , m_hasRegionsWithStyling(false)
- , m_dispatchRegionLayoutUpdateEvent(false)
- , m_dispatchRegionOversetChangeEvent(false)
, m_pageLogicalSizeChanged(false)
- , m_inConstrainedLayoutPhase(false)
- , m_needsTwoPhasesLayout(false)
{
setFlowThreadState(InsideOutOfFlowThread);
}
-PassRefPtr<RenderStyle> RenderFlowThread::createFlowThreadStyle(RenderStyle* parentStyle)
+void RenderFlowThread::removeRegionFromThread(RenderMultiColumnSet* columnSet)
{
- RefPtr<RenderStyle> newStyle(RenderStyle::create());
- newStyle->inheritFrom(parentStyle);
- newStyle->setDisplay(BLOCK);
- newStyle->setPosition(AbsolutePosition);
- newStyle->setZIndex(0);
- newStyle->setLeft(Length(0, Fixed));
- newStyle->setTop(Length(0, Fixed));
- newStyle->setWidth(Length(100, Percent));
- newStyle->setHeight(Length(100, Percent));
- newStyle->font().update(0);
-
- return newStyle.release();
-}
-
-void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
-{
- RenderBlock::styleDidChange(diff, oldStyle);
-
- if (oldStyle && oldStyle->writingMode() != style()->writingMode())
- invalidateRegions();
-}
-
-void RenderFlowThread::removeFlowChildInfo(RenderObject* child)
-{
- if (child->isBox())
- removeRenderBoxRegionInfo(toRenderBox(child));
- clearRenderObjectCustomStyle(child);
-}
-
-void RenderFlowThread::addRegionToThread(RenderRegion* renderRegion)
-{
- ASSERT(renderRegion);
- m_regionList.add(renderRegion);
- renderRegion->setIsValid(true);
-}
-
-void RenderFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
-{
- ASSERT(renderRegion);
- m_regionList.remove(renderRegion);
+ ASSERT(columnSet);
+ m_multiColumnSetList.remove(columnSet);
}
void RenderFlowThread::invalidateRegions()
return;
}
- m_regionRangeMap.clear();
- m_breakBeforeToRegionMap.clear();
- m_breakAfterToRegionMap.clear();
- setNeedsLayout();
+ setNeedsLayoutAndFullPaintInvalidation();
m_regionsInvalidated = true;
}
{
if (m_regionsInvalidated) {
m_regionsInvalidated = false;
- m_regionsHaveUniformLogicalWidth = true;
m_regionsHaveUniformLogicalHeight = true;
if (hasRegions()) {
- LayoutUnit previousRegionLogicalWidth = 0;
LayoutUnit previousRegionLogicalHeight = 0;
bool firstRegionVisited = false;
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- ASSERT(!region->needsLayout() || region->isRenderRegionSet());
-
- region->deleteAllRenderBoxRegionInfo();
-
- // In the normal layout phase we need to initialize the computedAutoHeight for auto-height regions.
- // See initializeRegionsComputedAutoHeight for the explanation.
- // Also, if we have auto-height regions we can't assume m_regionsHaveUniformLogicalHeight to be true in the first phase
- // because the auto-height regions don't have their height computed yet.
- if (!inConstrainedLayoutPhase() && region->hasAutoLogicalHeight()) {
- region->setComputedAutoHeight(region->maxPageLogicalHeight());
- m_regionsHaveUniformLogicalHeight = false;
- }
-
- LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
- LayoutUnit regionLogicalHeight = region->pageLogicalHeight();
+ for (RenderMultiColumnSetList::iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
+ LayoutUnit regionLogicalHeight = columnSet->pageLogicalHeight();
if (!firstRegionVisited) {
firstRegionVisited = true;
} else {
- if (m_regionsHaveUniformLogicalWidth && previousRegionLogicalWidth != regionLogicalWidth)
- m_regionsHaveUniformLogicalWidth = false;
if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)
m_regionsHaveUniformLogicalHeight = false;
}
- previousRegionLogicalWidth = regionLogicalWidth;
+ previousRegionLogicalHeight = regionLogicalHeight;
}
}
}
- updateLogicalWidth(); // Called to get the maximum logical width for the region.
+ updateLogicalWidth(); // Called to get the maximum logical width for the columnSet.
updateRegionsFlowThreadPortionRect();
}
void RenderFlowThread::layout()
{
- LayoutRectRecorder recorder(*this);
m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();
- // In case this is the second pass of the normal phase we need to update the auto-height regions to their initial value.
- // If the region chain was invalidated this will happen anyway.
- if (!m_regionsInvalidated && !inConstrainedLayoutPhase())
- initializeRegionsComputedAutoHeight();
-
- validateRegions();
-
- // This is the first phase of the layout and because we have auto-height regions we'll need a second
- // pass to update the flow with the computed auto-height regions.
- m_needsTwoPhasesLayout = !inConstrainedLayoutPhase() && hasAutoLogicalHeightRegions();
-
CurrentRenderFlowThreadMaintainer currentFlowThreadSetter(this);
RenderBlockFlow::layout();
m_pageLogicalSizeChanged = false;
-
- if (lastRegion())
- lastRegion()->expandToEncompassFlowThreadContentsIfNeeded();
-
- if (shouldDispatchRegionLayoutUpdateEvent())
- dispatchRegionLayoutUpdateEvent();
-
- if (shouldDispatchRegionOversetChangeEvent())
- dispatchRegionOversetChangeEvent();
-}
-
-void RenderFlowThread::updateLogicalWidth()
-{
- LayoutUnit logicalWidth = initialLogicalWidth();
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- ASSERT(!region->needsLayout() || region->isRenderRegionSet());
- logicalWidth = max(region->pageLogicalWidth(), logicalWidth);
- }
- setLogicalWidth(logicalWidth);
-
- // If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
- if (regionLogicalWidth != logicalWidth) {
- LayoutUnit logicalLeft = style()->direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;
- region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);
- }
- }
}
void RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
computedValues.m_position = logicalTop;
computedValues.m_extent = 0;
- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- ASSERT(!region->needsLayout() || region->isRenderRegionSet());
-
- computedValues.m_extent += region->logicalHeightOfAllFlowThreadContent();
- }
-}
-
-LayoutRect RenderFlowThread::computeRegionClippingRect(const LayoutPoint& offset, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect) const
-{
- LayoutRect regionClippingRect(offset + (flowThreadPortionOverflowRect.location() - flowThreadPortionRect.location()), flowThreadPortionOverflowRect.size());
- if (style()->isFlippedBlocksWritingMode())
- regionClippingRect.move(flowThreadPortionRect.size() - flowThreadPortionOverflowRect.size());
- return regionClippingRect;
-}
-
-void RenderFlowThread::paintFlowThreadPortionInRegion(PaintInfo& paintInfo, RenderRegion* region, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& paintOffset) const
-{
- GraphicsContext* context = paintInfo.context;
- if (!context)
- return;
-
- // RenderFlowThread should start painting its content in a position that is offset
- // from the region rect's current position. The amount of offset is equal to the location of
- // the flow thread portion in the flow thread's local coordinates.
- // Note that we have to pixel snap the location at which we're going to paint, since this is necessary
- // to minimize the amount of incorrect snapping that would otherwise occur.
- // If we tried to paint by applying a non-integral translation, then all the
- // layout code that attempted to pixel snap would be incorrect.
- IntPoint adjustedPaintOffset;
- LayoutPoint portionLocation;
- if (style()->isFlippedBlocksWritingMode()) {
- LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
- flipForWritingMode(flippedFlowThreadPortionRect);
- portionLocation = flippedFlowThreadPortionRect.location();
- } else {
- portionLocation = flowThreadPortionRect.location();
- }
- adjustedPaintOffset = roundedIntPoint(paintOffset - portionLocation);
-
- // The clipping rect for the region is set up by assuming the flowThreadPortionRect is going to paint offset from adjustedPaintOffset.
- // Remember that we pixel snapped and moved the paintOffset and stored the snapped result in adjustedPaintOffset. Now we add back in
- // the flowThreadPortionRect's location to get the spot where we expect the portion to actually paint. This can be non-integral and
- // that's ok. We then pixel snap the resulting clipping rect to account for snapping that will occur when the flow thread paints.
- IntRect regionClippingRect = pixelSnappedIntRect(computeRegionClippingRect(adjustedPaintOffset + portionLocation, flowThreadPortionRect, flowThreadPortionOverflowRect));
-
- PaintInfo info(paintInfo);
- info.rect.intersect(regionClippingRect);
-
- if (!info.rect.isEmpty()) {
- context->save();
-
- context->clip(regionClippingRect);
-
- context->translate(adjustedPaintOffset.x(), adjustedPaintOffset.y());
- info.rect.moveBy(-adjustedPaintOffset);
-
- if (info.phase == PaintPhaseTextClip)
- info.paintBehavior = PaintBehaviorForceBlackText;
-
- layer()->paint(context, info.rect, info.paintBehavior, 0, region, PaintLayerTemporaryClipRects);
-
- context->restore();
+ for (RenderMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
+ computedValues.m_extent += columnSet->logicalHeightOfAllFlowThreadContent();
}
}
{
if (hitTestAction == HitTestBlockBackground)
return false;
- return RenderBlock::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
-}
-
-bool RenderFlowThread::hitTestFlowThreadPortionInRegion(RenderRegion* region, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset) const
-{
- LayoutRect regionClippingRect = computeRegionClippingRect(accumulatedOffset, flowThreadPortionRect, flowThreadPortionOverflowRect);
- if (!regionClippingRect.contains(locationInContainer.point()))
- return false;
-
- LayoutSize renderFlowThreadOffset;
- if (style()->isFlippedBlocksWritingMode()) {
- LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
- flipForWritingMode(flippedFlowThreadPortionRect);
- renderFlowThreadOffset = accumulatedOffset - flippedFlowThreadPortionRect.location();
- } else {
- renderFlowThreadOffset = accumulatedOffset - flowThreadPortionRect.location();
- }
-
- // Always ignore clipping, since the RenderFlowThread has nothing to do with the bounds of the FrameView.
- HitTestRequest newRequest(request.type() | HitTestRequest::IgnoreClipping | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
-
- // Make a new temporary HitTestLocation in the new region.
- HitTestLocation newHitTestLocation(locationInContainer, -renderFlowThreadOffset, region);
-
- bool isPointInsideFlowThread = layer()->hitTest(newRequest, newHitTestLocation, result);
-
- // FIXME: Should we set result.m_localPoint back to the RenderRegion's coordinate space or leave it in the RenderFlowThread's coordinate
- // space? Right now it's staying in the RenderFlowThread's coordinate space, which may end up being ok. We will know more when we get around to
- // patching positionForPoint.
- return isPointInsideFlowThread;
+ return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
}
-bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const
+bool RenderFlowThread::shouldIssuePaintInvalidations(const LayoutRect& r) const
{
if (view()->document().printing() || r.isEmpty())
return false;
return true;
}
-void RenderFlowThread::repaintRectangleInRegions(const LayoutRect& repaintRect) const
+void RenderFlowThread::paintInvalidationRectangleInRegions(const LayoutRect& paintInvalidationRect) const
{
- if (!shouldRepaint(repaintRect) || !hasValidRegionInfo())
+ if (!shouldIssuePaintInvalidations(paintInvalidationRect) || !hasValidRegionInfo())
return;
- LayoutStateDisabler layoutStateDisabler(view()); // We can't use layout state to repaint, since the regions are somewhere else.
-
// We can't use currentFlowThread as it is possible to have interleaved flow threads and the wrong one could be used.
- // Let each region figure out the proper enclosing flow thread.
+ // Let each columnSet figure out the proper enclosing flow thread.
CurrentRenderFlowThreadDisabler disabler(view());
- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
+ for (RenderMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
- region->repaintFlowThreadContent(repaintRect);
+ columnSet->paintInvalidationForFlowThreadContent(paintInvalidationRect);
}
}
-RenderRegion* RenderFlowThread::regionAtBlockOffset(LayoutUnit offset, bool extendLastRegion, RegionAutoGenerationPolicy autoGenerationPolicy)
-{
- ASSERT(!m_regionsInvalidated);
-
- if (autoGenerationPolicy == AllowRegionAutoGeneration)
- autoGenerateRegionsToBlockOffset(offset);
-
- if (offset <= 0)
- return m_regionList.isEmpty() ? 0 : m_regionList.first();
-
- RegionSearchAdapter adapter(offset);
- m_regionIntervalTree.allOverlapsWithAdapter<RegionSearchAdapter>(adapter);
-
- // If no region was found, the offset is in the flow thread overflow.
- // The last region will contain the offset if extendLastRegion is set or if the last region is a set.
- if (!adapter.result() && !m_regionList.isEmpty() && (extendLastRegion || m_regionList.last()->isRenderRegionSet()))
- return m_regionList.last();
-
- return adapter.result();
-}
-
-RenderRegion* RenderFlowThread::regionFromAbsolutePointAndBox(IntPoint absolutePoint, const RenderBox* flowedBox)
-{
- if (!flowedBox)
- return 0;
-
- RenderRegion* startRegion = 0;
- RenderRegion* endRegion = 0;
- getRegionRangeForBox(flowedBox, startRegion, endRegion);
-
- if (!startRegion)
- return 0;
-
- for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- IntRect regionAbsoluteRect(roundedIntPoint(region->localToAbsolute()), roundedIntSize(region->frameRect().size()));
- if (regionAbsoluteRect.contains(absolutePoint))
- return region;
-
- if (region == endRegion)
- break;
- }
-
- return 0;
-}
-
-LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint)
-{
- LayoutPoint referencePoint = startPoint;
-
- // FIXME: This needs to be adapted for different writing modes inside the flow thread.
- RenderRegion* startRegion = regionAtBlockOffset(referencePoint.y());
- if (startRegion) {
- RenderBoxModelObject* startRegionBox = startRegion->isRenderNamedFlowFragment() ? toRenderBoxModelObject(startRegion->parent()) : startRegion;
- // Take into account the offset coordinates of the region.
- RenderObject* currObject = startRegionBox;
- RenderObject* currOffsetParentRenderer;
- Element* currOffsetParentElement;
- while ((currOffsetParentElement = currObject->offsetParent()) && (currOffsetParentRenderer = currOffsetParentElement->renderer())) {
- if (currObject->isBoxModelObject())
- referencePoint.move(toRenderBoxModelObject(currObject)->offsetLeft(), toRenderBoxModelObject(currObject)->offsetTop());
-
- // Since we're looking for the offset relative to the body, we must also
- // take into consideration the borders of the region's offsetParent.
- if (currOffsetParentRenderer->isBox() && !currOffsetParentRenderer->isBody())
- referencePoint.move(toRenderBox(currOffsetParentRenderer)->borderLeft(), toRenderBox(currOffsetParentRenderer)->borderTop());
-
- currObject = currOffsetParentRenderer;
- }
-
- // We need to check if any of this box's containing blocks start in a different region
- // and if so, drop the object's top position (which was computed relative to its containing block
- // and is no longer valid) and recompute it using the region in which it flows as reference.
- bool wasComputedRelativeToOtherRegion = false;
- const RenderBlock* objContainingBlock = boxModelObject.containingBlock();
- while (objContainingBlock && !objContainingBlock->isRenderNamedFlowThread()) {
- // Check if this object is in a different region.
- RenderRegion* parentStartRegion = 0;
- RenderRegion* parentEndRegion = 0;
- getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion);
- if (parentStartRegion && parentStartRegion != startRegion) {
- wasComputedRelativeToOtherRegion = true;
- break;
- }
- objContainingBlock = objContainingBlock->containingBlock();
- }
-
- if (wasComputedRelativeToOtherRegion) {
- if (boxModelObject.isBox()) {
- // Use borderBoxRectInRegion to account for variations such as percentage margins.
- LayoutRect borderBoxRect = toRenderBox(&boxModelObject)->borderBoxRectInRegion(startRegion, RenderBox::DoNotCacheRenderBoxRegionInfo);
- referencePoint.move(borderBoxRect.location().x(), 0);
- }
-
- // Get the logical top coordinate of the current object.
- LayoutUnit top = 0;
- if (boxModelObject.isRenderBlock()) {
- top = toRenderBlock(&boxModelObject)->offsetFromLogicalTopOfFirstPage();
- } else {
- if (boxModelObject.containingBlock())
- top = boxModelObject.containingBlock()->offsetFromLogicalTopOfFirstPage();
-
- if (boxModelObject.isBox())
- top += toRenderBox(&boxModelObject)->topLeftLocation().y();
- else if (boxModelObject.isRenderInline())
- top -= toRenderInline(&boxModelObject)->borderTop();
- }
-
- // Get the logical top of the region this object starts in
- // and compute the object's top, relative to the region's top.
- LayoutUnit regionLogicalTop = startRegion->pageLogicalTopForOffset(top);
- LayoutUnit topRelativeToRegion = top - regionLogicalTop;
- referencePoint.setY(startRegionBox->offsetTop() + topRelativeToRegion);
-
- // Since the top has been overriden, check if the
- // relative/sticky positioning must be reconsidered.
- if (boxModelObject.isRelPositioned())
- referencePoint.move(0, boxModelObject.relativePositionOffset().height());
- else if (boxModelObject.isStickyPositioned())
- referencePoint.move(0, boxModelObject.stickyPositionOffset().height());
- }
-
- // Since we're looking for the offset relative to the body, we must also
- // take into consideration the borders of the region.
- referencePoint.move(startRegionBox->borderLeft(), startRegionBox->borderTop());
- }
-
- return referencePoint;
-}
-
-LayoutUnit RenderFlowThread::pageLogicalTopForOffset(LayoutUnit offset)
-{
- RenderRegion* region = regionAtBlockOffset(offset);
- return region ? region->pageLogicalTopForOffset(offset) : LayoutUnit();
-}
-
-LayoutUnit RenderFlowThread::pageLogicalWidthForOffset(LayoutUnit offset)
-{
- RenderRegion* region = regionAtBlockOffset(offset, true);
- return region ? region->pageLogicalWidth() : contentLogicalWidth();
-}
-
LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset)
{
- RenderRegion* region = regionAtBlockOffset(offset);
- if (!region)
+ RenderMultiColumnSet* columnSet = columnSetAtBlockOffset(offset);
+ if (!columnSet)
return 0;
- return region->pageLogicalHeight();
+ return columnSet->pageLogicalHeight();
}
LayoutUnit RenderFlowThread::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule)
{
- RenderRegion* region = regionAtBlockOffset(offset);
- if (!region)
+ RenderMultiColumnSet* columnSet = columnSetAtBlockOffset(offset);
+ if (!columnSet)
return 0;
- LayoutUnit pageLogicalTop = region->pageLogicalTopForOffset(offset);
- LayoutUnit pageLogicalHeight = region->pageLogicalHeight();
+ LayoutUnit pageLogicalTop = columnSet->pageLogicalTopForOffset(offset);
+ LayoutUnit pageLogicalHeight = columnSet->pageLogicalHeight();
LayoutUnit pageLogicalBottom = pageLogicalTop + pageLogicalHeight;
LayoutUnit remainingHeight = pageLogicalBottom - offset;
if (pageBoundaryRule == IncludePageBoundary) {
// If IncludePageBoundary is set, the line exactly on the top edge of a
- // region will act as being part of the previous region.
+ // columnSet will act as being part of the previous columnSet.
remainingHeight = intMod(remainingHeight, pageLogicalHeight);
}
return remainingHeight;
}
-RenderRegion* RenderFlowThread::mapFromFlowToRegion(TransformState& transformState) const
-{
- if (!hasValidRegionInfo())
- return 0;
-
- LayoutRect boxRect = transformState.mappedQuad().enclosingBoundingBox();
- flipForWritingMode(boxRect);
-
- // FIXME: We need to refactor RenderObject::absoluteQuads to be able to split the quads across regions,
- // for now we just take the center of the mapped enclosing box and map it to a region.
- // Note: Using the center in order to avoid rounding errors.
-
- LayoutPoint center = boxRect.center();
- RenderRegion* renderRegion = const_cast<RenderFlowThread*>(this)->regionAtBlockOffset(isHorizontalWritingMode() ? center.y() : center.x(), true, DisallowRegionAutoGeneration);
- if (!renderRegion)
- return 0;
-
- LayoutRect flippedRegionRect(renderRegion->flowThreadPortionRect());
- flipForWritingMode(flippedRegionRect);
-
- transformState.move(renderRegion->contentBoxRect().location() - flippedRegionRect.location());
-
- return renderRegion;
-}
-
-void RenderFlowThread::removeRenderBoxRegionInfo(RenderBox* box)
-{
- if (!hasRegions())
- return;
-
- // If the region chain was invalidated the next layout will clear the box information from all the regions.
- if (m_regionsInvalidated) {
- ASSERT(selfNeedsLayout());
- return;
- }
-
- RenderRegion* startRegion;
- RenderRegion* endRegion;
- getRegionRangeForBox(box, startRegion, endRegion);
-
- for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- region->removeRenderBoxRegionInfo(box);
- if (region == endRegion)
- break;
- }
-
-#ifndef NDEBUG
- // We have to make sure we did not leave any RenderBoxRegionInfo attached.
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- ASSERT(!region->renderBoxRegionInfo(box));
- }
-#endif
-
- m_regionRangeMap.remove(box);
-}
-
-bool RenderFlowThread::logicalWidthChangedInRegionsForBlock(const RenderBlock* block)
-{
- if (!hasRegions())
- return false;
-
- RenderRegion* startRegion;
- RenderRegion* endRegion;
- getRegionRangeForBox(block, startRegion, endRegion);
-
- // When the region chain is invalidated the box information is discarded so we must assume the width has changed.
- if (m_pageLogicalSizeChanged && !startRegion)
- return true;
-
- // Not necessary for the flow thread, since we already computed the correct info for it.
- if (block == this)
- return false;
-
- for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- ASSERT(!region->needsLayout() || region->isRenderRegionSet());
-
- OwnPtr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);
- if (!oldInfo)
- continue;
-
- LayoutUnit oldLogicalWidth = oldInfo->logicalWidth();
- RenderBoxRegionInfo* newInfo = block->renderBoxRegionInfo(region);
- if (!newInfo || newInfo->logicalWidth() != oldLogicalWidth)
- return true;
-
- if (region == endRegion)
- break;
- }
-
- return false;
-}
-
-LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstRegion() const
-{
- RenderRegion* firstValidRegionInFlow = firstRegion();
- if (!firstValidRegionInFlow)
- return 0;
- return isHorizontalWritingMode() ? firstValidRegionInFlow->contentWidth() : firstValidRegionInFlow->contentHeight();
-}
-
-LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstRegion() const
-{
- RenderRegion* firstValidRegionInFlow = firstRegion();
- if (!firstValidRegionInFlow)
- return 0;
- return isHorizontalWritingMode() ? firstValidRegionInFlow->contentHeight() : firstValidRegionInFlow->contentWidth();
-}
-
-LayoutUnit RenderFlowThread::contentLogicalLeftOfFirstRegion() const
-{
- RenderRegion* firstValidRegionInFlow = firstRegion();
- if (!firstValidRegionInFlow)
- return 0;
- return isHorizontalWritingMode() ? firstValidRegionInFlow->flowThreadPortionRect().x() : firstValidRegionInFlow->flowThreadPortionRect().y();
-}
-
RenderRegion* RenderFlowThread::firstRegion() const
{
if (!hasValidRegionInfo())
return 0;
- return m_regionList.first();
+ return m_multiColumnSetList.first();
}
RenderRegion* RenderFlowThread::lastRegion() const
{
if (!hasValidRegionInfo())
return 0;
- return m_regionList.last();
-}
-
-void RenderFlowThread::clearRenderObjectCustomStyle(const RenderObject* object,
- const RenderRegion* oldStartRegion, const RenderRegion* oldEndRegion,
- const RenderRegion* newStartRegion, const RenderRegion* newEndRegion)
-{
- // Clear the styles for the object in the regions.
- // The styles are not cleared for the regions that are contained in both ranges.
- bool insideOldRegionRange = false;
- bool insideNewRegionRange = false;
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
-
- if (oldStartRegion == region)
- insideOldRegionRange = true;
- if (newStartRegion == region)
- insideNewRegionRange = true;
-
- if (!(insideOldRegionRange && insideNewRegionRange))
- region->clearObjectStyleInRegion(object);
-
- if (oldEndRegion == region)
- insideOldRegionRange = false;
- if (newEndRegion == region)
- insideNewRegionRange = false;
- }
-}
-
-void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, LayoutUnit offsetFromLogicalTopOfFirstPage)
-{
- if (!hasRegions())
- return;
-
- // FIXME: Not right for differing writing-modes.
- RenderRegion* startRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage, true);
- RenderRegion* endRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage + box->logicalHeight(), true);
- RenderRegionRangeMap::iterator it = m_regionRangeMap.find(box);
- if (it == m_regionRangeMap.end()) {
- m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));
- clearRenderObjectCustomStyle(box);
- return;
- }
-
- // If nothing changed, just bail.
- RenderRegionRange& range = it->value;
- if (range.startRegion() == startRegion && range.endRegion() == endRegion)
- return;
-
- // Delete any info that we find before our new startRegion and after our new endRegion.
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- if (region == startRegion) {
- iter = m_regionList.find(endRegion);
- continue;
- }
-
- region->removeRenderBoxRegionInfo(box);
-
- if (region == range.endRegion())
- break;
- }
-
- clearRenderObjectCustomStyle(box, range.startRegion(), range.endRegion(), startRegion, endRegion);
- range.setRange(startRegion, endRegion);
-}
-
-void RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
-{
- startRegion = 0;
- endRegion = 0;
- RenderRegionRangeMap::const_iterator it = m_regionRangeMap.find(box);
- if (it == m_regionRangeMap.end())
- return;
-
- const RenderRegionRange& range = it->value;
- startRegion = range.startRegion();
- endRegion = range.endRegion();
- ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));
-}
-
-void RenderFlowThread::applyBreakAfterContent(LayoutUnit clientHeight)
-{
- // Simulate a region break at height. If it points inside an auto logical height region,
- // then it may determine the region computed autoheight.
- addForcedRegionBreak(clientHeight, this, false);
-}
-
-bool RenderFlowThread::regionInRange(const RenderRegion* targetRegion, const RenderRegion* startRegion, const RenderRegion* endRegion) const
-{
- ASSERT(targetRegion);
-
- for (RenderRegionList::const_iterator it = m_regionList.find(const_cast<RenderRegion*>(startRegion)); it != m_regionList.end(); ++it) {
- const RenderRegion* currRegion = *it;
- if (targetRegion == currRegion)
- return true;
- if (currRegion == endRegion)
- break;
- }
-
- return false;
-}
-
-// Check if the content is flown into at least a region with region styling rules.
-void RenderFlowThread::checkRegionsWithStyling()
-{
- bool hasRegionsWithStyling = false;
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- if (region->hasCustomRegionStyle()) {
- hasRegionsWithStyling = true;
- break;
- }
- }
- m_hasRegionsWithStyling = hasRegionsWithStyling;
-}
-
-bool RenderFlowThread::objectInFlowRegion(const RenderObject* object, const RenderRegion* region) const
-{
- ASSERT(object);
- ASSERT(region);
-
- RenderFlowThread* flowThread = object->flowThreadContainingBlock();
- if (flowThread != this)
- return false;
- if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
- return false;
-
- RenderBox* enclosingBox = object->enclosingBox();
- RenderRegion* enclosingBoxStartRegion = 0;
- RenderRegion* enclosingBoxEndRegion = 0;
- getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion);
- if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
- return false;
-
- if (object->isBox())
- return true;
-
- LayoutRect objectABBRect = object->absoluteBoundingBoxRect(true);
- if (!objectABBRect.width())
- objectABBRect.setWidth(1);
- if (!objectABBRect.height())
- objectABBRect.setHeight(1);
- if (objectABBRect.intersects(region->absoluteBoundingBoxRect(true)))
- return true;
-
- if (region == lastRegion()) {
- // If the object does not intersect any of the enclosing box regions
- // then the object is in last region.
- for (RenderRegionList::const_iterator it = m_regionList.find(enclosingBoxStartRegion); it != m_regionList.end(); ++it) {
- const RenderRegion* currRegion = *it;
- if (currRegion == region)
- break;
- if (objectABBRect.intersects(currRegion->absoluteBoundingBoxRect(true)))
- return false;
- }
- return true;
- }
-
- return false;
-}
-
-#ifndef NDEBUG
-bool RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent() const
-{
- unsigned autoLogicalHeightRegions = 0;
- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- const RenderRegion* region = *iter;
- if (region->hasAutoLogicalHeight())
- autoLogicalHeightRegions++;
- }
-
- return autoLogicalHeightRegions == m_autoLogicalHeightRegionsCount;
+ return m_multiColumnSetList.last();
}
-#endif
-// During the normal layout phase of the named flow the regions are initialized with a height equal to their max-height.
-// This way unforced breaks are automatically placed when a region is full and the content height/position correctly estimated.
-// Also, the region where a forced break falls is exactly the region found at the forced break offset inside the flow content.
-void RenderFlowThread::initializeRegionsComputedAutoHeight(RenderRegion* startRegion)
+void RenderFlowThread::updateRegionsFlowThreadPortionRect()
{
- ASSERT(!inConstrainedLayoutPhase());
- if (!hasAutoLogicalHeightRegions())
- return;
-
- RenderRegionList::iterator regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin();
- for (; regionIter != m_regionList.end(); ++regionIter) {
- RenderRegion* region = *regionIter;
- if (region->hasAutoLogicalHeight())
- region->setComputedAutoHeight(region->maxPageLogicalHeight());
- }
-}
-
-void RenderFlowThread::markAutoLogicalHeightRegionsForLayout()
-{
- ASSERT(hasAutoLogicalHeightRegions());
-
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- if (!region->hasAutoLogicalHeight())
- continue;
-
- // FIXME: We need to find a way to avoid marking all the regions ancestors for layout
- // as we are already inside layout.
- region->setNeedsLayout();
- }
-}
-
-void RenderFlowThread::updateRegionsFlowThreadPortionRect(const RenderRegion* lastRegionWithContent)
-{
- ASSERT(!lastRegionWithContent || (!inConstrainedLayoutPhase() && hasAutoLogicalHeightRegions()));
LayoutUnit logicalHeight = 0;
- bool emptyRegionsSegment = false;
// FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.
- m_regionIntervalTree.clear();
- m_regionIntervalTree.initIfNeeded();
- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
-
- // If we find an empty auto-height region, clear the computedAutoHeight value.
- if (emptyRegionsSegment && region->hasAutoLogicalHeight())
- region->clearComputedAutoHeight();
-
- LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
- LayoutUnit regionLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, region->logicalHeightOfAllFlowThreadContent());
-
- LayoutRect regionRect(style()->direction() == LTR ? LayoutUnit() : logicalWidth() - regionLogicalWidth, logicalHeight, regionLogicalWidth, regionLogicalHeight);
-
- region->setFlowThreadPortionRect(isHorizontalWritingMode() ? regionRect : regionRect.transposedRect());
+ m_multiColumnSetIntervalTree.clear();
+ m_multiColumnSetIntervalTree.initIfNeeded();
+ for (RenderMultiColumnSetList::iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
- m_regionIntervalTree.add(RegionIntervalTree::createInterval(logicalHeight, logicalHeight + regionLogicalHeight, region));
+ LayoutUnit columnSetLogicalWidth = columnSet->pageLogicalWidth();
+ LayoutUnit columnSetLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, columnSet->logicalHeightOfAllFlowThreadContent());
- logicalHeight += regionLogicalHeight;
+ LayoutRect columnSetRect(style()->direction() == LTR ? LayoutUnit() : logicalWidth() - columnSetLogicalWidth, logicalHeight, columnSetLogicalWidth, columnSetLogicalHeight);
- // Once we find the last region with content the next regions are considered empty.
- if (lastRegionWithContent == region)
- emptyRegionsSegment = true;
- }
-
- ASSERT(!lastRegionWithContent || emptyRegionsSegment);
-}
-
-// Even if we require the break to occur at offsetBreakInFlowThread, because regions may have min/max-height values,
-// it is possible that the break will occur at a different offset than the original one required.
-// offsetBreakAdjustment measures the different between the requested break offset and the current break offset.
-bool RenderFlowThread::addForcedRegionBreak(LayoutUnit offsetBreakInFlowThread, RenderObject* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment)
-{
- // We take breaks into account for height computation for auto logical height regions
- // only in the layout phase in which we lay out the flows threads unconstrained
- // and we use the content breaks to determine the computedAutoHeight for
- // auto logical height regions.
- if (inConstrainedLayoutPhase())
- return false;
-
- // Breaks can come before or after some objects. We need to track these objects, so that if we get
- // multiple breaks for the same object (for example because of multiple layouts on the same object),
- // we need to invalidate every other region after the old one and start computing from fresh.
- RenderObjectToRegionMap& mapToUse = isBefore ? m_breakBeforeToRegionMap : m_breakAfterToRegionMap;
- RenderObjectToRegionMap::iterator iter = mapToUse.find(breakChild);
- if (iter != mapToUse.end()) {
- RenderRegionList::iterator regionIter = m_regionList.find(iter->value);
- ASSERT_WITH_SECURITY_IMPLICATION(regionIter != m_regionList.end());
- ASSERT((*regionIter)->hasAutoLogicalHeight());
- initializeRegionsComputedAutoHeight(*regionIter);
-
- // We need to update the regions flow thread portion rect because we are going to process
- // a break on these regions.
- updateRegionsFlowThreadPortionRect();
- }
-
- // Simulate a region break at offsetBreakInFlowThread. If it points inside an auto logical height region,
- // then it determines the region computed auto height.
- RenderRegion* region = regionAtBlockOffset(offsetBreakInFlowThread);
- if (!region)
- return false;
-
- bool lastBreakAfterContent = breakChild == this;
- bool hasComputedAutoHeight = false;
-
- LayoutUnit currentRegionOffsetInFlowThread = isHorizontalWritingMode() ? region->flowThreadPortionRect().y() : region->flowThreadPortionRect().x();
- LayoutUnit offsetBreakInCurrentRegion = offsetBreakInFlowThread - currentRegionOffsetInFlowThread;
-
- if (region->hasAutoLogicalHeight()) {
- // A forced break can appear only in an auto-height region that didn't have a forced break before.
- // This ASSERT is a good-enough heuristic to verify the above condition.
- ASSERT(region->maxPageLogicalHeight() == region->computedAutoHeight());
-
- mapToUse.set(breakChild, region);
-
- hasComputedAutoHeight = true;
-
- // Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.
- LayoutUnit regionComputedAutoHeight = region->constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion, -1);
+ columnSet->setFlowThreadPortionRect(isHorizontalWritingMode() ? columnSetRect : columnSetRect.transposedRect());
- // The new height of this region needs to be smaller than the initial value, the max height. A forced break is the only way to change the initial
- // height of an auto-height region besides content ending.
- ASSERT(regionComputedAutoHeight <= region->maxPageLogicalHeight());
+ m_multiColumnSetIntervalTree.add(MultiColumnSetIntervalTree::createInterval(logicalHeight, logicalHeight + columnSetLogicalHeight, columnSet));
- region->setComputedAutoHeight(regionComputedAutoHeight);
-
- currentRegionOffsetInFlowThread += regionComputedAutoHeight;
- } else {
- currentRegionOffsetInFlowThread += isHorizontalWritingMode() ? region->flowThreadPortionRect().height() : region->flowThreadPortionRect().width();
+ logicalHeight += columnSetLogicalHeight;
}
-
- // If the break was found inside an auto-height region its size changed so we need to recompute the flow thread portion rectangles.
- // Also, if this is the last break after the content we need to clear the computedAutoHeight value on the last empty regions.
- if (hasAutoLogicalHeightRegions() && lastBreakAfterContent)
- updateRegionsFlowThreadPortionRect(region);
- else if (hasComputedAutoHeight)
- updateRegionsFlowThreadPortionRect();
-
- if (offsetBreakAdjustment)
- *offsetBreakAdjustment = max<LayoutUnit>(0, currentRegionOffsetInFlowThread - offsetBreakInFlowThread);
-
- return hasComputedAutoHeight;
-}
-
-void RenderFlowThread::incrementAutoLogicalHeightRegions()
-{
- if (!m_autoLogicalHeightRegionsCount)
- view()->flowThreadController()->incrementFlowThreadsWithAutoLogicalHeightRegions();
- ++m_autoLogicalHeightRegionsCount;
-}
-
-void RenderFlowThread::decrementAutoLogicalHeightRegions()
-{
- ASSERT(m_autoLogicalHeightRegionsCount > 0);
- --m_autoLogicalHeightRegionsCount;
- if (!m_autoLogicalHeightRegionsCount)
- view()->flowThreadController()->decrementFlowThreadsWithAutoLogicalHeightRegions();
}
void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
{
ASSERT(!m_regionsInvalidated);
- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
- region->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
+ for (RenderMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
+ columnSet->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
}
}
ASSERT(!m_regionsInvalidated);
LayoutRect result;
- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
- RenderRegion* region = *iter;
+ for (RenderMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
+ RenderMultiColumnSet* columnSet = *iter;
LayerFragments fragments;
- region->collectLayerFragments(fragments, layerBoundingBox, PaintInfo::infiniteRect());
+ columnSet->collectLayerFragments(fragments, layerBoundingBox, PaintInfo::infiniteRect());
for (size_t i = 0; i < fragments.size(); ++i) {
const LayerFragment& fragment = fragments.at(i);
LayoutRect fragmentRect(layerBoundingBox);
return 0;
}
-void RenderFlowThread::pushFlowThreadLayoutState(const RenderObject* object)
+void RenderFlowThread::pushFlowThreadLayoutState(const RenderObject& object)
{
if (const RenderBox* currentBoxDescendant = currentStatePusherRenderBox()) {
LayoutState* layoutState = currentBoxDescendant->view()->layoutState();
if (layoutState && layoutState->isPaginated()) {
ASSERT(layoutState->renderer() == currentBoxDescendant);
- LayoutSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;
+ LayoutSize offsetDelta = layoutState->layoutOffset() - layoutState->pageOffset();
setOffsetFromLogicalTopOfFirstRegion(currentBoxDescendant, currentBoxDescendant->isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width());
}
}
- m_statePusherObjectsStack.add(object);
+ m_statePusherObjectsStack.add(&object);
}
void RenderFlowThread::popFlowThreadLayoutState()
LayoutState* layoutState = view()->layoutState();
ASSERT(layoutState->renderer() == currentBlock);
ASSERT(layoutState && layoutState->isPaginated());
- LayoutSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;
+ LayoutSize offsetDelta = layoutState->layoutOffset() - layoutState->pageOffset();
return currentBoxDescendant->isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width();
}
return currentBlock->isHorizontalWritingMode() ? blockRect.y() : blockRect.x();
}
-void RenderFlowThread::RegionSearchAdapter::collectIfNeeded(const RegionInterval& interval)
+void RenderFlowThread::RegionSearchAdapter::collectIfNeeded(const MultiColumnSetInterval& interval)
{
if (m_result)
return;
m_result = interval.data();
}
-void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
-{
- if (this == repaintContainer)
- return;
-
- if (RenderRegion* region = mapFromFlowToRegion(transformState)) {
- // FIXME: The cast below is probably not the best solution, we may need to find a better way.
- static_cast<const RenderObject*>(region)->mapLocalToContainer(region->containerForRepaint(), transformState, mode, wasFixed);
- }
-}
-
CurrentRenderFlowThreadMaintainer::CurrentRenderFlowThreadMaintainer(RenderFlowThread* renderFlowThread)
: m_renderFlowThread(renderFlowThread)
, m_previousRenderFlowThread(0)
return;
RenderView* view = m_renderFlowThread->view();
m_previousRenderFlowThread = view->flowThreadController()->currentRenderFlowThread();
- ASSERT(!m_previousRenderFlowThread || !renderFlowThread->isRenderNamedFlowThread());
view->flowThreadController()->setCurrentRenderFlowThread(m_renderFlowThread);
}
}
-} // namespace WebCore
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff