void LayoutListMarker::layout() {
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
LayoutUnit blockOffset;
for (LayoutBox* o = parentBox(); o && o != listItem(); o = o->parentBox()) {
blockOffset += o->logicalTop();
}
if (listItem()->style()->isLeftToRightDirection()) {
m_lineOffset = listItem()->logicalLeftOffsetForLine(
blockOffset, DoNotIndentText, LayoutUnit());
} else {
m_lineOffset = listItem()->logicalRightOffsetForLine(
blockOffset, DoNotIndentText, LayoutUnit());
}
if (isImage()) {
updateMarginsAndContent();
LayoutSize imageSize(imageBulletSize());
setWidth(imageSize.width());
setHeight(imageSize.height());
} else {
const SimpleFontData* fontData = style()->font().primaryFont();
DCHECK(fontData);
setLogicalWidth(minPreferredLogicalWidth());
setLogicalHeight(
LayoutUnit(fontData ? fontData->getFontMetrics().height() : 0));
}
setMarginStart(LayoutUnit());
setMarginEnd(LayoutUnit());
Length startMargin = style()->marginStart();
Length endMargin = style()->marginEnd();
if (startMargin.isFixed())
setMarginStart(LayoutUnit(startMargin.value()));
if (endMargin.isFixed())
setMarginEnd(LayoutUnit(endMargin.value()));
clearNeedsLayout();
}
void LayoutSVGContainer::layout() {
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
// Allow LayoutSVGViewportContainer to update its viewport.
calcViewport();
// Allow LayoutSVGTransformableContainer to update its transform.
SVGTransformChange transformChange = calculateLocalTransform();
m_didScreenScaleFactorChange =
transformChange == SVGTransformChange::Full ||
SVGLayoutSupport::screenScaleFactorChanged(parent());
// LayoutSVGViewportContainer needs to set the 'layout size changed' flag.
determineIfLayoutSizeChanged();
// When hasRelativeLengths() is false, no descendants have relative lengths
// (hence no one is interested in viewport size changes).
bool layoutSizeChanged =
element()->hasRelativeLengths() &&
SVGLayoutSupport::layoutSizeOfNearestViewportChanged(this);
SVGLayoutSupport::layoutChildren(
firstChild(), false, m_didScreenScaleFactorChange, layoutSizeChanged);
// Invalidate all resources of this client if our layout changed.
if (everHadLayout() && needsLayout())
SVGResourcesCache::clientLayoutChanged(this);
if (m_needsBoundariesUpdate || transformChange != SVGTransformChange::None) {
updateCachedBoundaries();
m_needsBoundariesUpdate = false;
// If our bounds changed, notify the parents.
LayoutSVGModelObject::setNeedsBoundariesUpdate();
}
ASSERT(!m_needsBoundariesUpdate);
clearNeedsLayout();
}
void LayoutReplaced::layout()
{
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
LayoutRect oldContentRect = replacedContentRect();
setHeight(minimumReplacedHeight());
updateLogicalWidth();
updateLogicalHeight();
m_overflow.clear();
addVisualEffectOverflow();
updateLayerTransformAfterLayout();
invalidateBackgroundObscurationStatus();
clearNeedsLayout();
if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && replacedContentRect() != oldContentRect)
setShouldDoFullPaintInvalidation();
}
void RenderView::layout()
{
SubtreeLayoutScope layoutScope(*this);
bool relayoutChildren = (!m_frameView || width() != viewWidth() || height() != viewHeight());
if (relayoutChildren) {
layoutScope.setChildNeedsLayout(this);
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if ((child->isBox() && toRenderBox(child)->hasRelativeLogicalHeight())
|| child->style()->logicalHeight().isPercent()
|| child->style()->logicalMinHeight().isPercent()
|| child->style()->logicalMaxHeight().isPercent())
layoutScope.setChildNeedsLayout(child);
}
}
if (!needsLayout())
return;
RenderFlexibleBox::layout();
clearNeedsLayout();
}
void LayoutSVGRoot::layout()
{
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
bool needsLayout = selfNeedsLayout();
LayoutSize oldSize = size();
updateLogicalWidth();
updateLogicalHeight();
buildLocalToBorderBoxTransform();
SVGLayoutSupport::layoutResourcesIfNeeded(this);
SVGSVGElement* svg = toSVGSVGElement(node());
ASSERT(svg);
m_isLayoutSizeChanged = needsLayout || (svg->hasRelativeLengths() && oldSize != size());
SVGLayoutSupport::layoutChildren(this, needsLayout || SVGLayoutSupport::filtersForceContainerLayout(this));
if (m_needsBoundariesOrTransformUpdate) {
updateCachedBoundaries();
m_needsBoundariesOrTransformUpdate = false;
}
m_overflow.clear();
addVisualEffectOverflow();
if (!shouldApplyViewportClip()) {
FloatRect contentPaintInvalidationRect = paintInvalidationRectInLocalCoordinates();
contentPaintInvalidationRect = m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
addVisualOverflow(enclosingLayoutRect(contentPaintInvalidationRect));
}
updateLayerTransformAfterLayout();
m_hasBoxDecorationBackground = isDocumentElement() ? calculateHasBoxDecorations() : hasBoxDecorationBackground();
invalidateBackgroundObscurationStatus();
clearNeedsLayout();
}
void RenderSVGContainer::layout()
{
StackStats::LayoutCheckPoint layoutCheckPoint;
ASSERT(needsLayout());
// RenderSVGRoot disables layoutState for the SVG rendering tree.
ASSERT(!view()->layoutStateEnabled());
LayoutRepainter repainter(*this, SVGRenderSupport::checkForSVGRepaintDuringLayout(this) || selfWillPaint());
// Allow RenderSVGViewportContainer to update its viewport.
calcViewport();
// Allow RenderSVGTransformableContainer to update its transform.
bool updatedTransform = calculateLocalTransform();
// RenderSVGViewportContainer needs to set the 'layout size changed' flag.
determineIfLayoutSizeChanged();
SVGRenderSupport::layoutChildren(this, selfNeedsLayout() || SVGRenderSupport::filtersForceContainerLayout(this));
// Invalidate all resources of this client if our layout changed.
if (everHadLayout() && needsLayout())
SVGResourcesCache::clientLayoutChanged(this);
// At this point LayoutRepainter already grabbed the old bounds,
// recalculate them now so repaintAfterLayout() uses the new bounds.
if (m_needsBoundariesUpdate || updatedTransform) {
updateCachedBoundaries();
m_needsBoundariesUpdate = false;
// If our bounds changed, notify the parents.
RenderSVGModelObject::setNeedsBoundariesUpdate();
}
repainter.repaintAfterLayout();
clearNeedsLayout();
}
void RenderBlockFlow::layoutBlock(bool relayoutChildren)
{
ASSERT(needsLayout());
ASSERT(isInlineBlock() || !isInline());
if (!relayoutChildren && simplifiedLayout())
return;
SubtreeLayoutScope layoutScope(*this);
layoutBlockFlow(relayoutChildren, layoutScope);
updateLayerTransformAfterLayout();
// Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
// we overflow or not.
updateScrollInfoAfterLayout();
if (m_paintInvalidationLogicalTop != m_paintInvalidationLogicalBottom)
setShouldInvalidateOverflowForPaint(true);
clearNeedsLayout();
}
void LayoutMultiColumnSpannerPlaceholder::layout()
{
ASSERT(needsLayout());
// The placeholder, like any other block level object, has its logical top calculated and set
// before layout. Copy this to the actual column-span:all object before laying it out, so that
// it gets paginated correctly, in case we have an enclosing fragmentation context.
m_layoutObjectInFlowThread->setLogicalTop(logicalTop());
// Lay out the actual column-span:all element.
m_layoutObjectInFlowThread->layoutIfNeeded();
// The spanner has now been laid out, so its height is known. Time to update the placeholder's
// height as well, so that we take up the correct amount of space in the multicol container.
updateLogicalHeight();
// Take the overflow from the spanner, so that it gets
// propagated to the multicol container and beyond.
m_overflow.reset();
addContentsVisualOverflow(m_layoutObjectInFlowThread->visualOverflowRect());
addLayoutOverflow(m_layoutObjectInFlowThread->layoutOverflowRect());
clearNeedsLayout();
}
void LayoutMedia::layout() {
LayoutSize oldSize = contentBoxRect().size();
LayoutImage::layout();
LayoutRect newRect = contentBoxRect();
LayoutState state(*this);
Optional<LayoutUnit> newPanelWidth;
// Iterate the children in reverse order so that the media controls are laid
// out before the text track container. This is to ensure that the text
// track rendering has an up-to-date position of the media controls for
// overlap checking, see LayoutVTTCue.
#if ENABLE(ASSERT)
bool seenTextTrackContainer = false;
#endif
for (LayoutObject* child = m_children.lastChild(); child;
child = child->previousSibling()) {
#if ENABLE(ASSERT)
if (child->node()->isMediaControls())
ASSERT(!seenTextTrackContainer);
else if (child->node()->isTextTrackContainer())
seenTextTrackContainer = true;
else
ASSERT_NOT_REACHED();
#endif
// TODO(mlamouri): we miss some layouts because needsLayout returns false in
// some cases where we want to change the width of the controls because the
// visible viewport has changed for example.
if (newRect.size() == oldSize && !child->needsLayout())
continue;
LayoutUnit width = newRect.width();
if (child->node()->isMediaControls()) {
width = computePanelWidth(newRect);
if (width != oldSize.width())
newPanelWidth = width;
}
LayoutBox* layoutBox = toLayoutBox(child);
layoutBox->setLocation(newRect.location());
// TODO(foolip): Remove the mutableStyleRef() and depend on CSS
// width/height: inherit to match the media element size.
layoutBox->mutableStyleRef().setHeight(Length(newRect.height(), Fixed));
layoutBox->mutableStyleRef().setWidth(Length(width, Fixed));
layoutBox->forceLayout();
}
clearNeedsLayout();
// Notify our MediaControls that a layout has happened.
if (mediaElement() && mediaElement()->mediaControls() &&
newPanelWidth.has_value()) {
mediaElement()->mediaControls()->notifyPanelWidthChanged(
newPanelWidth.value());
}
}
void RenderSVGText::layout()
{
StackStats::LayoutCheckPoint layoutCheckPoint;
ASSERT(needsLayout());
LayoutRepainter repainter(*this, SVGRenderSupport::checkForSVGRepaintDuringLayout(*this));
bool updateCachedBoundariesInParents = false;
if (m_needsTransformUpdate) {
m_localTransform = textElement().animatedLocalTransform();
m_needsTransformUpdate = false;
updateCachedBoundariesInParents = true;
}
if (!everHadLayout()) {
// When laying out initially, collect all layout attributes, build the character data map,
// and propogate resulting SVGLayoutAttributes to all RenderSVGInlineText children in the subtree.
ASSERT(m_layoutAttributes.isEmpty());
collectLayoutAttributes(this, m_layoutAttributes);
updateFontInAllDescendants(this);
m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(*this);
m_needsReordering = true;
m_needsTextMetricsUpdate = false;
m_needsPositioningValuesUpdate = false;
updateCachedBoundariesInParents = true;
} else if (m_needsPositioningValuesUpdate) {
// When the x/y/dx/dy/rotate lists change, recompute the layout attributes, and eventually
// update the on-screen font objects as well in all descendants.
if (m_needsTextMetricsUpdate) {
updateFontInAllDescendants(this);
m_needsTextMetricsUpdate = false;
}
m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(*this);
m_needsReordering = true;
m_needsPositioningValuesUpdate = false;
updateCachedBoundariesInParents = true;
} else if (m_needsTextMetricsUpdate || SVGRenderSupport::findTreeRootObject(*this).isLayoutSizeChanged()) {
// If the root layout size changed (eg. window size changes) or the transform to the root
// context has changed then recompute the on-screen font size.
updateFontInAllDescendants(this, &m_layoutAttributesBuilder);
ASSERT(!m_needsReordering);
ASSERT(!m_needsPositioningValuesUpdate);
m_needsTextMetricsUpdate = false;
updateCachedBoundariesInParents = true;
}
checkLayoutAttributesConsistency(this, m_layoutAttributes);
// Reduced version of RenderBlock::layoutBlock(), which only takes care of SVG text.
// All if branches that could cause early exit in RenderBlocks layoutBlock() method are turned into assertions.
ASSERT(!isInline());
ASSERT(!simplifiedLayout());
ASSERT(!scrollsOverflow());
ASSERT(!hasControlClip());
ASSERT(!multiColumnFlowThread());
ASSERT(!positionedObjects());
ASSERT(!m_overflow);
ASSERT(!isAnonymousBlock());
if (!firstChild())
setChildrenInline(true);
// FIXME: We need to find a way to only layout the child boxes, if needed.
FloatRect oldBoundaries = objectBoundingBox();
ASSERT(childrenInline());
LayoutUnit repaintLogicalTop = 0;
LayoutUnit repaintLogicalBottom = 0;
rebuildFloatingObjectSetFromIntrudingFloats();
layoutInlineChildren(true, repaintLogicalTop, repaintLogicalBottom);
if (m_needsReordering)
m_needsReordering = false;
if (!updateCachedBoundariesInParents)
updateCachedBoundariesInParents = oldBoundaries != objectBoundingBox();
// Invalidate all resources of this client if our layout changed.
if (everHadLayout() && selfNeedsLayout())
SVGResourcesCache::clientLayoutChanged(*this);
// If our bounds changed, notify the parents.
if (updateCachedBoundariesInParents)
RenderSVGBlock::setNeedsBoundariesUpdate();
repainter.repaintAfterLayout();
clearNeedsLayout();
}
void RenderSVGGradientStop::layout()
{
clearNeedsLayout();
}
void LayoutPart::layout()
{
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
clearNeedsLayout();
}
void RenderWidget::layout()
{
ASSERT(needsLayout());
clearNeedsLayout();
}
void RenderMathMLRoot::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
updateStyle();
m_radicalOperatorTop = 0;
m_baseWidth = 0;
if (!isValid()) {
setLogicalWidth(0);
setLogicalHeight(0);
clearNeedsLayout();
return;
}
// We layout the children, determine the vertical metrics of the base and set the logical width.
// Note: Per the MathML specification, the children of <msqrt> are wrapped in an inferred <mrow>, which is the desired base.
LayoutUnit baseAscent, baseDescent;
recomputeLogicalWidth();
if (m_kind == SquareRoot) {
baseAscent = baseDescent;
RenderMathMLRow::computeLineVerticalStretch(baseAscent, baseDescent);
RenderMathMLRow::layoutRowItems(baseAscent, baseDescent);
m_baseWidth = logicalWidth();
} else {
getBase().layoutIfNeeded();
m_baseWidth = getBase().logicalWidth();
baseAscent = ascentForChild(getBase());
baseDescent = getBase().logicalHeight() - baseAscent;
getIndex().layoutIfNeeded();
}
// Stretch the radical operator to cover the base height.
// We can then determine the metrics of the radical operator + the base.
m_radicalOperator.stretchTo(style(), baseAscent + baseDescent);
LayoutUnit radicalOperatorHeight = m_radicalOperator.ascent() + m_radicalOperator.descent();
LayoutUnit indexBottomRaise = m_degreeBottomRaisePercent * radicalOperatorHeight;
LayoutUnit radicalAscent = baseAscent + m_verticalGap + m_ruleThickness + m_extraAscender;
LayoutUnit radicalDescent = std::max<LayoutUnit>(baseDescent, radicalOperatorHeight + m_extraAscender - radicalAscent);
LayoutUnit descent = radicalDescent;
LayoutUnit ascent = radicalAscent;
// We set the logical width.
if (m_kind == SquareRoot)
setLogicalWidth(m_radicalOperator.width() + m_baseWidth);
else {
ASSERT(m_kind == RootWithIndex);
setLogicalWidth(m_kernBeforeDegree + getIndex().logicalWidth() + m_kernAfterDegree + m_radicalOperator.width() + m_baseWidth);
}
// For <mroot>, we update the metrics to take into account the index.
LayoutUnit indexAscent, indexDescent;
if (m_kind == RootWithIndex) {
indexAscent = ascentForChild(getIndex());
indexDescent = getIndex().logicalHeight() - indexAscent;
ascent = std::max<LayoutUnit>(radicalAscent, indexBottomRaise + indexDescent + indexAscent - descent);
}
// We set the final position of children.
m_radicalOperatorTop = ascent - radicalAscent + m_extraAscender;
LayoutUnit horizontalOffset = m_radicalOperator.width();
if (m_kind == RootWithIndex)
horizontalOffset += m_kernBeforeDegree + getIndex().logicalWidth() + m_kernAfterDegree;
LayoutPoint baseLocation(mirrorIfNeeded(horizontalOffset, m_baseWidth), ascent - baseAscent);
if (m_kind == SquareRoot) {
for (auto* child = firstChildBox(); child; child = child->nextSiblingBox())
child->setLocation(child->location() + baseLocation);
} else {
ASSERT(m_kind == RootWithIndex);
getBase().setLocation(baseLocation);
LayoutPoint indexLocation(mirrorIfNeeded(m_kernBeforeDegree, getIndex()), ascent + descent - indexBottomRaise - indexDescent - indexAscent);
getIndex().setLocation(indexLocation);
}
setLogicalHeight(ascent + descent);
clearNeedsLayout();
}
void LayoutSVGText::layout()
{
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
subtreeStyleDidChange();
bool updateCachedBoundariesInParents = false;
if (m_needsTransformUpdate) {
m_localTransform = toSVGTextElement(node())->calculateAnimatedLocalTransform();
m_needsTransformUpdate = false;
updateCachedBoundariesInParents = true;
}
if (!everHadLayout()) {
// When laying out initially, collect all layout attributes, build the character data map,
// and propogate resulting SVGLayoutAttributes to all LayoutSVGInlineText children in the subtree.
ASSERT(m_layoutAttributes.isEmpty());
collectLayoutAttributes(this, m_layoutAttributes);
updateFontInAllDescendants(this);
m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(*this);
m_needsReordering = true;
m_needsTextMetricsUpdate = false;
m_needsPositioningValuesUpdate = false;
updateCachedBoundariesInParents = true;
} else if (m_needsPositioningValuesUpdate) {
// When the x/y/dx/dy/rotate lists change, recompute the layout attributes, and eventually
// update the on-screen font objects as well in all descendants.
if (m_needsTextMetricsUpdate) {
updateFontInAllDescendants(this);
m_needsTextMetricsUpdate = false;
}
m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(*this);
m_needsReordering = true;
m_needsPositioningValuesUpdate = false;
updateCachedBoundariesInParents = true;
} else if (m_needsTextMetricsUpdate || SVGLayoutSupport::findTreeRootObject(this)->isLayoutSizeChanged()) {
// If the root layout size changed (eg. window size changes) or the transform to the root
// context has changed then recompute the on-screen font size.
updateFontInAllDescendants(this, &m_layoutAttributesBuilder);
ASSERT(!m_needsReordering);
ASSERT(!m_needsPositioningValuesUpdate);
m_needsTextMetricsUpdate = false;
updateCachedBoundariesInParents = true;
}
checkLayoutAttributesConsistency(this, m_layoutAttributes);
// Reduced version of LayoutBlock::layoutBlock(), which only takes care of SVG text.
// All if branches that could cause early exit in LayoutBlocks layoutBlock() method are turned into assertions.
ASSERT(!isInline());
ASSERT(!simplifiedLayout());
ASSERT(!scrollsOverflow());
ASSERT(!hasControlClip());
ASSERT(!positionedObjects());
ASSERT(!isAnonymousBlock());
if (!firstChild())
setChildrenInline(true);
// FIXME: We need to find a way to only layout the child boxes, if needed.
FloatRect oldBoundaries = objectBoundingBox();
ASSERT(childrenInline());
rebuildFloatsFromIntruding();
LayoutUnit beforeEdge = borderBefore() + paddingBefore();
LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
setLogicalHeight(beforeEdge);
LayoutState state(*this, locationOffset());
LayoutUnit paintInvalidationLogicalTop = 0;
LayoutUnit paintInvalidationLogicalBottom = 0;
layoutInlineChildren(true, paintInvalidationLogicalTop, paintInvalidationLogicalBottom, afterEdge);
if (m_needsReordering)
m_needsReordering = false;
// If we don't have any line boxes, then make sure the frame rect is still cleared.
if (!firstLineBox())
setFrameRect(LayoutRect());
m_overflow.clear();
addVisualEffectOverflow();
if (!updateCachedBoundariesInParents)
updateCachedBoundariesInParents = oldBoundaries != objectBoundingBox();
// Invalidate all resources of this client if our layout changed.
if (everHadLayout() && selfNeedsLayout())
SVGResourcesCache::clientLayoutChanged(this);
// If our bounds changed, notify the parents.
if (updateCachedBoundariesInParents)
LayoutSVGBlock::setNeedsBoundariesUpdate();
clearNeedsLayout();
}