// 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 overrideContentLogicalHeight for
// auto logical height regions.
if (view()->constrainedFlowThreadsLayoutPhase())
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(regionIter != m_regionList.end());
ASSERT((*regionIter)->hasAutoLogicalHeight());
initializeRegionsOverrideLogicalContentHeight(*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 override logical content height.
RenderRegion* region = regionAtBlockOffset(offsetBreakInFlowThread);
if (!region)
return false;
bool overrideLogicalContentHeightComputed = 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->overrideLogicalContentHeight());
mapToUse.set(breakChild, region);
overrideLogicalContentHeightComputed = true;
// Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.
LayoutUnit regionOverrideLogicalContentHeight = region->computeReplacedLogicalHeightRespectingMinMaxHeight(offsetBreakInCurrentRegion);
// 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(regionOverrideLogicalContentHeight <= region->maxPageLogicalHeight());
region->setOverrideLogicalContentHeight(regionOverrideLogicalContentHeight);
currentRegionOffsetInFlowThread += regionOverrideLogicalContentHeight;
} else
currentRegionOffsetInFlowThread += isHorizontalWritingMode() ? region->flowThreadPortionRect().height() : region->flowThreadPortionRect().width();
// If the break was found inside an auto-height region its size changed so we need to recompute the flow thread portion rectangles.
if (overrideLogicalContentHeightComputed)
updateRegionsFlowThreadPortionRect();
if (offsetBreakAdjustment)
*offsetBreakAdjustment = max<LayoutUnit>(0, currentRegionOffsetInFlowThread - offsetBreakInFlowThread);
return overrideLogicalContentHeightComputed;
}
