blob: 28dfeb31264c20a846d72c935f30f41f99205cc2 [file] [log] [blame]
/*
* Copyright (C) 2012 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "RenderMultiColumnSet.h"
#include "FrameView.h"
#include "HitTestResult.h"
#include "PaintInfo.h"
#include "RenderBoxFragmentInfo.h"
#include "RenderLayer.h"
#include "RenderMultiColumnFlow.h"
#include "RenderMultiColumnSpannerPlaceholder.h"
#include "RenderView.h"
#include <wtf/IsoMallocInlines.h>
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(RenderMultiColumnSet);
RenderMultiColumnSet::RenderMultiColumnSet(RenderFragmentedFlow& fragmentedFlow, RenderStyle&& style)
: RenderFragmentContainerSet(fragmentedFlow.document(), WTFMove(style), fragmentedFlow)
, m_computedColumnCount(1)
, m_computedColumnWidth(0)
, m_computedColumnHeight(0)
, m_availableColumnHeight(0)
, m_columnHeightComputed(false)
, m_maxColumnHeight(RenderFragmentedFlow::maxLogicalHeight())
, m_minSpaceShortage(RenderFragmentedFlow::maxLogicalHeight())
, m_minimumColumnHeight(0)
{
}
RenderMultiColumnSet* RenderMultiColumnSet::nextSiblingMultiColumnSet() const
{
for (RenderObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
if (is<RenderMultiColumnSet>(*sibling))
return downcast<RenderMultiColumnSet>(sibling);
}
return nullptr;
}
RenderMultiColumnSet* RenderMultiColumnSet::previousSiblingMultiColumnSet() const
{
for (RenderObject* sibling = previousSibling(); sibling; sibling = sibling->previousSibling()) {
if (is<RenderMultiColumnSet>(*sibling))
return downcast<RenderMultiColumnSet>(sibling);
}
return nullptr;
}
RenderObject* RenderMultiColumnSet::firstRendererInFragmentedFlow() const
{
if (RenderBox* sibling = RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(this)) {
// Adjacent sets should not occur. Currently we would have no way of figuring out what each
// of them contains then.
ASSERT(!sibling->isRenderMultiColumnSet());
if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlow()->findColumnSpannerPlaceholder(sibling))
return placeholder->nextInPreOrderAfterChildren();
ASSERT_NOT_REACHED();
}
return fragmentedFlow()->firstChild();
}
RenderObject* RenderMultiColumnSet::lastRendererInFragmentedFlow() const
{
if (RenderBox* sibling = RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(this)) {
// Adjacent sets should not occur. Currently we would have no way of figuring out what each
// of them contains then.
ASSERT(!sibling->isRenderMultiColumnSet());
if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlow()->findColumnSpannerPlaceholder(sibling))
return placeholder->previousInPreOrder();
ASSERT_NOT_REACHED();
}
return fragmentedFlow()->lastLeafChild();
}
static bool precedesRenderer(const RenderObject* renderer, const RenderObject* boundary)
{
for (; renderer; renderer = renderer->nextInPreOrder()) {
if (renderer == boundary)
return true;
}
return false;
}
bool RenderMultiColumnSet::containsRendererInFragmentedFlow(const RenderObject& renderer) const
{
if (!previousSiblingMultiColumnSet() && !nextSiblingMultiColumnSet()) {
// There is only one set. This is easy, then.
return renderer.isDescendantOf(m_fragmentedFlow);
}
RenderObject* firstRenderer = firstRendererInFragmentedFlow();
RenderObject* lastRenderer = lastRendererInFragmentedFlow();
ASSERT(firstRenderer);
ASSERT(lastRenderer);
// This is SLOW! But luckily very uncommon.
return precedesRenderer(firstRenderer, &renderer) && precedesRenderer(&renderer, lastRenderer);
}
void RenderMultiColumnSet::setLogicalTopInFragmentedFlow(LayoutUnit logicalTop)
{
LayoutRect rect = fragmentedFlowPortionRect();
if (isHorizontalWritingMode())
rect.setY(logicalTop);
else
rect.setX(logicalTop);
setFragmentedFlowPortionRect(rect);
}
void RenderMultiColumnSet::setLogicalBottomInFragmentedFlow(LayoutUnit logicalBottom)
{
LayoutRect rect = fragmentedFlowPortionRect();
if (isHorizontalWritingMode())
rect.shiftMaxYEdgeTo(logicalBottom);
else
rect.shiftMaxXEdgeTo(logicalBottom);
setFragmentedFlowPortionRect(rect);
}
LayoutUnit RenderMultiColumnSet::heightAdjustedForSetOffset(LayoutUnit height) const
{
RenderBlockFlow& multicolBlock = downcast<RenderBlockFlow>(*parent());
LayoutUnit contentLogicalTop = logicalTop() - multicolBlock.borderAndPaddingBefore();
height -= contentLogicalTop;
return std::max(height, 1_lu); // Let's avoid zero height, as that would probably cause an infinite amount of columns to be created.
}
LayoutUnit RenderMultiColumnSet::pageLogicalTopForOffset(LayoutUnit offset) const
{
unsigned columnIndex = columnIndexAtOffset(offset, AssumeNewColumns);
return logicalTopInFragmentedFlow() + columnIndex * computedColumnHeight();
}
void RenderMultiColumnSet::setAndConstrainColumnHeight(LayoutUnit newHeight)
{
m_computedColumnHeight = newHeight;
if (m_computedColumnHeight > m_maxColumnHeight)
m_computedColumnHeight = m_maxColumnHeight;
// FIXME: The available column height is not the same as the constrained height specified
// by the pagination API. The column set in this case is allowed to be bigger than the
// height of a single column. We cache available column height in order to use it
// in computeLogicalHeight later. This is pretty gross, and maybe there's a better way
// to formalize the idea of clamped column heights without having a view dependency
// here.
m_availableColumnHeight = m_computedColumnHeight;
if (multiColumnFlow() && !multiColumnFlow()->progressionIsInline() && parent()->isRenderView()) {
int pageLength = view().frameView().pagination().pageLength;
if (pageLength)
m_computedColumnHeight = pageLength;
}
m_columnHeightComputed = true;
// FIXME: the height may also be affected by the enclosing pagination context, if any.
}
unsigned RenderMultiColumnSet::findRunWithTallestColumns() const
{
unsigned indexWithLargestHeight = 0;
LayoutUnit largestHeight;
LayoutUnit previousOffset;
size_t runCount = m_contentRuns.size();
ASSERT(runCount);
for (size_t i = 0; i < runCount; i++) {
const ContentRun& run = m_contentRuns[i];
LayoutUnit height = run.columnLogicalHeight(previousOffset);
if (largestHeight < height) {
largestHeight = height;
indexWithLargestHeight = i;
}
previousOffset = run.breakOffset();
}
return indexWithLargestHeight;
}
void RenderMultiColumnSet::distributeImplicitBreaks()
{
#ifndef NDEBUG
// There should be no implicit breaks assumed at this point.
for (unsigned i = 0; i < forcedBreaksCount(); i++)
ASSERT(!m_contentRuns[i].assumedImplicitBreaks());
#endif // NDEBUG
// Insert a final content run to encompass all content. This will include overflow if this is
// the last set.
addForcedBreak(logicalBottomInFragmentedFlow());
unsigned breakCount = forcedBreaksCount();
// If there is room for more breaks (to reach the used value of column-count), imagine that we
// insert implicit breaks at suitable locations. At any given time, the content run with the
// currently tallest columns will get another implicit break "inserted", which will increase its
// column count by one and shrink its columns' height. Repeat until we have the desired total
// number of breaks. The largest column height among the runs will then be the initial column
// height for the balancer to use.
while (breakCount < m_computedColumnCount) {
unsigned index = findRunWithTallestColumns();
m_contentRuns[index].assumeAnotherImplicitBreak();
breakCount++;
}
}
LayoutUnit RenderMultiColumnSet::calculateBalancedHeight(bool initial) const
{
if (initial) {
// Start with the lowest imaginable column height.
unsigned index = findRunWithTallestColumns();
LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : logicalTopInFragmentedFlow();
return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);
}
if (columnCount() <= computedColumnCount()) {
// With the current column height, the content fits without creating overflowing columns. We're done.
return m_computedColumnHeight;
}
if (forcedBreaksCount() >= computedColumnCount()) {
// Too many forced breaks to allow any implicit breaks. Initial balancing should already
// have set a good height. There's nothing more we should do.
return m_computedColumnHeight;
}
// If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest
// amount of space shortage found during layout.
ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!
// ASSERT(m_minSpaceShortage != RenderFragmentedFlow::maxLogicalHeight()); // If this happens, we probably have a bug.
if (m_minSpaceShortage == RenderFragmentedFlow::maxLogicalHeight())
return m_computedColumnHeight; // So bail out rather than looping infinitely.
return m_computedColumnHeight + m_minSpaceShortage;
}
void RenderMultiColumnSet::clearForcedBreaks()
{
m_contentRuns.clear();
}
void RenderMultiColumnSet::addForcedBreak(LayoutUnit offsetFromFirstPage)
{
if (!requiresBalancing())
return;
if (!m_contentRuns.isEmpty() && offsetFromFirstPage <= m_contentRuns.last().breakOffset())
return;
// Append another item as long as we haven't exceeded used column count. What ends up in the
// overflow area shouldn't affect column balancing.
if (m_contentRuns.size() < m_computedColumnCount)
m_contentRuns.append(ContentRun(offsetFromFirstPage));
}
bool RenderMultiColumnSet::recalculateColumnHeight(bool initial)
{
LayoutUnit oldColumnHeight = m_computedColumnHeight;
if (requiresBalancing()) {
if (initial)
distributeImplicitBreaks();
LayoutUnit newColumnHeight = calculateBalancedHeight(initial);
setAndConstrainColumnHeight(newColumnHeight);
// After having calculated an initial column height, the multicol container typically needs at
// least one more layout pass with a new column height, but if a height was specified, we only
// need to do this if we think that we need less space than specified. Conversely, if we
// determined that the columns need to be as tall as the specified height of the container, we
// have already laid it out correctly, and there's no need for another pass.
} else {
// The position of the column set may have changed, in which case height available for
// columns may have changed as well.
setAndConstrainColumnHeight(m_computedColumnHeight);
}
if (m_computedColumnHeight == oldColumnHeight)
return false; // No change. We're done.
m_minSpaceShortage = RenderFragmentedFlow::maxLogicalHeight();
return true; // Need another pass.
}
void RenderMultiColumnSet::recordSpaceShortage(LayoutUnit spaceShortage)
{
if (spaceShortage >= m_minSpaceShortage)
return;
// The space shortage is what we use as our stretch amount. We need a positive number here in
// order to get anywhere. Some lines actually have zero height. Ignore them.
if (spaceShortage > 0)
m_minSpaceShortage = spaceShortage;
}
void RenderMultiColumnSet::updateLogicalWidth()
{
setComputedColumnWidthAndCount(multiColumnFlow()->columnWidth(), multiColumnFlow()->columnCount()); // FIXME: This will eventually vary if we are contained inside fragments.
// FIXME: When we add fragments support, we'll start it off at the width of the multi-column
// block in that particular fragment.
setLogicalWidth(multiColumnBlockFlow()->contentLogicalWidth());
}
bool RenderMultiColumnSet::requiresBalancing() const
{
if (!multiColumnFlow()->progressionIsInline())
return false;
if (RenderBox* next = RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(this)) {
if (!next->isRenderMultiColumnSet() && !next->isLegend()) {
// If we're followed by a spanner, we need to balance.
ASSERT(multiColumnFlow()->findColumnSpannerPlaceholder(next));
return true;
}
}
RenderBlockFlow* container = multiColumnBlockFlow();
if (container->style().columnFill() == ColumnFill::Balance)
return true;
return !multiColumnFlow()->columnHeightAvailable();
}
void RenderMultiColumnSet::prepareForLayout(bool initial)
{
// Guess box logical top. This might eliminate the need for another layout pass.
if (RenderBox* previous = RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(this))
setLogicalTop(previous->logicalBottom() + previous->marginAfter());
else
setLogicalTop(multiColumnBlockFlow()->borderAndPaddingBefore());
if (initial)
m_maxColumnHeight = calculateMaxColumnHeight();
if (requiresBalancing()) {
if (initial) {
m_computedColumnHeight = 0;
m_availableColumnHeight = 0;
m_columnHeightComputed = false;
}
} else
setAndConstrainColumnHeight(heightAdjustedForSetOffset(multiColumnFlow()->columnHeightAvailable()));
// Set box width.
updateLogicalWidth();
// Any breaks will be re-inserted during layout, so get rid of what we already have.
clearForcedBreaks();
// Nuke previously stored minimum column height. Contents may have changed for all we know.
m_minimumColumnHeight = 0;
// Start with "infinite" flow thread portion height until height is known.
setLogicalBottomInFragmentedFlow(RenderFragmentedFlow::maxLogicalHeight());
setNeedsLayout(MarkOnlyThis);
}
void RenderMultiColumnSet::beginFlow(RenderBlock* container)
{
RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
// At this point layout is exactly at the beginning of this set. Store block offset from flow
// thread start.
LayoutUnit logicalTopInFragmentedFlow = fragmentedFlow->offsetFromLogicalTopOfFirstFragment(container) + container->logicalHeight();
setLogicalTopInFragmentedFlow(logicalTopInFragmentedFlow);
}
void RenderMultiColumnSet::endFlow(RenderBlock* container, LayoutUnit bottomInContainer)
{
RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
// At this point layout is exactly at the end of this set. Store block offset from flow thread
// start. Also note that a new column height may have affected the height used in the flow
// thread (because of struts), which may affect the number of columns. So we also need to update
// the flow thread portion height in order to be able to calculate actual column-count.
LayoutUnit logicalBottomInFragmentedFlow = fragmentedFlow->offsetFromLogicalTopOfFirstFragment(container) + bottomInContainer;
setLogicalBottomInFragmentedFlow(logicalBottomInFragmentedFlow);
container->setLogicalHeight(bottomInContainer);
}
void RenderMultiColumnSet::layout()
{
RenderBlockFlow::layout();
// At this point the logical top and bottom of the column set are known. Update maximum column
// height (multicol height may be constrained).
m_maxColumnHeight = calculateMaxColumnHeight();
if (!nextSiblingMultiColumnSet()) {
// This is the last set, i.e. the last fragment. Seize the opportunity to validate them.
multiColumnFlow()->validateFragments();
}
}
RenderBox::LogicalExtentComputedValues RenderMultiColumnSet::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop) const
{
return { m_availableColumnHeight, logicalTop, ComputedMarginValues() };
}
LayoutUnit RenderMultiColumnSet::calculateMaxColumnHeight() const
{
RenderBlockFlow* multicolBlock = multiColumnBlockFlow();
const RenderStyle& multicolStyle = multicolBlock->style();
LayoutUnit availableHeight = multiColumnFlow()->columnHeightAvailable();
LayoutUnit maxColumnHeight = availableHeight ? availableHeight : RenderFragmentedFlow::maxLogicalHeight();
if (!multicolStyle.logicalMaxHeight().isUndefined())
maxColumnHeight = std::min(maxColumnHeight, multicolBlock->computeContentLogicalHeight(MaxSize, multicolStyle.logicalMaxHeight(), WTF::nullopt).valueOr(maxColumnHeight));
return heightAdjustedForSetOffset(maxColumnHeight);
}
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.
RenderBlockFlow& parentBlock = downcast<RenderBlockFlow>(*parent());
if (parentBlock.style().columnGap().isNormal())
return parentBlock.style().fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
return valueForLength(parentBlock.style().columnGap().length(), parentBlock.availableLogicalWidth());
}
unsigned RenderMultiColumnSet::columnCount() const
{
// We must always return a value of 1 or greater. Column count = 0 is a meaningless situation,
// and will confuse and cause problems in other parts of the code.
if (!computedColumnHeight())
return 1;
// Our portion rect determines our column count. We have as many columns as needed to fit all the content.
LayoutUnit logicalHeightInColumns = fragmentedFlow()->isHorizontalWritingMode() ? fragmentedFlowPortionRect().height() : fragmentedFlowPortionRect().width();
if (!logicalHeightInColumns)
return 1;
unsigned count = ceil(static_cast<float>(logicalHeightInColumns) / computedColumnHeight());
ASSERT(count >= 1);
return count;
}
LayoutUnit RenderMultiColumnSet::columnLogicalLeft(unsigned index) const
{
LayoutUnit colLogicalWidth = computedColumnWidth();
LayoutUnit colLogicalLeft = borderAndPaddingLogicalLeft();
LayoutUnit colGap = columnGap();
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool progressionInline = multiColumnFlow()->progressionIsInline();
if (progressionInline) {
if (style().isLeftToRightDirection() ^ progressionReversed)
colLogicalLeft += index * (colLogicalWidth + colGap);
else
colLogicalLeft += contentLogicalWidth() - colLogicalWidth - index * (colLogicalWidth + colGap);
}
return colLogicalLeft;
}
LayoutUnit RenderMultiColumnSet::columnLogicalTop(unsigned index) const
{
LayoutUnit colLogicalHeight = computedColumnHeight();
LayoutUnit colLogicalTop = borderAndPaddingBefore();
LayoutUnit colGap = columnGap();
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool progressionInline = multiColumnFlow()->progressionIsInline();
if (!progressionInline) {
if (!progressionReversed)
colLogicalTop += index * (colLogicalHeight + colGap);
else
colLogicalTop += contentLogicalHeight() - colLogicalHeight - index * (colLogicalHeight + colGap);
}
return colLogicalTop;
}
LayoutRect RenderMultiColumnSet::columnRectAt(unsigned index) const
{
LayoutUnit colLogicalWidth = computedColumnWidth();
LayoutUnit colLogicalHeight = computedColumnHeight();
if (isHorizontalWritingMode())
return LayoutRect(columnLogicalLeft(index), columnLogicalTop(index), colLogicalWidth, colLogicalHeight);
return LayoutRect(columnLogicalTop(index), columnLogicalLeft(index), colLogicalHeight, colLogicalWidth);
}
unsigned RenderMultiColumnSet::columnIndexAtOffset(LayoutUnit offset, ColumnIndexCalculationMode mode) const
{
LayoutRect portionRect(fragmentedFlowPortionRect());
// Handle the offset being out of range.
LayoutUnit fragmentedFlowLogicalTop = isHorizontalWritingMode() ? portionRect.y() : portionRect.x();
if (offset < fragmentedFlowLogicalTop)
return 0;
// If we're laying out right now, we cannot constrain against some logical bottom, since it
// isn't known yet. Otherwise, just return the last column if we're past the logical bottom.
if (mode == ClampToExistingColumns) {
LayoutUnit fragmentedFlowLogicalBottom = isHorizontalWritingMode() ? portionRect.maxY() : portionRect.maxX();
if (offset >= fragmentedFlowLogicalBottom)
return columnCount() - 1;
}
// Sometimes computedColumnHeight() is 0 here: see https://bugs.webkit.org/show_bug.cgi?id=132884
if (!computedColumnHeight())
return 0;
// Just divide by the column height to determine the correct column.
return static_cast<float>(offset - fragmentedFlowLogicalTop) / computedColumnHeight();
}
LayoutRect RenderMultiColumnSet::fragmentedFlowPortionRectAt(unsigned index) const
{
LayoutRect portionRect = fragmentedFlowPortionRect();
if (isHorizontalWritingMode())
portionRect = LayoutRect(portionRect.x(), portionRect.y() + index * computedColumnHeight(), portionRect.width(), computedColumnHeight());
else
portionRect = LayoutRect(portionRect.x() + index * computedColumnHeight(), portionRect.y(), computedColumnHeight(), portionRect.height());
return portionRect;
}
LayoutRect RenderMultiColumnSet::fragmentedFlowPortionOverflowRect(const LayoutRect& portionRect, unsigned index, unsigned colCount, LayoutUnit colGap)
{
// This function determines the portion of the flow thread that paints for the column. Along the inline axis, columns are
// unclipped at outside edges (i.e., the first and last column in the set), and they clip to half the column
// gap along interior edges.
//
// In the block direction, we will not clip overflow out of the top of the first column, or out of the bottom of
// the last column. This applies only to the true first column and last column across all column sets.
//
// FIXME: Eventually we will know overflow on a per-column basis, but we can't do this until we have a painting
// mode that understands not to paint contents from a previous column in the overflow area of a following column.
// This problem applies to fragments and pages as well and is not unique to columns.
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool isFirstColumn = !index;
bool isLastColumn = index == colCount - 1;
bool isLeftmostColumn = style().isLeftToRightDirection() ^ progressionReversed ? isFirstColumn : isLastColumn;
bool isRightmostColumn = style().isLeftToRightDirection() ^ progressionReversed ? isLastColumn : isFirstColumn;
// Calculate the overflow rectangle, based on the flow thread's, clipped at column logical
// top/bottom unless it's the first/last column.
LayoutRect overflowRect = overflowRectForFragmentedFlowPortion(portionRect, isFirstColumn && isFirstFragment(), isLastColumn && isLastFragment(), VisualOverflow);
// For RenderViews only (i.e., iBooks), avoid overflowing into neighboring columns, by clipping in the middle of adjacent column gaps. Also make sure that we avoid rounding errors.
if (&view() == parent()) {
if (isHorizontalWritingMode()) {
if (!isLeftmostColumn)
overflowRect.shiftXEdgeTo(portionRect.x() - colGap / 2);
if (!isRightmostColumn)
overflowRect.shiftMaxXEdgeTo(portionRect.maxX() + colGap - colGap / 2);
} else {
if (!isLeftmostColumn)
overflowRect.shiftYEdgeTo(portionRect.y() - colGap / 2);
if (!isRightmostColumn)
overflowRect.shiftMaxYEdgeTo(portionRect.maxY() + colGap - colGap / 2);
}
}
return overflowRect;
}
void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (paintInfo.context().paintingDisabled())
return;
RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
const RenderStyle& blockStyle = parent()->style();
const Color& ruleColor = blockStyle.visitedDependentColorWithColorFilter(CSSPropertyColumnRuleColor);
bool ruleTransparent = blockStyle.columnRuleIsTransparent();
BorderStyle ruleStyle = collapsedBorderStyle(blockStyle.columnRuleStyle());
LayoutUnit ruleThickness = blockStyle.columnRuleWidth();
LayoutUnit colGap = columnGap();
bool renderRule = ruleStyle > BorderStyle::Hidden && !ruleTransparent;
if (!renderRule)
return;
unsigned colCount = columnCount();
if (colCount <= 1)
return;
bool antialias = shouldAntialiasLines(paintInfo.context());
if (fragmentedFlow->progressionIsInline()) {
bool leftToRight = style().isLeftToRightDirection() ^ fragmentedFlow->progressionIsReversed();
LayoutUnit currLogicalLeftOffset = leftToRight ? 0_lu : contentLogicalWidth();
LayoutUnit ruleAdd = logicalLeftOffsetForContent();
LayoutUnit ruleLogicalLeft = leftToRight ? 0_lu : contentLogicalWidth();
LayoutUnit inlineDirectionSize = computedColumnWidth();
BoxSide boxSide = isHorizontalWritingMode()
? leftToRight ? BSLeft : BSRight
: leftToRight ? BSTop : BSBottom;
for (unsigned i = 0; i < colCount; i++) {
// Move to the next position.
if (leftToRight) {
ruleLogicalLeft += inlineDirectionSize + colGap / 2;
currLogicalLeftOffset += inlineDirectionSize + colGap;
} else {
ruleLogicalLeft -= (inlineDirectionSize + colGap / 2);
currLogicalLeftOffset -= (inlineDirectionSize + colGap);
}
// Now paint the column rule.
if (i < colCount - 1) {
LayoutUnit ruleLeft = isHorizontalWritingMode() ? paintOffset.x() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd : paintOffset.x() + borderLeft() + paddingLeft();
LayoutUnit ruleRight = isHorizontalWritingMode() ? ruleLeft + ruleThickness : ruleLeft + contentWidth();
LayoutUnit ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd;
LayoutUnit ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleThickness;
IntRect pixelSnappedRuleRect = snappedIntRect(ruleLeft, ruleTop, ruleRight - ruleLeft, ruleBottom - ruleTop);
drawLineForBoxSide(paintInfo.context(), pixelSnappedRuleRect, boxSide, ruleColor, ruleStyle, 0, 0, antialias);
}
ruleLogicalLeft = currLogicalLeftOffset;
}
} else {
bool topToBottom = !style().isFlippedBlocksWritingMode() ^ fragmentedFlow->progressionIsReversed();
LayoutUnit ruleLeft = isHorizontalWritingMode() ? 0_lu : colGap / 2 - colGap - ruleThickness / 2;
LayoutUnit ruleWidth = isHorizontalWritingMode() ? contentWidth() : ruleThickness;
LayoutUnit ruleTop = isHorizontalWritingMode() ? colGap / 2 - colGap - ruleThickness / 2 : 0_lu;
LayoutUnit ruleHeight = isHorizontalWritingMode() ? ruleThickness : contentHeight();
LayoutRect ruleRect(ruleLeft, ruleTop, ruleWidth, ruleHeight);
if (!topToBottom) {
if (isHorizontalWritingMode())
ruleRect.setY(height() - ruleRect.maxY());
else
ruleRect.setX(width() - ruleRect.maxX());
}
ruleRect.moveBy(paintOffset);
BoxSide boxSide = isHorizontalWritingMode() ? topToBottom ? BSTop : BSBottom : topToBottom ? BSLeft : BSRight;
LayoutSize step(0_lu, topToBottom ? computedColumnHeight() + colGap : -(computedColumnHeight() + colGap));
if (!isHorizontalWritingMode())
step = step.transposedSize();
for (unsigned i = 1; i < colCount; i++) {
ruleRect.move(step);
IntRect pixelSnappedRuleRect = snappedIntRect(ruleRect);
drawLineForBoxSide(paintInfo.context(), pixelSnappedRuleRect, boxSide, ruleColor, ruleStyle, 0, 0, antialias);
}
}
}
void RenderMultiColumnSet::repaintFragmentedFlowContent(const LayoutRect& repaintRect)
{
// Figure out the start and end columns and only check within that range so that we don't walk the
// entire column set. Put the repaint rect into flow thread coordinates by flipping it first.
LayoutRect fragmentedFlowRepaintRect(repaintRect);
fragmentedFlow()->flipForWritingMode(fragmentedFlowRepaintRect);
// Now we can compare this rect with the flow thread portions owned by each column. First let's
// just see if the repaint rect intersects our flow thread portion at all.
LayoutRect clippedRect(fragmentedFlowRepaintRect);
clippedRect.intersect(RenderFragmentContainer::fragmentedFlowPortionOverflowRect());
if (clippedRect.isEmpty())
return;
// Now we know we intersect at least one column. Let's figure out the logical top and logical
// bottom of the area we're repainting.
LayoutUnit repaintLogicalTop = isHorizontalWritingMode() ? fragmentedFlowRepaintRect.y() : fragmentedFlowRepaintRect.x();
LayoutUnit repaintLogicalBottom = (isHorizontalWritingMode() ? fragmentedFlowRepaintRect.maxY() : fragmentedFlowRepaintRect.maxX()) - 1;
unsigned startColumn = columnIndexAtOffset(repaintLogicalTop);
unsigned endColumn = columnIndexAtOffset(repaintLogicalBottom);
LayoutUnit colGap = columnGap();
unsigned colCount = columnCount();
for (unsigned i = startColumn; i <= endColumn; i++) {
LayoutRect colRect = columnRectAt(i);
// Get the portion of the flow thread that corresponds to this column.
LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
// Now get the overflow rect that corresponds to the column.
LayoutRect fragmentedFlowOverflowPortion = fragmentedFlowPortionOverflowRect(fragmentedFlowPortion, i, colCount, colGap);
// Do a repaint for this specific column.
flipForWritingMode(colRect);
repaintFragmentedFlowContentRectangle(repaintRect, fragmentedFlowPortion, colRect.location(), &fragmentedFlowOverflowPortion);
}
}
LayoutUnit RenderMultiColumnSet::initialBlockOffsetForPainting() const
{
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool progressionIsInline = multiColumnFlow()->progressionIsInline();
LayoutUnit result;
if (!progressionIsInline && progressionReversed) {
LayoutRect colRect = columnRectAt(0);
result = isHorizontalWritingMode() ? colRect.y() : colRect.x();
}
return result;
}
void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
{
// Let's start by introducing the different coordinate systems involved here. They are different
// in how they deal with writing modes and columns. RenderLayer rectangles tend to be more
// physical than the rectangles used in RenderObject & co.
//
// The two rectangles passed to this method are physical, except that we pretend that there's
// only one long column (that's the flow thread). They are relative to the top left corner of
// the flow thread. All rectangles being compared to the dirty rect also need to be in this
// coordinate system.
//
// Then there's the output from this method - the stuff we put into the list of fragments. The
// translationOffset point is the actual physical translation required to get from a location in
// the flow thread to a location in some column. The paginationClip rectangle is in the same
// coordinate system as the two rectangles passed to this method (i.e. physical, in flow thread
// coordinates, pretending that there's only one long column).
//
// All other rectangles in this method are slightly less physical, when it comes to how they are
// used with different writing modes, but they aren't really logical either. They are just like
// RenderBox::frameRect(). More precisely, the sizes are physical, and the inline direction
// coordinate is too, but the block direction coordinate is always "logical top". These
// rectangles also pretend that there's only one long column, i.e. they are for the flow thread.
//
// To sum up: input and output from this method are "physical" RenderLayer-style rectangles and
// points, while inside this method we mostly use the RenderObject-style rectangles (with the
// block direction coordinate always being logical top).
// Put the layer bounds into flow thread-local coordinates by flipping it first. Since we're in
// a renderer, most rectangles are represented this way.
LayoutRect layerBoundsInFragmentedFlow(layerBoundingBox);
fragmentedFlow()->flipForWritingMode(layerBoundsInFragmentedFlow);
// Now we can compare with the flow thread portions owned by each column. First let's
// see if the rect intersects our flow thread portion at all.
LayoutRect clippedRect(layerBoundsInFragmentedFlow);
clippedRect.intersect(RenderFragmentContainer::fragmentedFlowPortionOverflowRect());
if (clippedRect.isEmpty())
return;
// Now we know we intersect at least one column. Let's figure out the logical top and logical
// bottom of the area we're checking.
LayoutUnit layerLogicalTop = isHorizontalWritingMode() ? layerBoundsInFragmentedFlow.y() : layerBoundsInFragmentedFlow.x();
LayoutUnit layerLogicalBottom = (isHorizontalWritingMode() ? layerBoundsInFragmentedFlow.maxY() : layerBoundsInFragmentedFlow.maxX()) - 1;
// Figure out the start and end columns and only check within that range so that we don't walk the
// entire column set.
unsigned startColumn = columnIndexAtOffset(layerLogicalTop);
unsigned endColumn = columnIndexAtOffset(layerLogicalBottom);
LayoutUnit colLogicalWidth = computedColumnWidth();
LayoutUnit colGap = columnGap();
unsigned colCount = columnCount();
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool progressionIsInline = multiColumnFlow()->progressionIsInline();
LayoutUnit initialBlockOffset = initialBlockOffsetForPainting();
for (unsigned i = startColumn; i <= endColumn; i++) {
// Get the portion of the flow thread that corresponds to this column.
LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
// Now get the overflow rect that corresponds to the column.
LayoutRect fragmentedFlowOverflowPortion = fragmentedFlowPortionOverflowRect(fragmentedFlowPortion, i, colCount, colGap);
// In order to create a fragment we must intersect the portion painted by this column.
LayoutRect clippedRect(layerBoundsInFragmentedFlow);
clippedRect.intersect(fragmentedFlowOverflowPortion);
if (clippedRect.isEmpty())
continue;
// We also need to intersect the dirty rect. We have to apply a translation and shift based off
// our column index.
LayoutSize translationOffset;
LayoutUnit inlineOffset = progressionIsInline ? i * (colLogicalWidth + colGap) : 0_lu;
bool leftToRight = style().isLeftToRightDirection() ^ progressionReversed;
if (!leftToRight) {
inlineOffset = -inlineOffset;
if (progressionReversed)
inlineOffset += contentLogicalWidth() - colLogicalWidth;
}
translationOffset.setWidth(inlineOffset);
LayoutUnit blockOffset = initialBlockOffset + logicalTop() - fragmentedFlow()->logicalTop() + (isHorizontalWritingMode() ? -fragmentedFlowPortion.y() : -fragmentedFlowPortion.x());
if (!progressionIsInline) {
if (!progressionReversed)
blockOffset = i * colGap;
else
blockOffset -= i * (computedColumnHeight() + colGap);
}
if (isFlippedWritingMode(style().writingMode()))
blockOffset = -blockOffset;
translationOffset.setHeight(blockOffset);
if (!isHorizontalWritingMode())
translationOffset = translationOffset.transposedSize();
// Shift the dirty rect to be in flow thread coordinates with this translation applied.
LayoutRect translatedDirtyRect(dirtyRect);
translatedDirtyRect.move(-translationOffset);
// See if we intersect the dirty rect.
clippedRect = layerBoundingBox;
clippedRect.intersect(translatedDirtyRect);
if (clippedRect.isEmpty())
continue;
// Something does need to paint in this column. Make a fragment now and supply the physical translation
// offset and the clip rect for the column with that offset applied.
LayerFragment fragment;
fragment.paginationOffset = translationOffset;
LayoutRect flippedFragmentedFlowOverflowPortion(fragmentedFlowOverflowPortion);
// Flip it into more a physical (RenderLayer-style) rectangle.
fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowOverflowPortion);
fragment.paginationClip = flippedFragmentedFlowOverflowPortion;
fragments.append(fragment);
}
}
LayoutPoint RenderMultiColumnSet::columnTranslationForOffset(const LayoutUnit& offset) const
{
unsigned startColumn = columnIndexAtOffset(offset);
LayoutUnit colGap = columnGap();
LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(startColumn);
LayoutPoint translationOffset;
bool progressionReversed = multiColumnFlow()->progressionIsReversed();
bool progressionIsInline = multiColumnFlow()->progressionIsInline();
LayoutUnit initialBlockOffset = initialBlockOffsetForPainting();
translationOffset.setX(columnLogicalLeft(startColumn));
LayoutUnit blockOffset = initialBlockOffset - (isHorizontalWritingMode() ? fragmentedFlowPortion.y() : fragmentedFlowPortion.x());
if (!progressionIsInline) {
if (!progressionReversed)
blockOffset = startColumn * colGap;
else
blockOffset -= startColumn * (computedColumnHeight() + colGap);
}
if (isFlippedWritingMode(style().writingMode()))
blockOffset = -blockOffset;
translationOffset.setY(blockOffset);
if (!isHorizontalWritingMode())
translationOffset = translationOffset.transposedPoint();
return translationOffset;
}
void RenderMultiColumnSet::adjustFragmentBoundsFromFragmentedFlowPortionRect(LayoutRect&) const
{
// This only fires for named flow thread compositing code, so let's make sure to ASSERT if this ever gets invoked.
ASSERT_NOT_REACHED();
}
void RenderMultiColumnSet::addOverflowFromChildren()
{
// FIXME: Need to do much better here.
unsigned colCount = columnCount();
if (!colCount)
return;
LayoutRect lastRect = columnRectAt(colCount - 1);
addLayoutOverflow(lastRect);
if (!hasOverflowClip())
addVisualOverflow(lastRect);
}
VisiblePosition RenderMultiColumnSet::positionForPoint(const LayoutPoint& logicalPoint, const RenderFragmentContainer*)
{
return multiColumnFlow()->positionForPoint(translateFragmentPointToFragmentedFlow(logicalPoint, ClampHitTestTranslationToColumns), this);
}
LayoutPoint RenderMultiColumnSet::translateFragmentPointToFragmentedFlow(const LayoutPoint & logicalPoint, ColumnHitTestTranslationMode clampMode) const
{
// Determine which columns we intersect.
LayoutUnit colGap = columnGap();
LayoutUnit halfColGap = colGap / 2;
bool progressionIsInline = multiColumnFlow()->progressionIsInline();
LayoutPoint point = logicalPoint;
for (unsigned i = 0; i < columnCount(); i++) {
// Add in half the column gap to the left and right of the rect.
LayoutRect colRect = columnRectAt(i);
if (isHorizontalWritingMode() == progressionIsInline) {
LayoutRect gapAndColumnRect(colRect.x() - halfColGap, colRect.y(), colRect.width() + colGap, colRect.height());
if (point.x() >= gapAndColumnRect.x() && point.x() < gapAndColumnRect.maxX()) {
if (clampMode == ClampHitTestTranslationToColumns) {
if (progressionIsInline) {
// FIXME: The clamping that follows is not completely right for right-to-left
// content.
// Clamp everything above the column to its top left.
if (point.y() < gapAndColumnRect.y())
point = gapAndColumnRect.location();
// Clamp everything below the column to the next column's top left. If there is
// no next column, this still maps to just after this column.
else if (point.y() >= gapAndColumnRect.maxY()) {
point = gapAndColumnRect.location();
point.move(0_lu, gapAndColumnRect.height());
}
} else {
if (point.x() < colRect.x())
point.setX(colRect.x());
else if (point.x() >= colRect.maxX())
point.setX(colRect.maxX() - 1);
}
}
LayoutSize offsetInColumn = point - colRect.location();
LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
return fragmentedFlowPortion.location() + offsetInColumn;
}
} else {
LayoutRect gapAndColumnRect(colRect.x(), colRect.y() - halfColGap, colRect.width(), colRect.height() + colGap);
if (point.y() >= gapAndColumnRect.y() && point.y() < gapAndColumnRect.maxY()) {
if (clampMode == ClampHitTestTranslationToColumns) {
if (progressionIsInline) {
// FIXME: The clamping that follows is not completely right for right-to-left
// content.
// Clamp everything above the column to its top left.
if (point.x() < gapAndColumnRect.x())
point = gapAndColumnRect.location();
// Clamp everything below the column to the next column's top left. If there is
// no next column, this still maps to just after this column.
else if (point.x() >= gapAndColumnRect.maxX()) {
point = gapAndColumnRect.location();
point.move(gapAndColumnRect.width(), 0_lu);
}
} else {
if (point.y() < colRect.y())
point.setY(colRect.y());
else if (point.y() >= colRect.maxY())
point.setY(colRect.maxY() - 1);
}
}
LayoutSize offsetInColumn = point - colRect.location();
LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
return fragmentedFlowPortion.location() + offsetInColumn;
}
}
}
return logicalPoint;
}
void RenderMultiColumnSet::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
{
if (result.innerNode() || !parent()->isRenderView())
return;
// Note this does not work with column spans, but once we implement RenderPageSet, we can move this code
// over there instead (and spans of course won't be allowed on pages).
Node* node = document().documentElement();
if (node) {
result.setInnerNode(node);
if (!result.innerNonSharedNode())
result.setInnerNonSharedNode(node);
LayoutPoint adjustedPoint = translateFragmentPointToFragmentedFlow(point);
view().offsetForContents(adjustedPoint);
result.setLocalPoint(adjustedPoint);
}
}
const char* RenderMultiColumnSet::renderName() const
{
return "RenderMultiColumnSet";
}
}