LayoutUnit RenderMultiColumnSet::heightAdjustedForSetOffset(LayoutUnit height) const
{
RenderMultiColumnBlock* multicolBlock = toRenderMultiColumnBlock(parent());
LayoutUnit contentLogicalTop = logicalTop() - multicolBlock->borderBefore() - multicolBlock->paddingBefore();
height -= contentLogicalTop;
return max(height, LayoutUnit(1)); // Let's avoid zero height, as that would probably cause an infinite amount of columns to be created.
}
void RenderMultiColumnSet::computeLogicalHeight()
{
// Make sure our column height is up to date.
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnHeight(parentBlock->columnHeight()); // FIXME: Once we make more than one column set, this will become variable.
// Our logical height is always just the height of our columns.
setLogicalHeight(computedColumnHeight());
}
LayoutUnit RenderMultiColumnSet::columnGap() const
{
// FIXME: Eventually we will cache the column gap when the widths of columns start varying, but for now we just
// go to the parent block to get the gap.
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
if (parentBlock->style()->hasNormalColumnGap())
return parentBlock->style()->fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
return parentBlock->style()->columnGap();
}
void RenderMultiColumnSet::computeLogicalWidth()
{
// Our logical width starts off matching the column block itself.
// This width will be fixed up after the flow thread lays out once it is determined exactly how many
// columns we ended up holding.
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnWidthAndCount(parentBlock->columnWidth(), parentBlock->columnCount()); // FIXME: This will eventually vary if we are contained inside regions.
}
void RenderMultiColumnSet::updateLogicalWidth()
{
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnWidthAndCount(parentBlock->columnWidth(), parentBlock->columnCount()); // FIXME: This will eventually vary if we are contained inside regions.
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
// If we overflow, increase our logical width.
unsigned colCount = columnCount();
LayoutUnit colGap = columnGap();
LayoutUnit minimumContentLogicalWidth = colCount * computedColumnWidth() + (colCount - 1) * colGap;
LayoutUnit currentContentLogicalWidth = contentLogicalWidth();
LayoutUnit delta = max(LayoutUnit(), minimumContentLogicalWidth - currentContentLogicalWidth);
if (!delta)
return;
// Increase our logical width by the delta.
setLogicalWidth(logicalWidth() + delta);
}
void RenderMultiColumnSet::prepareForLayout()
{
RenderMultiColumnBlock* multicolBlock = toRenderMultiColumnBlock(parent());
RenderStyle* multicolStyle = multicolBlock->style();
// Set box logical top.
ASSERT(!previousSiblingBox() || !previousSiblingBox()->isRenderMultiColumnSet()); // FIXME: multiple set not implemented; need to examine previous set to calculate the correct logical top.
setLogicalTop(multicolBlock->borderBefore() + multicolBlock->paddingBefore());
// Set box width.
updateLogicalWidth();
if (multicolBlock->requiresBalancing()) {
// Set maximum column height. We will not stretch beyond this.
m_maxColumnHeight = RenderFlowThread::maxLogicalHeight();
if (!multicolStyle->logicalHeight().isAuto()) {
m_maxColumnHeight = multicolBlock->computeContentLogicalHeight(multicolStyle->logicalHeight(), -1);
if (m_maxColumnHeight == -1)
m_maxColumnHeight = RenderFlowThread::maxLogicalHeight();
}
if (!multicolStyle->logicalMaxHeight().isUndefined()) {
LayoutUnit logicalMaxHeight = multicolBlock->computeContentLogicalHeight(multicolStyle->logicalMaxHeight(), -1);
if (logicalMaxHeight != -1 && m_maxColumnHeight > logicalMaxHeight)
m_maxColumnHeight = logicalMaxHeight;
}
m_maxColumnHeight = heightAdjustedForSetOffset(m_maxColumnHeight);
m_computedColumnHeight = 0; // Restart balancing.
} else {
setAndConstrainColumnHeight(heightAdjustedForSetOffset(multicolBlock->columnHeightAvailable()));
}
clearForcedBreaks();
// Nuke previously stored minimum column height. Contents may have changed for all we know.
m_minimumColumnHeight = 0;
}
void RenderMultiColumnFlowThread::autoGenerateRegionsToBlockOffset(LayoutUnit /*offset*/)
{
// This function ensures we have the correct column set information at all times.
// For a simple multi-column layout in continuous media, only one column set child is required.
// Once a column is nested inside an enclosing pagination context, the number of column sets
// required becomes 2n-1, where n is the total number of nested pagination contexts. For example:
//
// Column layout with no enclosing pagination model = 2 * 1 - 1 = 1 column set.
// Columns inside pages = 2 * 2 - 1 = 3 column sets (bottom of first page, all the subsequent pages, then the last page).
// Columns inside columns inside pages = 2 * 3 - 1 = 5 column sets.
//
// In addition, column spans will force a column set to "split" into before/after sets around the spanning element.
//
// Finally, we will need to deal with columns inside regions. If regions have variable widths, then there will need
// to be unique column sets created inside any region whose width is different from its surrounding regions. This is
// actually pretty similar to the spanning case, in that we break up the column sets whenever the width varies.
//
// FIXME: For now just make one column set. This matches the old multi-column code.
// Right now our goal is just feature parity with the old multi-column code so that we can switch over to the
// new code as soon as possible.
RenderMultiColumnSet* firstSet = toRenderMultiColumnSet(firstRegion());
if (firstSet)
return;
invalidateRegions();
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
firstSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(&parentBlock->style(), BLOCK));
firstSet->initializeStyle();
parentBlock->RenderBlock::addChild(firstSet);
// Even though we aren't placed yet, we can go ahead and set up our size. At this point we're
// typically in the middle of laying out the thread, attempting to paginate, and we need to do
// some rudimentary "layout" of the set now, so that pagination will work.
firstSet->prepareForLayout();
validateRegions();
}
void RenderMultiColumnSet::computeLogicalHeight(LayoutUnit, LayoutUnit, LogicalExtentComputedValues& computedValues) const
{
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
computedValues.m_extent = parentBlock->columnHeight();
}
LayoutUnit RenderMultiColumnFlowThread::initialLogicalWidth() const
{
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
return parentBlock->columnWidth();
}
