RenderFlexibleBox.cpp [plain text]
#include "config.h"
#include "RenderFlexibleBox.h"
#include "FlexibleBoxAlgorithm.h"
#include "LayoutRepainter.h"
#include "RenderChildIterator.h"
#include "RenderLayer.h"
#include "RenderLayoutState.h"
#include "RenderView.h"
#include <limits>
#include <wtf/IsoMallocInlines.h>
#include <wtf/MathExtras.h>
#include <wtf/SetForScope.h>
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(RenderFlexibleBox);
struct RenderFlexibleBox::LineContext {
LineContext(LayoutUnit crossAxisOffset, LayoutUnit crossAxisExtent, LayoutUnit maxAscent, Vector<FlexItem>&& flexItems)
: crossAxisOffset(crossAxisOffset)
, crossAxisExtent(crossAxisExtent)
, maxAscent(maxAscent)
, flexItems(flexItems)
{
}
LayoutUnit crossAxisOffset;
LayoutUnit crossAxisExtent;
LayoutUnit maxAscent;
Vector<FlexItem> flexItems;
};
RenderFlexibleBox::RenderFlexibleBox(Element& element, RenderStyle&& style)
: RenderBlock(element, WTFMove(style), 0)
{
setChildrenInline(false); }
RenderFlexibleBox::RenderFlexibleBox(Document& document, RenderStyle&& style)
: RenderBlock(document, WTFMove(style), 0)
{
setChildrenInline(false); }
RenderFlexibleBox::~RenderFlexibleBox() = default;
const char* RenderFlexibleBox::renderName() const
{
return "RenderFlexibleBox";
}
void RenderFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
{
LayoutUnit childMinWidth;
LayoutUnit childMaxWidth;
bool hadExcludedChildren = computePreferredWidthsForExcludedChildren(childMinWidth, childMaxWidth);
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
if (child->isOutOfFlowPositioned() || child->isExcludedFromNormalLayout())
continue;
LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child);
LayoutUnit minPreferredLogicalWidth;
LayoutUnit maxPreferredLogicalWidth;
computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth, maxPreferredLogicalWidth);
minPreferredLogicalWidth += margin;
maxPreferredLogicalWidth += margin;
if (!isColumnFlow()) {
maxLogicalWidth += maxPreferredLogicalWidth;
if (isMultiline()) {
minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth);
} else
minLogicalWidth += minPreferredLogicalWidth;
} else {
minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth);
maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth);
}
}
maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
minLogicalWidth = std::max(0_lu, minLogicalWidth);
maxLogicalWidth = std::max(0_lu, maxLogicalWidth);
if (hadExcludedChildren) {
minLogicalWidth = std::max(minLogicalWidth, childMinWidth);
maxLogicalWidth = std::max(maxLogicalWidth, childMaxWidth);
}
LayoutUnit scrollbarWidth(scrollbarLogicalWidth());
maxLogicalWidth += scrollbarWidth;
minLogicalWidth += scrollbarWidth;
}
void RenderFlexibleBox::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty());
m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = 0;
const RenderStyle& styleToUse = style();
if (styleToUse.logicalWidth().isFixed() && styleToUse.logicalWidth().value() > 0)
m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalWidth().value());
else
computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
if (styleToUse.logicalMinWidth().isFixed() && styleToUse.logicalMinWidth().value() > 0) {
m_maxPreferredLogicalWidth = std::max(m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalMinWidth().value()));
m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalMinWidth().value()));
}
if (styleToUse.logicalMaxWidth().isFixed()) {
m_maxPreferredLogicalWidth = std::min(m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalMaxWidth().value()));
m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse.logicalMaxWidth().value()));
}
LayoutUnit borderAndPadding = borderAndPaddingLogicalWidth();
m_minPreferredLogicalWidth += borderAndPadding;
m_maxPreferredLogicalWidth += borderAndPadding;
setPreferredLogicalWidthsDirty(false);
}
static int synthesizedBaselineFromBorderBox(const RenderBox& box, LineDirectionMode direction)
{
return (direction == HorizontalLine ? box.size().height() : box.size().width()).toInt();
}
int RenderFlexibleBox::baselinePosition(FontBaseline, bool, LineDirectionMode direction, LinePositionMode) const
{
auto baseline = firstLineBaseline();
if (!baseline)
return synthesizedBaselineFromBorderBox(*this, direction) + marginLogicalHeight();
return baseline.value() + (direction == HorizontalLine ? marginTop() : marginRight()).toInt();
}
Optional<int> RenderFlexibleBox::firstLineBaseline() const
{
if (isWritingModeRoot() || m_numberOfInFlowChildrenOnFirstLine <= 0)
return Optional<int>();
RenderBox* baselineChild = nullptr;
int childNumber = 0;
for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
if (m_orderIterator.shouldSkipChild(*child))
continue;
if (alignmentForChild(*child) == ItemPosition::Baseline && !hasAutoMarginsInCrossAxis(*child)) {
baselineChild = child;
break;
}
if (!baselineChild)
baselineChild = child;
++childNumber;
if (childNumber == m_numberOfInFlowChildrenOnFirstLine)
break;
}
if (!baselineChild)
return Optional<int>();
if (!isColumnFlow() && hasOrthogonalFlow(*baselineChild))
return Optional<int>(crossAxisExtentForChild(*baselineChild) + baselineChild->logicalTop());
if (isColumnFlow() && !hasOrthogonalFlow(*baselineChild))
return Optional<int>(mainAxisExtentForChild(*baselineChild) + baselineChild->logicalTop());
Optional<int> baseline = baselineChild->firstLineBaseline();
if (!baseline) {
LineDirectionMode direction = isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
return Optional<int>(synthesizedBaselineFromBorderBox(*baselineChild, direction) + baselineChild->logicalTop());
}
return Optional<int>(baseline.value() + baselineChild->logicalTop());
}
Optional<int> RenderFlexibleBox::inlineBlockBaseline(LineDirectionMode) const
{
return firstLineBaseline();
}
static const StyleContentAlignmentData& contentAlignmentNormalBehavior()
{
static const StyleContentAlignmentData normalBehavior = { ContentPosition::Normal, ContentDistribution::Stretch};
return normalBehavior;
}
void RenderFlexibleBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlock::styleDidChange(diff, oldStyle);
if (!oldStyle || diff != StyleDifference::Layout)
return;
if (oldStyle->resolvedAlignItems(selfAlignmentNormalBehavior()).position() == ItemPosition::Stretch) {
for (auto& child : childrenOfType<RenderBox>(*this)) {
ItemPosition previousAlignment = child.style().resolvedAlignSelf(oldStyle, selfAlignmentNormalBehavior()).position();
if (previousAlignment == ItemPosition::Stretch && previousAlignment != child.style().resolvedAlignSelf(&style(), selfAlignmentNormalBehavior()).position())
child.setChildNeedsLayout(MarkOnlyThis);
}
}
}
void RenderFlexibleBox::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
resetLogicalHeightBeforeLayoutIfNeeded();
m_relaidOutChildren.clear();
bool oldInLayout = m_inLayout;
m_inLayout = true;
if (recomputeLogicalWidth())
relayoutChildren = true;
LayoutUnit previousHeight = logicalHeight();
setLogicalHeight(borderAndPaddingLogicalHeight() + scrollbarLogicalHeight());
{
LayoutStateMaintainer statePusher(*this, locationOffset(), hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
preparePaginationBeforeBlockLayout(relayoutChildren);
m_numberOfInFlowChildrenOnFirstLine = -1;
beginUpdateScrollInfoAfterLayoutTransaction();
prepareOrderIteratorAndMargins();
layoutExcludedChildren(relayoutChildren);
ChildFrameRects oldChildRects;
appendChildFrameRects(oldChildRects);
layoutFlexItems(relayoutChildren);
endAndCommitUpdateScrollInfoAfterLayoutTransaction();
if (logicalHeight() != previousHeight)
relayoutChildren = true;
layoutPositionedObjects(relayoutChildren || isDocumentElementRenderer());
repaintChildrenDuringLayoutIfMoved(oldChildRects);
computeOverflow(clientLogicalBottomAfterRepositioning());
}
updateLayerTransform();
m_hasDefiniteHeight = SizeDefiniteness::Unknown;
updateScrollInfoAfterLayout();
repainter.repaintAfterLayout();
clearNeedsLayout();
m_inLayout = oldInLayout;
}
void RenderFlexibleBox::appendChildFrameRects(ChildFrameRects& childFrameRects)
{
for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
if (!child->isOutOfFlowPositioned())
childFrameRects.append(child->frameRect());
}
}
void RenderFlexibleBox::repaintChildrenDuringLayoutIfMoved(const ChildFrameRects& oldChildRects)
{
size_t childIndex = 0;
for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
if (child->isOutOfFlowPositioned())
continue;
if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
child->repaintDuringLayoutIfMoved(oldChildRects[childIndex]);
++childIndex;
}
ASSERT(childIndex == oldChildRects.size());
}
void RenderFlexibleBox::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& paintInfoForChild, bool usePrintRect)
{
for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
if (!paintChild(*child, paintInfo, paintOffset, paintInfoForChild, usePrintRect, PaintAsInlineBlock))
return;
}
}
void RenderFlexibleBox::repositionLogicalHeightDependentFlexItems(Vector<LineContext>& lineContexts)
{
LayoutUnit crossAxisStartEdge = lineContexts.isEmpty() ? 0_lu : lineContexts[0].crossAxisOffset;
alignFlexLines(lineContexts);
alignChildren(lineContexts);
if (style().flexWrap() == FlexWrap::Reverse)
flipForWrapReverse(lineContexts, crossAxisStartEdge);
flipForRightToLeftColumn(lineContexts);
}
LayoutUnit RenderFlexibleBox::clientLogicalBottomAfterRepositioning()
{
LayoutUnit maxChildLogicalBottom;
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
if (child->isOutOfFlowPositioned())
continue;
LayoutUnit childLogicalBottom = logicalTopForChild(*child) + logicalHeightForChild(*child) + marginAfterForChild(*child);
maxChildLogicalBottom = std::max(maxChildLogicalBottom, childLogicalBottom);
}
return std::max(clientLogicalBottom(), maxChildLogicalBottom + paddingAfter());
}
bool RenderFlexibleBox::hasOrthogonalFlow(const RenderBox& child) const
{
return isHorizontalFlow() != child.isHorizontalWritingMode();
}
bool RenderFlexibleBox::isColumnFlow() const
{
return style().isColumnFlexDirection();
}
bool RenderFlexibleBox::isHorizontalFlow() const
{
if (isHorizontalWritingMode())
return !isColumnFlow();
return isColumnFlow();
}
bool RenderFlexibleBox::isLeftToRightFlow() const
{
if (isColumnFlow())
return style().writingMode() == TopToBottomWritingMode || style().writingMode() == LeftToRightWritingMode;
return style().isLeftToRightDirection() ^ (style().flexDirection() == FlexDirection::RowReverse);
}
bool RenderFlexibleBox::isMultiline() const
{
return style().flexWrap() != FlexWrap::NoWrap;
}
Length RenderFlexibleBox::flexBasisForChild(const RenderBox& child) const
{
Length flexLength = child.style().flexBasis();
if (flexLength.isAuto())
flexLength = isHorizontalFlow() ? child.style().width() : child.style().height();
return flexLength;
}
LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(const RenderBox& child) const
{
return isHorizontalFlow() ? child.height() : child.width();
}
LayoutUnit RenderFlexibleBox::cachedChildIntrinsicContentLogicalHeight(const RenderBox& child) const
{
if (child.isRenderReplaced())
return downcast<RenderReplaced>(child).intrinsicLogicalHeight();
if (m_intrinsicContentLogicalHeights.contains(&child))
return m_intrinsicContentLogicalHeights.get(&child);
return child.contentLogicalHeight();
}
void RenderFlexibleBox::setCachedChildIntrinsicContentLogicalHeight(const RenderBox& child, LayoutUnit height)
{
if (child.isRenderReplaced())
return; m_intrinsicContentLogicalHeights.set(&child, height);
}
void RenderFlexibleBox::clearCachedChildIntrinsicContentLogicalHeight(const RenderBox& child)
{
if (child.isRenderReplaced())
return; m_intrinsicContentLogicalHeights.remove(&child);
}
LayoutUnit RenderFlexibleBox::childIntrinsicLogicalHeight(const RenderBox& child) const
{
ASSERT(!hasOrthogonalFlow(child));
if (needToStretchChildLogicalHeight(child)) {
LayoutUnit childContentHeight = cachedChildIntrinsicContentLogicalHeight(child);
LayoutUnit childLogicalHeight = childContentHeight + child.scrollbarLogicalHeight() + child.borderAndPaddingLogicalHeight();
return child.constrainLogicalHeightByMinMax(childLogicalHeight, childContentHeight);
}
return child.logicalHeight();
}
LayoutUnit RenderFlexibleBox::childIntrinsicLogicalWidth(const RenderBox& child) const
{
ASSERT(hasOrthogonalFlow(child));
if (!crossAxisLengthIsDefinite(child, child.style().logicalWidth()))
return child.maxPreferredLogicalWidth();
return child.logicalWidth();
}
LayoutUnit RenderFlexibleBox::crossAxisIntrinsicExtentForChild(const RenderBox& child) const
{
return hasOrthogonalFlow(child) ? childIntrinsicLogicalWidth(child) : childIntrinsicLogicalHeight(child);
}
LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(const RenderBox& child) const
{
return isHorizontalFlow() ? child.size().width() : child.size().height();
}
LayoutUnit RenderFlexibleBox::mainAxisContentExtentForChildIncludingScrollbar(const RenderBox& child) const
{
return isHorizontalFlow() ? child.contentWidth() + child.verticalScrollbarWidth() : child.contentHeight() + child.horizontalScrollbarHeight();
}
LayoutUnit RenderFlexibleBox::crossAxisExtent() const
{
return isHorizontalFlow() ? size().height() : size().width();
}
LayoutUnit RenderFlexibleBox::mainAxisExtent() const
{
return isHorizontalFlow() ? size().width() : size().height();
}
LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
{
return isHorizontalFlow() ? contentHeight() : contentWidth();
}
LayoutUnit RenderFlexibleBox::mainAxisContentExtent(LayoutUnit contentLogicalHeight)
{
if (isColumnFlow()) {
LayoutUnit borderPaddingAndScrollbar = borderAndPaddingLogicalHeight() + scrollbarLogicalHeight();
LayoutUnit borderBoxLogicalHeight = contentLogicalHeight + borderPaddingAndScrollbar;
auto computedValues = computeLogicalHeight(borderBoxLogicalHeight, logicalTop());
if (computedValues.m_extent == LayoutUnit::max())
return computedValues.m_extent;
return std::max(0_lu, computedValues.m_extent - borderPaddingAndScrollbar);
}
return contentLogicalWidth();
}
Optional<LayoutUnit> RenderFlexibleBox::computeMainAxisExtentForChild(const RenderBox& child, SizeType sizeType, const Length& size)
{
if (isHorizontalFlow() != child.style().isHorizontalWritingMode()) {
Optional<LayoutUnit> height = child.computeContentLogicalHeight(sizeType, size, cachedChildIntrinsicContentLogicalHeight(child));
if (!height)
return height;
return height.value() + child.scrollbarLogicalHeight();
}
LayoutUnit borderAndPadding = child.borderAndPaddingLogicalWidth();
if (child.style().logicalWidth().isAuto() && !child.hasAspectRatio()) {
if (size.type() == MinContent)
return child.minPreferredLogicalWidth() - borderAndPadding;
if (size.type() == MaxContent)
return child.maxPreferredLogicalWidth() - borderAndPadding;
}
RenderFragmentContainer* fragment = nullptr;
return child.computeLogicalWidthInFragmentUsing(sizeType, size, contentLogicalWidth(), *this, fragment) - borderAndPadding;
}
WritingMode RenderFlexibleBox::transformedWritingMode() const
{
WritingMode mode = style().writingMode();
if (!isColumnFlow())
return mode;
switch (mode) {
case TopToBottomWritingMode:
case BottomToTopWritingMode:
return style().isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
case LeftToRightWritingMode:
case RightToLeftWritingMode:
return style().isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
}
ASSERT_NOT_REACHED();
return TopToBottomWritingMode;
}
LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? borderLeft() : borderRight();
return isLeftToRightFlow() ? borderTop() : borderBottom();
}
LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? borderRight() : borderLeft();
return isLeftToRightFlow() ? borderBottom() : borderTop();
}
LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
{
switch (transformedWritingMode()) {
case TopToBottomWritingMode:
return borderTop();
case BottomToTopWritingMode:
return borderBottom();
case LeftToRightWritingMode:
return borderLeft();
case RightToLeftWritingMode:
return borderRight();
}
ASSERT_NOT_REACHED();
return borderTop();
}
LayoutUnit RenderFlexibleBox::flowAwareBorderAfter() const
{
switch (transformedWritingMode()) {
case TopToBottomWritingMode:
return borderBottom();
case BottomToTopWritingMode:
return borderTop();
case LeftToRightWritingMode:
return borderRight();
case RightToLeftWritingMode:
return borderLeft();
}
ASSERT_NOT_REACHED();
return borderTop();
}
LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? paddingLeft() : paddingRight();
return isLeftToRightFlow() ? paddingTop() : paddingBottom();
}
LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? paddingRight() : paddingLeft();
return isLeftToRightFlow() ? paddingBottom() : paddingTop();
}
LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
{
switch (transformedWritingMode()) {
case TopToBottomWritingMode:
return paddingTop();
case BottomToTopWritingMode:
return paddingBottom();
case LeftToRightWritingMode:
return paddingLeft();
case RightToLeftWritingMode:
return paddingRight();
}
ASSERT_NOT_REACHED();
return paddingTop();
}
LayoutUnit RenderFlexibleBox::flowAwarePaddingAfter() const
{
switch (transformedWritingMode()) {
case TopToBottomWritingMode:
return paddingBottom();
case BottomToTopWritingMode:
return paddingTop();
case LeftToRightWritingMode:
return paddingRight();
case RightToLeftWritingMode:
return paddingLeft();
}
ASSERT_NOT_REACHED();
return paddingTop();
}
LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(const RenderBox& child) const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? child.marginLeft() : child.marginRight();
return isLeftToRightFlow() ? child.marginTop() : child.marginBottom();
}
LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(const RenderBox& child) const
{
if (isHorizontalFlow())
return isLeftToRightFlow() ? child.marginRight() : child.marginLeft();
return isLeftToRightFlow() ? child.marginBottom() : child.marginTop();
}
LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(const RenderBox& child) const
{
switch (transformedWritingMode()) {
case TopToBottomWritingMode:
return child.marginTop();
case BottomToTopWritingMode:
return child.marginBottom();
case LeftToRightWritingMode:
return child.marginLeft();
case RightToLeftWritingMode:
return child.marginRight();
}
ASSERT_NOT_REACHED();
return marginTop();
}
LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(const RenderBox& child) const
{
return isHorizontalFlow() ? child.verticalMarginExtent() : child.horizontalMarginExtent();
}
LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
{
return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
}
LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(const RenderBox& child) const
{
return isHorizontalFlow() ? child.location() : child.location().transposedPoint();
}
bool RenderFlexibleBox::useChildAspectRatio(const RenderBox& child) const
{
if (!child.hasAspectRatio())
return false;
if (!child.intrinsicSize().height()) {
return false;
}
Length crossSize;
if (isHorizontalFlow())
crossSize = child.style().height();
else
crossSize = child.style().width();
return crossAxisLengthIsDefinite(child, crossSize);
}
LayoutUnit RenderFlexibleBox::computeMainSizeFromAspectRatioUsing(const RenderBox& child, Length crossSizeLength) const
{
ASSERT(child.hasAspectRatio());
ASSERT(child.intrinsicSize().height());
Optional<LayoutUnit> crossSize;
if (crossSizeLength.isFixed())
crossSize = LayoutUnit(crossSizeLength.value());
else {
ASSERT(crossSizeLength.isPercentOrCalculated());
crossSize = hasOrthogonalFlow(child) ? adjustBorderBoxLogicalWidthForBoxSizing(valueForLength(crossSizeLength, contentWidth())) : child.computePercentageLogicalHeight(crossSizeLength);
if (!crossSize)
return 0_lu;
}
const LayoutSize& childIntrinsicSize = child.intrinsicSize();
double ratio = childIntrinsicSize.width().toFloat() /
childIntrinsicSize.height().toFloat();
if (isHorizontalFlow())
return LayoutUnit(crossSize.value() * ratio);
return LayoutUnit(crossSize.value() / ratio);
}
void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox& child, const LayoutPoint& location)
{
if (isHorizontalFlow())
child.setLocation(location);
else
child.setLocation(location.transposedPoint());
}
bool RenderFlexibleBox::mainAxisLengthIsDefinite(const RenderBox& child, const Length& flexBasis) const
{
if (flexBasis.isAuto())
return false;
if (flexBasis.isPercentOrCalculated()) {
if (!isColumnFlow() || m_hasDefiniteHeight == SizeDefiniteness::Definite)
return true;
if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite)
return false;
bool definite = child.computePercentageLogicalHeight(flexBasis) != WTF::nullopt;
if (m_inLayout) {
m_hasDefiniteHeight = definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;
}
return definite;
}
return true;
}
bool RenderFlexibleBox::crossAxisLengthIsDefinite(const RenderBox& child, const Length& length) const
{
if (length.isAuto())
return false;
if (length.isPercentOrCalculated()) {
if (hasOrthogonalFlow(child) || m_hasDefiniteHeight == SizeDefiniteness::Definite)
return true;
if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite)
return false;
bool definite = bool(child.computePercentageLogicalHeight(length));
m_hasDefiniteHeight = definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;
return definite;
}
return length.isFixed();
}
void RenderFlexibleBox::cacheChildMainSize(const RenderBox& child)
{
ASSERT(!child.needsLayout());
LayoutUnit mainSize;
if (hasOrthogonalFlow(child))
mainSize = child.logicalHeight();
else
mainSize = child.maxPreferredLogicalWidth();
m_intrinsicSizeAlongMainAxis.set(&child, mainSize);
m_relaidOutChildren.add(&child);
}
void RenderFlexibleBox::clearCachedMainSizeForChild(const RenderBox& child)
{
m_intrinsicSizeAlongMainAxis.remove(&child);
}
LayoutUnit RenderFlexibleBox::computeInnerFlexBaseSizeForChild(RenderBox& child, LayoutUnit mainAxisBorderAndPadding, bool relayoutChildren)
{
child.clearOverrideContentSize();
Length flexBasis = flexBasisForChild(child);
if (mainAxisLengthIsDefinite(child, flexBasis))
return std::max(0_lu, computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis).value());
LayoutUnit mainAxisExtent;
if (hasOrthogonalFlow(child)) {
updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, child);
if (child.needsLayout() || relayoutChildren || !m_intrinsicSizeAlongMainAxis.contains(&child)) {
if (!child.needsLayout())
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
cacheChildMainSize(child);
}
mainAxisExtent = m_intrinsicSizeAlongMainAxis.get(&child);
} else {
mainAxisExtent = child.maxPreferredLogicalWidth();
}
return mainAxisExtent - mainAxisBorderAndPadding;
}
void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren)
{
Vector<LineContext> lineContexts;
LayoutUnit sumFlexBaseSize;
double totalFlexGrow;
double totalFlexShrink;
double totalWeightedFlexShrink;
LayoutUnit sumHypotheticalMainSize;
Vector<FlexItem> allItems;
m_orderIterator.first();
for (RenderBox* child = m_orderIterator.currentChild(); child; child = m_orderIterator.next()) {
if (m_orderIterator.shouldSkipChild(*child)) {
if (child->isOutOfFlowPositioned())
prepareChildForPositionedLayout(*child);
continue;
}
allItems.append(constructFlexItem(*child, relayoutChildren));
}
const LayoutUnit lineBreakLength = mainAxisContentExtent(LayoutUnit::max());
FlexLayoutAlgorithm flexAlgorithm(style(), lineBreakLength, allItems);
LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
Vector<FlexItem> lineItems;
size_t nextIndex = 0;
while (flexAlgorithm.computeNextFlexLine(nextIndex, lineItems, sumFlexBaseSize, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink, sumHypotheticalMainSize)) {
LayoutUnit containerMainInnerSize = mainAxisContentExtent(sumHypotheticalMainSize);
LayoutUnit remainingFreeSpace = containerMainInnerSize - sumFlexBaseSize;
FlexSign flexSign = (sumHypotheticalMainSize < containerMainInnerSize) ? PositiveFlexibility : NegativeFlexibility;
freezeInflexibleItems(flexSign, lineItems, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink);
const LayoutUnit initialFreeSpace = remainingFreeSpace;
while (!resolveFlexibleLengths(flexSign, lineItems, initialFreeSpace, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink)) {
ASSERT(totalFlexGrow >= 0);
ASSERT(totalWeightedFlexShrink >= 0);
}
remainingFreeSpace = containerMainInnerSize;
for (size_t i = 0; i < lineItems.size(); ++i) {
FlexItem& flexItem = lineItems[i];
ASSERT(!flexItem.box.isOutOfFlowPositioned());
remainingFreeSpace -= flexItem.flexedMarginBoxSize();
}
layoutAndPlaceChildren(crossAxisOffset, lineItems, remainingFreeSpace, relayoutChildren, lineContexts);
}
if (hasLineIfEmpty()) {
LayoutUnit minHeight = borderAndPaddingLogicalHeight() + lineHeight(true, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes) + scrollbarLogicalHeight();
if (size().height() < minHeight)
setLogicalHeight(minHeight);
}
updateLogicalHeight();
repositionLogicalHeightDependentFlexItems(lineContexts);
}
LayoutUnit RenderFlexibleBox::autoMarginOffsetInMainAxis(const Vector<FlexItem>& children, LayoutUnit& availableFreeSpace)
{
if (availableFreeSpace <= 0_lu)
return 0_lu;
int numberOfAutoMargins = 0;
bool isHorizontal = isHorizontalFlow();
for (size_t i = 0; i < children.size(); ++i) {
const auto& child = children[i].box;
ASSERT(!child.isOutOfFlowPositioned());
if (isHorizontal) {
if (child.style().marginLeft().isAuto())
++numberOfAutoMargins;
if (child.style().marginRight().isAuto())
++numberOfAutoMargins;
} else {
if (child.style().marginTop().isAuto())
++numberOfAutoMargins;
if (child.style().marginBottom().isAuto())
++numberOfAutoMargins;
}
}
if (!numberOfAutoMargins)
return 0_lu;
LayoutUnit sizeOfAutoMargin = availableFreeSpace / numberOfAutoMargins;
availableFreeSpace = 0_lu;
return sizeOfAutoMargin;
}
void RenderFlexibleBox::updateAutoMarginsInMainAxis(RenderBox& child, LayoutUnit autoMarginOffset)
{
ASSERT(autoMarginOffset >= 0_lu);
if (isHorizontalFlow()) {
if (child.style().marginLeft().isAuto())
child.setMarginLeft(autoMarginOffset);
if (child.style().marginRight().isAuto())
child.setMarginRight(autoMarginOffset);
} else {
if (child.style().marginTop().isAuto())
child.setMarginTop(autoMarginOffset);
if (child.style().marginBottom().isAuto())
child.setMarginBottom(autoMarginOffset);
}
}
bool RenderFlexibleBox::hasAutoMarginsInCrossAxis(const RenderBox& child) const
{
if (isHorizontalFlow())
return child.style().marginTop().isAuto() || child.style().marginBottom().isAuto();
return child.style().marginLeft().isAuto() || child.style().marginRight().isAuto();
}
LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(LayoutUnit lineCrossAxisExtent, const RenderBox& child)
{
ASSERT(!child.isOutOfFlowPositioned());
LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
return lineCrossAxisExtent - childCrossExtent;
}
bool RenderFlexibleBox::updateAutoMarginsInCrossAxis(RenderBox& child, LayoutUnit availableAlignmentSpace)
{
ASSERT(!child.isOutOfFlowPositioned());
ASSERT(availableAlignmentSpace >= 0_lu);
bool isHorizontal = isHorizontalFlow();
Length topOrLeft = isHorizontal ? child.style().marginTop() : child.style().marginLeft();
Length bottomOrRight = isHorizontal ? child.style().marginBottom() : child.style().marginRight();
if (topOrLeft.isAuto() && bottomOrRight.isAuto()) {
adjustAlignmentForChild(child, availableAlignmentSpace / 2);
if (isHorizontal) {
child.setMarginTop(availableAlignmentSpace / 2);
child.setMarginBottom(availableAlignmentSpace / 2);
} else {
child.setMarginLeft(availableAlignmentSpace / 2);
child.setMarginRight(availableAlignmentSpace / 2);
}
return true;
}
bool shouldAdjustTopOrLeft = true;
if (isColumnFlow() && !child.style().isLeftToRightDirection()) {
shouldAdjustTopOrLeft = false;
}
if (!isColumnFlow() && child.style().isFlippedBlocksWritingMode()) {
shouldAdjustTopOrLeft = false;
}
if (topOrLeft.isAuto()) {
if (shouldAdjustTopOrLeft)
adjustAlignmentForChild(child, availableAlignmentSpace);
if (isHorizontal)
child.setMarginTop(availableAlignmentSpace);
else
child.setMarginLeft(availableAlignmentSpace);
return true;
}
if (bottomOrRight.isAuto()) {
if (!shouldAdjustTopOrLeft)
adjustAlignmentForChild(child, availableAlignmentSpace);
if (isHorizontal)
child.setMarginBottom(availableAlignmentSpace);
else
child.setMarginRight(availableAlignmentSpace);
return true;
}
return false;
}
LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(const RenderBox& child)
{
LayoutUnit ascent = child.firstLineBaseline().valueOr(crossAxisExtentForChild(child));
return ascent + flowAwareMarginBeforeForChild(child);
}
LayoutUnit RenderFlexibleBox::computeChildMarginValue(Length margin)
{
LayoutUnit availableSize = contentLogicalWidth();
return minimumValueForLength(margin, availableSize);
}
void RenderFlexibleBox::prepareOrderIteratorAndMargins()
{
OrderIteratorPopulator populator(m_orderIterator);
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
if (!populator.collectChild(*child))
continue;
if (isHorizontalFlow()) {
child->setMarginLeft(computeChildMarginValue(child->style().marginLeft()));
child->setMarginRight(computeChildMarginValue(child->style().marginRight()));
} else {
child->setMarginTop(computeChildMarginValue(child->style().marginTop()));
child->setMarginBottom(computeChildMarginValue(child->style().marginBottom()));
}
}
}
LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(const RenderBox& child, LayoutUnit childSize)
{
Length max = isHorizontalFlow() ? child.style().maxWidth() : child.style().maxHeight();
Optional<LayoutUnit> maxExtent = WTF::nullopt;
if (max.isSpecifiedOrIntrinsic()) {
maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
childSize = std::min(childSize, maxExtent.valueOr(childSize));
}
Length min = isHorizontalFlow() ? child.style().minWidth() : child.style().minHeight();
if (min.isSpecifiedOrIntrinsic())
return std::max(childSize, std::max(0_lu, computeMainAxisExtentForChild(child, MinSize, min).valueOr(childSize)));
if (!isFlexibleBoxImpl() && min.isAuto() && mainAxisOverflowForChild(child) == Overflow::Visible && !(isColumnFlow() && is<RenderFlexibleBox>(child))) {
LayoutUnit contentSize = computeMainAxisExtentForChild(child, MinSize, Length(MinContent)).valueOr(0);
ASSERT(contentSize >= 0);
if (child.hasAspectRatio() && child.intrinsicSize().height() > 0)
contentSize = adjustChildSizeForAspectRatioCrossAxisMinAndMax(child, contentSize);
contentSize = std::min(contentSize, maxExtent.valueOr(contentSize));
Length mainSize = isHorizontalFlow() ? child.style().width() : child.style().height();
if (mainAxisLengthIsDefinite(child, mainSize)) {
LayoutUnit resolvedMainSize = computeMainAxisExtentForChild(child, MainOrPreferredSize, mainSize).valueOr(0);
ASSERT(resolvedMainSize >= 0);
LayoutUnit specifiedSize = std::min(resolvedMainSize, maxExtent.valueOr(resolvedMainSize));
return std::max(childSize, std::min(specifiedSize, contentSize));
}
if (useChildAspectRatio(child)) {
Length crossSizeLength = isHorizontalFlow() ? child.style().height() : child.style().width();
Optional<LayoutUnit> transferredSize = computeMainSizeFromAspectRatioUsing(child, crossSizeLength);
if (transferredSize) {
transferredSize = adjustChildSizeForAspectRatioCrossAxisMinAndMax(child, transferredSize.value());
return std::max(childSize, std::min(transferredSize.value(), contentSize));
}
}
return std::max(childSize, contentSize);
}
return std::max(0_lu, childSize);
}
Optional<LayoutUnit> RenderFlexibleBox::crossSizeForPercentageResolution(const RenderBox& child)
{
if (alignmentForChild(child) != ItemPosition::Stretch)
return WTF::nullopt;
if (hasOrthogonalFlow(child) && child.hasOverrideContentLogicalWidth())
return child.overrideContentLogicalWidth();
if (!hasOrthogonalFlow(child) && child.hasOverrideContentLogicalHeight())
return child.overrideContentLogicalHeight();
return WTF::nullopt;
}
Optional<LayoutUnit> RenderFlexibleBox::mainSizeForPercentageResolution(const RenderBox& child)
{
const Length& flexBasis = flexBasisForChild(child);
if (!mainAxisLengthIsDefinite(child, flexBasis))
return WTF::nullopt;
if (!flexBasis.isPercentOrCalculated()) {
if (!mainAxisLengthIsDefinite(child, Length(0, Percent)))
return WTF::nullopt;
}
if (hasOrthogonalFlow(child))
return child.hasOverrideContentLogicalHeight() ? Optional<LayoutUnit>(child.overrideContentLogicalHeight()) : WTF::nullopt;
return child.hasOverrideContentLogicalWidth() ? Optional<LayoutUnit>(child.overrideContentLogicalWidth()) : WTF::nullopt;
}
Optional<LayoutUnit> RenderFlexibleBox::childLogicalHeightForPercentageResolution(const RenderBox& child)
{
if (!hasOrthogonalFlow(child))
return crossSizeForPercentageResolution(child);
return mainSizeForPercentageResolution(child);
}
LayoutUnit RenderFlexibleBox::adjustChildSizeForAspectRatioCrossAxisMinAndMax(const RenderBox& child, LayoutUnit childSize)
{
Length crossMin = isHorizontalFlow() ? child.style().minHeight() : child.style().minWidth();
Length crossMax = isHorizontalFlow() ? child.style().maxHeight() : child.style().maxWidth();
if (crossAxisLengthIsDefinite(child, crossMax)) {
LayoutUnit maxValue = computeMainSizeFromAspectRatioUsing(child, crossMax);
childSize = std::min(maxValue, childSize);
}
if (crossAxisLengthIsDefinite(child, crossMin)) {
LayoutUnit minValue = computeMainSizeFromAspectRatioUsing(child, crossMin);
childSize = std::max(minValue, childSize);
}
return childSize;
}
FlexItem RenderFlexibleBox::constructFlexItem(RenderBox& child, bool relayoutChildren)
{
if (childHasIntrinsicMainAxisSize(child) && child.needsLayout()) {
child.clearOverrideContentSize();
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
cacheChildMainSize(child);
relayoutChildren = false;
}
LayoutUnit borderAndPadding = isHorizontalFlow() ? child.horizontalBorderAndPaddingExtent() : child.verticalBorderAndPaddingExtent();
LayoutUnit childInnerFlexBaseSize = computeInnerFlexBaseSizeForChild(child, borderAndPadding, relayoutChildren);
LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childInnerFlexBaseSize);
LayoutUnit margin = isHorizontalFlow() ? child.horizontalMarginExtent() : child.verticalMarginExtent();
return FlexItem(child, childInnerFlexBaseSize, childMinMaxAppliedMainAxisExtent, borderAndPadding, margin);
}
void RenderFlexibleBox::freezeViolations(Vector<FlexItem*>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
{
for (size_t i = 0; i < violations.size(); ++i) {
ASSERT(!violations[i]->frozen);
const auto& child = violations[i]->box;
LayoutUnit childSize = violations[i]->flexedContentSize;
availableFreeSpace -= childSize - violations[i]->flexBaseContentSize;
totalFlexGrow -= child.style().flexGrow();
totalFlexShrink -= child.style().flexShrink();
totalWeightedFlexShrink -= child.style().flexShrink() * violations[i]->flexBaseContentSize;
totalWeightedFlexShrink = std::max(totalWeightedFlexShrink, 0.0);
violations[i]->frozen = true;
}
}
void RenderFlexibleBox::freezeInflexibleItems(FlexSign flexSign, Vector<FlexItem>& children, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
{
Vector<FlexItem*> newInflexibleItems;
for (size_t i = 0; i < children.size(); ++i) {
FlexItem& flexItem = children[i];
const auto& child = flexItem.box;
ASSERT(!flexItem.box.isOutOfFlowPositioned());
ASSERT(!flexItem.frozen);
float flexFactor = (flexSign == PositiveFlexibility) ? child.style().flexGrow() : child.style().flexShrink();
if (!flexFactor || (flexSign == PositiveFlexibility && flexItem.flexBaseContentSize > flexItem.hypotheticalMainContentSize) || (flexSign == NegativeFlexibility && flexItem.flexBaseContentSize < flexItem.hypotheticalMainContentSize)) {
flexItem.flexedContentSize = flexItem.hypotheticalMainContentSize;
newInflexibleItems.append(&flexItem);
}
}
freezeViolations(newInflexibleItems, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink);
}
bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, Vector<FlexItem>& children, LayoutUnit initialFreeSpace, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
{
LayoutUnit totalViolation;
LayoutUnit usedFreeSpace;
Vector<FlexItem*> minViolations;
Vector<FlexItem*> maxViolations;
double sumFlexFactors = (flexSign == PositiveFlexibility) ? totalFlexGrow : totalFlexShrink;
if (sumFlexFactors > 0 && sumFlexFactors < 1) {
LayoutUnit fractional(initialFreeSpace * sumFlexFactors);
if (fractional.abs() < remainingFreeSpace.abs())
remainingFreeSpace = fractional;
}
for (size_t i = 0; i < children.size(); ++i) {
FlexItem& flexItem = children[i];
const auto& child = flexItem.box;
if (flexItem.frozen)
continue;
LayoutUnit childSize = flexItem.flexBaseContentSize;
double extraSpace = 0;
if (remainingFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow))
extraSpace = remainingFreeSpace * child.style().flexGrow() / totalFlexGrow;
else if (remainingFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink) && child.style().flexShrink())
extraSpace = remainingFreeSpace * child.style().flexShrink() * flexItem.flexBaseContentSize / totalWeightedFlexShrink;
if (std::isfinite(extraSpace))
childSize += LayoutUnit::fromFloatRound(extraSpace);
LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize);
ASSERT(adjustedChildSize >= 0);
flexItem.flexedContentSize = adjustedChildSize;
usedFreeSpace += adjustedChildSize - flexItem.flexBaseContentSize;
LayoutUnit violation = adjustedChildSize - childSize;
if (violation > 0)
minViolations.append(&flexItem);
else if (violation < 0)
maxViolations.append(&flexItem);
totalViolation += violation;
}
if (totalViolation)
freezeViolations(totalViolation < 0 ? maxViolations : minViolations, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink);
else
remainingFreeSpace -= usedFreeSpace;
return !totalViolation;
}
static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, ContentPosition justifyContent, ContentDistribution justifyContentDistribution, unsigned numberOfChildren)
{
if (justifyContent == ContentPosition::FlexEnd)
return availableFreeSpace;
if (justifyContent == ContentPosition::Center)
return availableFreeSpace / 2;
if (justifyContentDistribution == ContentDistribution::SpaceAround) {
if (availableFreeSpace > 0 && numberOfChildren)
return availableFreeSpace / (2 * numberOfChildren);
else
return availableFreeSpace / 2;
}
if (justifyContentDistribution == ContentDistribution::SpaceEvenly) {
if (availableFreeSpace > 0 && numberOfChildren)
return availableFreeSpace / (numberOfChildren + 1);
return availableFreeSpace / 2;
}
return 0;
}
static LayoutUnit justifyContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, ContentDistribution justifyContentDistribution, unsigned numberOfChildren)
{
if (availableFreeSpace > 0 && numberOfChildren > 1) {
if (justifyContentDistribution == ContentDistribution::SpaceBetween)
return availableFreeSpace / (numberOfChildren - 1);
if (justifyContentDistribution == ContentDistribution::SpaceAround)
return availableFreeSpace / numberOfChildren;
if (justifyContentDistribution == ContentDistribution::SpaceEvenly)
return availableFreeSpace / (numberOfChildren + 1);
}
return 0;
}
static LayoutUnit alignmentOffset(LayoutUnit availableFreeSpace, ItemPosition position, LayoutUnit ascent, LayoutUnit maxAscent, bool isWrapReverse)
{
switch (position) {
case ItemPosition::Legacy:
case ItemPosition::Auto:
case ItemPosition::Normal:
ASSERT_NOT_REACHED();
break;
case ItemPosition::Stretch:
if (isWrapReverse)
return availableFreeSpace;
break;
case ItemPosition::FlexStart:
break;
case ItemPosition::FlexEnd:
return availableFreeSpace;
case ItemPosition::Center:
return availableFreeSpace / 2;
case ItemPosition::Baseline:
return maxAscent - ascent;
case ItemPosition::LastBaseline:
case ItemPosition::SelfStart:
case ItemPosition::SelfEnd:
case ItemPosition::Start:
case ItemPosition::End:
case ItemPosition::Left:
case ItemPosition::Right:
break;
}
return 0;
}
void RenderFlexibleBox::setOverrideMainAxisContentSizeForChild(RenderBox& child, LayoutUnit childPreferredSize)
{
if (hasOrthogonalFlow(child))
child.setOverrideContentLogicalHeight(childPreferredSize);
else
child.setOverrideContentLogicalWidth(childPreferredSize);
}
LayoutUnit RenderFlexibleBox::staticMainAxisPositionForPositionedChild(const RenderBox& child)
{
const LayoutUnit availableSpace = mainAxisContentExtent(contentLogicalHeight()) - mainAxisExtentForChild(child);
ContentPosition position = style().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
ContentDistribution distribution = style().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
LayoutUnit offset = initialJustifyContentOffset(availableSpace, position, distribution, 1);
if (style().flexDirection() == FlexDirection::RowReverse || style().flexDirection() == FlexDirection::ColumnReverse)
offset = availableSpace - offset;
return offset;
}
LayoutUnit RenderFlexibleBox::staticCrossAxisPositionForPositionedChild(const RenderBox& child)
{
LayoutUnit availableSpace = crossAxisContentExtent() - crossAxisExtentForChild(child);
return alignmentOffset(availableSpace, alignmentForChild(child), 0_lu, 0_lu, style().flexWrap() == FlexWrap::Reverse);
}
LayoutUnit RenderFlexibleBox::staticInlinePositionForPositionedChild(const RenderBox& child)
{
return startOffsetForContent() + (isColumnFlow() ? staticCrossAxisPositionForPositionedChild(child) : staticMainAxisPositionForPositionedChild(child));
}
LayoutUnit RenderFlexibleBox::staticBlockPositionForPositionedChild(const RenderBox& child)
{
return borderAndPaddingBefore() + (isColumnFlow() ? staticMainAxisPositionForPositionedChild(child) : staticCrossAxisPositionForPositionedChild(child));
}
bool RenderFlexibleBox::setStaticPositionForPositionedLayout(const RenderBox& child)
{
bool positionChanged = false;
auto* childLayer = child.layer();
if (child.style().hasStaticInlinePosition(style().isHorizontalWritingMode())) {
LayoutUnit inlinePosition = staticInlinePositionForPositionedChild(child);
if (childLayer->staticInlinePosition() != inlinePosition) {
childLayer->setStaticInlinePosition(inlinePosition);
positionChanged = true;
}
}
if (child.style().hasStaticBlockPosition(style().isHorizontalWritingMode())) {
LayoutUnit blockPosition = staticBlockPositionForPositionedChild(child);
if (childLayer->staticBlockPosition() != blockPosition) {
childLayer->setStaticBlockPosition(blockPosition);
positionChanged = true;
}
}
return positionChanged;
}
void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox& child)
{
ASSERT(child.isOutOfFlowPositioned());
child.containingBlock()->insertPositionedObject(child);
auto* childLayer = child.layer();
LayoutUnit staticInlinePosition = flowAwareBorderStart() + flowAwarePaddingStart();
if (childLayer->staticInlinePosition() != staticInlinePosition) {
childLayer->setStaticInlinePosition(staticInlinePosition);
if (child.style().hasStaticInlinePosition(style().isHorizontalWritingMode()))
child.setChildNeedsLayout(MarkOnlyThis);
}
LayoutUnit staticBlockPosition = flowAwareBorderBefore() + flowAwarePaddingBefore();
if (childLayer->staticBlockPosition() != staticBlockPosition) {
childLayer->setStaticBlockPosition(staticBlockPosition);
if (child.style().hasStaticBlockPosition(style().isHorizontalWritingMode()))
child.setChildNeedsLayout(MarkOnlyThis);
}
}
ItemPosition RenderFlexibleBox::alignmentForChild(const RenderBox& child) const
{
ItemPosition align = child.style().resolvedAlignSelf(&style(), selfAlignmentNormalBehavior()).position();
ASSERT(align != ItemPosition::Auto && align != ItemPosition::Normal);
if (align == ItemPosition::Baseline && hasOrthogonalFlow(child))
align = ItemPosition::FlexStart;
if (style().flexWrap() == FlexWrap::Reverse) {
if (align == ItemPosition::FlexStart)
align = ItemPosition::FlexEnd;
else if (align == ItemPosition::FlexEnd)
align = ItemPosition::FlexStart;
}
return align;
}
void RenderFlexibleBox::resetAutoMarginsAndLogicalTopInCrossAxis(RenderBox& child)
{
if (hasAutoMarginsInCrossAxis(child)) {
child.updateLogicalHeight();
if (isHorizontalFlow()) {
if (child.style().marginTop().isAuto())
child.setMarginTop(0_lu);
if (child.style().marginBottom().isAuto())
child.setMarginBottom(0_lu);
} else {
if (child.style().marginLeft().isAuto())
child.setMarginLeft(0_lu);
if (child.style().marginRight().isAuto())
child.setMarginRight(0_lu);
}
}
}
bool RenderFlexibleBox::needToStretchChildLogicalHeight(const RenderBox& child) const
{
if (alignmentForChild(child) != ItemPosition::Stretch)
return false;
if (isHorizontalFlow() != child.style().isHorizontalWritingMode())
return false;
return child.style().logicalHeight().isAuto();
}
bool RenderFlexibleBox::childHasIntrinsicMainAxisSize(const RenderBox& child) const
{
bool result = false;
if (isHorizontalFlow() != child.style().isHorizontalWritingMode()) {
Length childFlexBasis = flexBasisForChild(child);
Length childMinSize = isHorizontalFlow() ? child.style().minWidth() : child.style().minHeight();
Length childMaxSize = isHorizontalFlow() ? child.style().maxWidth() : child.style().maxHeight();
if (childFlexBasis.isIntrinsic() || childMinSize.isIntrinsicOrAuto() || childMaxSize.isIntrinsic())
result = true;
}
return result;
}
Overflow RenderFlexibleBox::mainAxisOverflowForChild(const RenderBox& child) const
{
if (isHorizontalFlow())
return child.style().overflowX();
return child.style().overflowY();
}
Overflow RenderFlexibleBox::crossAxisOverflowForChild(const RenderBox& child) const
{
if (isHorizontalFlow())
return child.style().overflowY();
return child.style().overflowX();
}
bool RenderFlexibleBox::hasPercentHeightDescendants(const RenderBox& renderer) const
{
if (!is<RenderBlock>(renderer))
return false;
auto& renderBlock = downcast<RenderBlock>(renderer);
if (!renderBlock.hasPercentHeightDescendants())
return false;
auto* percentHeightDescendants = renderBlock.percentHeightDescendants();
if (!percentHeightDescendants)
return false;
for (auto it = percentHeightDescendants->begin(), end = percentHeightDescendants->end(); it != end; ++it) {
bool hasOutOfFlowAncestor = false;
for (auto* ancestor = (*it)->containingBlock(); ancestor && ancestor != &renderBlock; ancestor = ancestor->containingBlock()) {
if (ancestor->isOutOfFlowPositioned()) {
hasOutOfFlowAncestor = true;
break;
}
}
if (!hasOutOfFlowAncestor)
return true;
}
return false;
}
void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, Vector<FlexItem>& children, LayoutUnit availableFreeSpace, bool relayoutChildren, Vector<LineContext>& lineContexts)
{
ContentPosition position = style().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
ContentDistribution distribution = style().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, distribution, children.size());
if (style().flexDirection() == FlexDirection::RowReverse)
mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
LayoutUnit totalMainExtent = mainAxisExtent();
LayoutUnit maxAscent, maxDescent; LayoutUnit maxChildCrossAxisExtent;
bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
for (size_t i = 0; i < children.size(); ++i) {
const auto& flexItem = children[i];
auto& child = flexItem.box;
bool childHadLayout = child.everHadLayout();
ASSERT(!flexItem.box.isOutOfFlowPositioned());
setOverrideMainAxisContentSizeForChild(child, flexItem.flexedContentSize);
if (flexItem.flexedContentSize != mainAxisContentExtentForChildIncludingScrollbar(child))
child.setChildNeedsLayout(MarkOnlyThis);
else {
resetAutoMarginsAndLogicalTopInCrossAxis(child);
}
bool forceChildRelayout = relayoutChildren && !m_relaidOutChildren.contains(&child);
if (!forceChildRelayout && hasPercentHeightDescendants(child)) {
forceChildRelayout = true;
}
updateBlockChildDirtyBitsBeforeLayout(forceChildRelayout, child);
if (!child.needsLayout())
child.markForPaginationRelayoutIfNeeded();
if (child.needsLayout())
m_relaidOutChildren.add(&child);
child.layoutIfNeeded();
if (!childHadLayout && child.checkForRepaintDuringLayout()) {
child.repaint();
child.repaintOverhangingFloats(true);
}
updateAutoMarginsInMainAxis(child, autoMarginOffset);
LayoutUnit childCrossAxisMarginBoxExtent;
if (alignmentForChild(child) == ItemPosition::Baseline && !hasAutoMarginsInCrossAxis(child)) {
LayoutUnit ascent = marginBoxAscentForChild(child);
LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
maxAscent = std::max(maxAscent, ascent);
maxDescent = std::max(maxDescent, descent);
childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
} else
childCrossAxisMarginBoxExtent = crossAxisIntrinsicExtentForChild(child) + crossAxisMarginExtentForChild(child);
if (!isColumnFlow())
setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
mainAxisOffset += flowAwareMarginStartForChild(child);
LayoutUnit childMainExtent = mainAxisExtentForChild(child);
LayoutPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child));
setFlowAwareLocationForChild(child, childLocation);
mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
if (i != children.size() - 1) {
mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, distribution, children.size());
}
}
if (isColumnFlow())
setLogicalHeight(std::max(logicalHeight(), mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight()));
if (style().flexDirection() == FlexDirection::ColumnReverse) {
updateLogicalHeight();
layoutColumnReverse(children, crossAxisOffset, availableFreeSpace);
}
if (m_numberOfInFlowChildrenOnFirstLine == -1)
m_numberOfInFlowChildrenOnFirstLine = children.size();
lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, maxAscent, WTFMove(children)));
crossAxisOffset += maxChildCrossAxisExtent;
}
void RenderFlexibleBox::layoutColumnReverse(const Vector<FlexItem>& children, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
{
ContentPosition position = style().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
ContentDistribution distribution = style().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, position, distribution, children.size());
mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
for (size_t i = 0; i < children.size(); ++i) {
auto& child = children[i].box;
ASSERT(!child.isOutOfFlowPositioned());
mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
setFlowAwareLocationForChild(child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
mainAxisOffset -= flowAwareMarginStartForChild(child);
mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, distribution, children.size());
}
}
static LayoutUnit initialAlignContentOffset(LayoutUnit availableFreeSpace, ContentPosition alignContent, ContentDistribution alignContentDistribution, unsigned numberOfLines)
{
if (numberOfLines <= 1)
return 0_lu;
if (alignContent == ContentPosition::FlexEnd)
return availableFreeSpace;
if (alignContent == ContentPosition::Center)
return availableFreeSpace / 2;
if (alignContentDistribution == ContentDistribution::SpaceAround) {
if (availableFreeSpace > 0 && numberOfLines)
return availableFreeSpace / (2 * numberOfLines);
if (availableFreeSpace < 0)
return availableFreeSpace / 2;
}
if (alignContentDistribution == ContentDistribution::SpaceEvenly) {
if (availableFreeSpace > 0)
return availableFreeSpace / (numberOfLines + 1);
return availableFreeSpace / 2;
}
return 0_lu;
}
static LayoutUnit alignContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, ContentDistribution alignContentDistribution, unsigned numberOfLines)
{
if (availableFreeSpace > 0 && numberOfLines > 1) {
if (alignContentDistribution == ContentDistribution::SpaceBetween)
return availableFreeSpace / (numberOfLines - 1);
if (alignContentDistribution == ContentDistribution::SpaceAround || alignContentDistribution == ContentDistribution::Stretch)
return availableFreeSpace / numberOfLines;
if (alignContentDistribution == ContentDistribution::SpaceEvenly)
return availableFreeSpace / (numberOfLines + 1);
}
return 0_lu;
}
void RenderFlexibleBox::alignFlexLines(Vector<LineContext>& lineContexts)
{
ContentPosition position = style().resolvedAlignContentPosition(contentAlignmentNormalBehavior());
ContentDistribution distribution = style().resolvedAlignContentDistribution(contentAlignmentNormalBehavior());
if (lineContexts.size() == 1) {
lineContexts[0].crossAxisExtent = crossAxisContentExtent();
return;
}
if (position == ContentPosition::FlexStart)
return;
LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
for (size_t i = 0; i < lineContexts.size(); ++i)
availableCrossAxisSpace -= lineContexts[i].crossAxisExtent;
LayoutUnit lineOffset = initialAlignContentOffset(availableCrossAxisSpace, position, distribution, lineContexts.size());
for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
LineContext& lineContext = lineContexts[lineNumber];
lineContext.crossAxisOffset += lineOffset;
for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); ++childNumber) {
FlexItem& flexItem = lineContext.flexItems[childNumber];
adjustAlignmentForChild(flexItem.box, lineOffset);
}
if (distribution == ContentDistribution::Stretch && availableCrossAxisSpace > 0)
lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
lineOffset += alignContentSpaceBetweenChildren(availableCrossAxisSpace, distribution, lineContexts.size());
}
}
void RenderFlexibleBox::adjustAlignmentForChild(RenderBox& child, LayoutUnit delta)
{
ASSERT(!child.isOutOfFlowPositioned());
setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0_lu, delta));
}
void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts)
{
Vector<LayoutUnit> minMarginAfterBaselines;
for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
const LineContext& lineContext = lineContexts[lineNumber];
LayoutUnit minMarginAfterBaseline = LayoutUnit::max();
LayoutUnit lineCrossAxisExtent = lineContext.crossAxisExtent;
LayoutUnit maxAscent = lineContext.maxAscent;
for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); ++childNumber) {
const auto& flexItem = lineContext.flexItems[childNumber];
ASSERT(!flexItem.box.isOutOfFlowPositioned());
if (updateAutoMarginsInCrossAxis(flexItem.box, std::max(0_lu, availableAlignmentSpaceForChild(lineCrossAxisExtent, flexItem.box))))
continue;
ItemPosition position = alignmentForChild(flexItem.box);
if (position == ItemPosition::Stretch)
applyStretchAlignmentToChild(flexItem.box, lineCrossAxisExtent);
LayoutUnit availableSpace =
availableAlignmentSpaceForChild(lineCrossAxisExtent, flexItem.box);
LayoutUnit offset = alignmentOffset(availableSpace, position, marginBoxAscentForChild(flexItem.box), maxAscent, style().flexWrap() == FlexWrap::Reverse);
adjustAlignmentForChild(flexItem.box, offset);
if (position == ItemPosition::Baseline && style().flexWrap() == FlexWrap::Reverse)
minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, flexItem.box) - offset);
}
minMarginAfterBaselines.append(minMarginAfterBaseline);
}
if (style().flexWrap() != FlexWrap::Reverse)
return;
for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
const LineContext& lineContext = lineContexts[lineNumber];
LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); ++childNumber) {
const auto& flexItem = lineContext.flexItems[childNumber];
if (alignmentForChild(flexItem.box) == ItemPosition::Baseline && !hasAutoMarginsInCrossAxis(flexItem.box) && minMarginAfterBaseline)
adjustAlignmentForChild(flexItem.box, minMarginAfterBaseline);
}
}
}
void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox& child, LayoutUnit lineCrossAxisExtent)
{
if (!hasOrthogonalFlow(child) && child.style().logicalHeight().isAuto()) {
LayoutUnit stretchedLogicalHeight = std::max(child.borderAndPaddingLogicalHeight(),
lineCrossAxisExtent - crossAxisMarginExtentForChild(child));
ASSERT(!child.needsLayout());
LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, cachedChildIntrinsicContentLogicalHeight(child));
bool childNeedsRelayout = desiredLogicalHeight != child.logicalHeight();
if (child.isRenderBlock() && downcast<RenderBlock>(child).hasPercentHeightDescendants() && m_relaidOutChildren.contains(&child)) {
childNeedsRelayout = true;
}
if (childNeedsRelayout || !child.hasOverrideContentLogicalHeight())
child.setOverrideContentLogicalHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
if (childNeedsRelayout) {
SetForScope<bool> resetChildLogicalHeight(m_shouldResetChildLogicalHeightBeforeLayout, true);
LayoutUnit childIntrinsicContentLogicalHeight = cachedChildIntrinsicContentLogicalHeight(child);
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
setCachedChildIntrinsicContentLogicalHeight(child, childIntrinsicContentLogicalHeight);
}
} else if (hasOrthogonalFlow(child) && child.style().logicalWidth().isAuto()) {
LayoutUnit childWidth = std::max(0_lu, lineCrossAxisExtent - crossAxisMarginExtentForChild(child));
childWidth = child.constrainLogicalWidthInFragmentByMinMax(childWidth, crossAxisContentExtent(), *this, nullptr);
if (childWidth != child.logicalWidth()) {
child.setOverrideContentLogicalWidth(childWidth - child.borderAndPaddingLogicalWidth());
child.setChildNeedsLayout(MarkOnlyThis);
child.layoutIfNeeded();
}
}
}
void RenderFlexibleBox::flipForRightToLeftColumn(const Vector<LineContext>& lineContexts)
{
if (style().isLeftToRightDirection() || !isColumnFlow())
return;
LayoutUnit crossExtent = crossAxisExtent();
for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
const LineContext& lineContext = lineContexts[lineNumber];
for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); ++childNumber) {
const auto& flexItem = lineContext.flexItems[childNumber];
ASSERT(!flexItem.box.isOutOfFlowPositioned());
LayoutPoint location = flowAwareLocationForChild(flexItem.box);
location.setY(crossExtent - crossAxisExtentForChild(flexItem.box) - location.y());
if (!isHorizontalWritingMode())
location.move(LayoutSize(0, -horizontalScrollbarHeight()));
setFlowAwareLocationForChild(flexItem.box, location);
}
}
}
void RenderFlexibleBox::flipForWrapReverse(const Vector<LineContext>& lineContexts, LayoutUnit crossAxisStartEdge)
{
LayoutUnit contentExtent = crossAxisContentExtent();
for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
const LineContext& lineContext = lineContexts[lineNumber];
for (size_t childNumber = 0; childNumber < lineContext.flexItems.size(); ++childNumber) {
const auto& flexItem = lineContext.flexItems[childNumber];
LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
adjustAlignmentForChild(flexItem.box, newOffset - originalOffset);
}
}
}
bool RenderFlexibleBox::isTopLayoutOverflowAllowed() const
{
bool hasTopOverflow = RenderBlock::isTopLayoutOverflowAllowed();
if (hasTopOverflow || !style().isReverseFlexDirection())
return hasTopOverflow;
return !isHorizontalFlow();
}
bool RenderFlexibleBox::isLeftLayoutOverflowAllowed() const
{
bool hasLeftOverflow = RenderBlock::isLeftLayoutOverflowAllowed();
if (hasLeftOverflow || !style().isReverseFlexDirection())
return hasLeftOverflow;
return isHorizontalFlow();
}
}