void RenderRegion::attachRegion()
{
if (documentBeingDestroyed())
return;
// A region starts off invalid.
setIsValid(false);
// Initialize the flow thread reference and create the flow thread object if needed.
// The flow thread lifetime is influenced by the number of regions attached to it,
// and we are attaching the region to the flow thread.
installFlowThread();
if (!m_flowThread)
return;
// Only after adding the region to the thread, the region is marked to be valid.
m_flowThread->addRegionToThread(this);
// The region just got attached to the flow thread, lets check whether
// it has region styling rules associated.
checkRegionStyle();
if (!isValid())
return;
m_hasAutoLogicalHeight = shouldHaveAutoLogicalHeight();
if (hasAutoLogicalHeight())
incrementAutoLogicalHeightCount();
}
void RenderNamedFlowFragment::updateLogicalHeight()
{
RenderRegion::updateLogicalHeight();
if (!hasAutoLogicalHeight())
return;
// We want to update the logical height based on the computed auto-height
// only after the measure cotnent layout phase when all the
// auto logical height regions have a computed auto-height.
if (m_flowThread->inMeasureContentLayoutPhase())
return;
// There may be regions with auto logical height that during the prerequisite layout phase
// did not have the chance to layout flow thread content. Because of that, these regions do not
// have a computedAutoHeight and they will not be able to fragment any flow
// thread content.
if (!hasComputedAutoHeight())
return;
LayoutUnit newLogicalHeight = computedAutoHeight() + borderAndPaddingLogicalHeight();
ASSERT(newLogicalHeight < RenderFlowThread::maxLogicalHeight());
if (newLogicalHeight > logicalHeight()) {
setLogicalHeight(newLogicalHeight);
// Recalculate position of the render block after new logical height is set.
// (needed in absolute positioning case with bottom alignment for example)
RenderRegion::updateLogicalHeight();
}
}
void RenderRegion::layoutBlock(bool relayoutChildren, LayoutUnit)
{
StackStats::LayoutCheckPoint layoutCheckPoint;
RenderBlock::layoutBlock(relayoutChildren);
if (isValid()) {
LayoutRect oldRegionRect(flowThreadPortionRect());
if (!isHorizontalWritingMode())
oldRegionRect = oldRegionRect.transposedRect();
if (hasAutoLogicalHeight() && !m_flowThread->inConstrainedLayoutPhase()) {
m_flowThread->invalidateRegions();
clearOverrideLogicalContentHeight();
return;
}
if (!isRenderRegionSet() && (oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()))
// This can happen even if we are in the inConstrainedLayoutPhase and it will trigger a pathological layout of the flow thread.
m_flowThread->invalidateRegions();
}
// FIXME: We need to find a way to set up overflow properly. Our flow thread hasn't gotten a layout
// yet, so we can't look to it for correct information. It's possible we could wait until after the RenderFlowThread
// gets a layout, and then try to propagate overflow information back to the region, and then mark for a second layout.
// That second layout would then be able to use the information from the RenderFlowThread to set up overflow.
//
// The big problem though is that overflow needs to be region-specific. We can't simply use the RenderFlowThread's global
// overflow values, since then we'd always think any narrow region had huge overflow (all the way to the width of the
// RenderFlowThread itself).
//
// We'll need to expand RenderBoxRegionInfo to also hold left and right overflow values.
}
void RenderNamedFlowFragment::detachRegion()
{
if (m_flowThread && hasAutoLogicalHeight())
decrementAutoLogicalHeightCount();
RenderRegion::detachRegion();
}
void RenderRegion::updateLogicalHeight()
{
RenderBlock::updateLogicalHeight();
if (!hasAutoLogicalHeight())
return;
// We want to update the logical height based on the computed override logical
// content height only if the view is in the layout phase
// in which all the auto logical height regions have their override logical height set.
if (!m_flowThread->inConstrainedLayoutPhase())
return;
// There may be regions with auto logical height that during the prerequisite layout phase
// did not have the chance to layout flow thread content. Because of that, these regions do not
// have an overrideLogicalContentHeight computed and they will not be able to fragment any flow
// thread content.
if (!hasOverrideHeight())
return;
LayoutUnit newLogicalHeight = overrideLogicalContentHeight() + borderAndPaddingLogicalHeight();
ASSERT(newLogicalHeight < LayoutUnit::max() / 2);
if (newLogicalHeight > logicalHeight())
setLogicalHeight(newLogicalHeight);
}
void RenderNamedFlowFragment::layoutBlock(bool relayoutChildren, LayoutUnit)
{
StackStats::LayoutCheckPoint layoutCheckPoint;
RenderRegion::layoutBlock(relayoutChildren);
if (isValid()) {
LayoutRect oldRegionRect(flowThreadPortionRect());
if (!isHorizontalWritingMode())
oldRegionRect = oldRegionRect.transposedRect();
if (m_flowThread->inOverflowLayoutPhase() || m_flowThread->inFinalLayoutPhase()) {
computeOverflowFromFlowThread();
updateOversetState();
}
if (hasAutoLogicalHeight() && m_flowThread->inMeasureContentLayoutPhase()) {
m_flowThread->invalidateRegions();
clearComputedAutoHeight();
return;
}
if ((oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()) && !m_flowThread->inFinalLayoutPhase())
// This can happen even if we are in the inConstrainedLayoutPhase and it will trigger a pathological layout of the flow thread.
m_flowThread->invalidateRegions();
}
}
LayoutUnit RenderRegion::pageLogicalHeight() const
{
ASSERT(m_flowThread);
if (hasComputedAutoHeight() && !m_flowThread->inConstrainedLayoutPhase()) {
ASSERT(hasAutoLogicalHeight());
return computedAutoHeight();
}
return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
}
LayoutUnit RenderRegion::logicalHeightOfAllFlowThreadContent() const
{
ASSERT(m_flowThread);
if (hasComputedAutoHeight() && m_flowThread->inMeasureContentLayoutPhase()) {
ASSERT(hasAutoLogicalHeight());
return computedAutoHeight();
}
return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
}
void RenderRegion::detachRegion()
{
if (m_flowThread) {
m_flowThread->removeRegionFromThread(this);
if (hasAutoLogicalHeight())
decrementAutoLogicalHeightCount();
}
m_flowThread = 0;
}
LayoutUnit RenderNamedFlowFragment::pageLogicalHeight() const
{
ASSERT(isValid());
if (hasComputedAutoHeight() && m_flowThread->inMeasureContentLayoutPhase()) {
ASSERT(hasAutoLogicalHeight());
return computedAutoHeight();
}
return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
}
LayoutUnit RenderRegion::logicalHeightOfAllFlowThreadContent() const
{
ASSERT(m_flowThread);
if (hasOverrideHeight() && !m_flowThread->inConstrainedLayoutPhase()) {
ASSERT(hasAutoLogicalHeight());
return overrideLogicalContentHeight();
}
return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
}
// This method returns the maximum page size of a region with auto-height. This is the initial
// height value for auto-height regions in the first layout phase of the parent named flow.
LayoutUnit RenderNamedFlowFragment::maxPageLogicalHeight() const
{
ASSERT(isValid());
ASSERT(hasAutoLogicalHeight() && m_flowThread->inMeasureContentLayoutPhase());
ASSERT(isAnonymous());
ASSERT(parent());
const RenderStyle& styleToUse = parent()->style();
return styleToUse.logicalMaxHeight().isUndefined() ? RenderFlowThread::maxLogicalHeight() : downcast<RenderBlock>(*parent()).computeReplacedLogicalHeightUsing(MaxSize, styleToUse.logicalMaxHeight());
}
void RenderNamedFlowFragment::detachRegion()
{
if (hasAutoLogicalHeight()) {
ASSERT(isValid());
m_hasAutoLogicalHeight = false;
clearComputedAutoHeight();
decrementAutoLogicalHeightCount();
}
RenderRegion::detachRegion();
}
void RenderNamedFlowFragment::layoutBlock(bool relayoutChildren, LayoutUnit)
{
StackStats::LayoutCheckPoint layoutCheckPoint;
RenderRegion::layoutBlock(relayoutChildren);
if (isValid()) {
if (m_flowThread->inOverflowLayoutPhase() || m_flowThread->inFinalLayoutPhase()) {
computeOverflowFromFlowThread();
updateOversetState();
}
if (hasAutoLogicalHeight() && m_flowThread->inMeasureContentLayoutPhase()) {
m_flowThread->invalidateRegions();
clearComputedAutoHeight();
return;
}
}
}
void RenderNamedFlowFragment::attachRegion()
{
RenderRegion::attachRegion();
if (documentBeingDestroyed() || !m_flowThread)
return;
// The region just got attached to the flow thread, lets check whether
// it has region styling rules associated.
checkRegionStyle();
if (!isValid())
return;
m_hasAutoLogicalHeight = shouldHaveAutoLogicalHeight();
if (hasAutoLogicalHeight())
incrementAutoLogicalHeightCount();
}
// This method returns the maximum page size of a region with auto-height. This is the initial
// height value for auto-height regions in the first layout phase of the parent named flow.
LayoutUnit RenderRegion::maxPageLogicalHeight() const
{
ASSERT(m_flowThread);
ASSERT(hasAutoLogicalHeight() && m_flowThread->inMeasureContentLayoutPhase());
return style()->logicalMaxHeight().isUndefined() ? RenderFlowThread::maxLogicalHeight() : computeReplacedLogicalHeightUsing(style()->logicalMaxHeight());
}
// This method returns the maximum page size of a region with auto-height. This is the initial
// height value for auto-height regions in the first layout phase of the parent named flow.
LayoutUnit RenderRegion::maxPageLogicalHeight() const
{
ASSERT(m_flowThread);
ASSERT(hasAutoLogicalHeight() && !m_flowThread->inConstrainedLayoutPhase());
return style()->logicalMaxHeight().isUndefined() ? LayoutUnit::max() / 2 : computeReplacedLogicalHeightUsing(style()->logicalMaxHeight());
}
