void RenderFlowThread::updateRegionsFlowThreadPortionRect()
{
LayoutUnit logicalHeight = 0;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
LayoutUnit regionLogicalHeight = region->logicalHeightOfAllFlowThreadContent();
LayoutRect regionRect(style()->direction() == LTR ? LayoutUnit() : logicalWidth() - regionLogicalWidth, logicalHeight, regionLogicalWidth, regionLogicalHeight);
// When a flow thread has more than one auto logical height region,
// we have to take into account the override logical content height value,
// if computed for an auto logical height region, and use it to set the height
// for the region rect. This way, the regions in the chain following the auto
// logical height region, will be able to fragment the right part of their
// associated flow thread content (and compute their overrideComputedLogicalHeight properly).
if (view()->normalLayoutPhase()) {
ASSERT(region->hasOverrideHeight() || !region->hasAutoLogicalHeight());
if (region->hasOverrideHeight())
regionLogicalHeight = region->overrideLogicalContentHeight();
regionRect.setHeight(regionLogicalHeight);
}
region->setFlowThreadPortionRect(isHorizontalWritingMode() ? regionRect : regionRect.transposedRect());
logicalHeight += regionLogicalHeight;
}
}
RenderRegion* RenderFlowThread::regionAtBlockOffset(LayoutUnit offset, bool extendLastRegion) const
{
ASSERT(!m_regionsInvalidated);
// If no region matches the position and extendLastRegion is true, it will return
// the last valid region. It is similar to auto extending the size of the last region.
RenderRegion* lastValidRegion = 0;
LayoutUnit accumulatedLogicalHeight = 0;
// FIXME: The regions are always in order, optimize this search.
for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (offset <= 0)
return region;
if (extendLastRegion || region->isRenderRegionSet())
lastValidRegion = region;
if (region->hasOverrideHeight() && view()->normalLayoutPhase()) {
accumulatedLogicalHeight += region->overrideLogicalContentHeight();
if (offset < accumulatedLogicalHeight)
return region;
continue;
}
LayoutRect regionRect = region->flowThreadPortionRect();
accumulatedLogicalHeight += isHorizontalWritingMode() ? regionRect.height() : regionRect.width();
if (offset < accumulatedLogicalHeight)
return region;
}
return lastValidRegion;
}
// 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;
}
