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(); }