void RenderMathMLFraction::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
if (!isValid()) {
setLogicalWidth(0);
setLogicalHeight(0);
clearNeedsLayout();
return;
}
numerator().layoutIfNeeded();
denominator().layoutIfNeeded();
setLogicalWidth(std::max(numerator().logicalWidth(), denominator().logicalWidth()));
updateLineThickness();
LayoutUnit verticalOffset = 0; // This is the top of the renderer.
LayoutPoint numeratorLocation(horizontalOffset(numerator(), element().numeratorAlignment()), verticalOffset);
numerator().setLocation(numeratorLocation);
LayoutUnit numeratorAscent = ascentForChild(numerator());
LayoutUnit numeratorDescent = numerator().logicalHeight() - numeratorAscent;
LayoutUnit denominatorAscent = ascentForChild(denominator());
LayoutUnit denominatorDescent = denominator().logicalHeight() - denominatorAscent;
if (isStack()) {
LayoutUnit gapMin, topShiftUp, bottomShiftDown;
getStackParameters(gapMin, topShiftUp, bottomShiftDown);
LayoutUnit gap = topShiftUp - numeratorDescent + bottomShiftDown - denominatorAscent;
if (gap < gapMin) {
// If the gap is not large enough, we increase the shifts by the same value.
LayoutUnit delta = (gapMin - gap) / 2;
topShiftUp += delta;
bottomShiftDown += delta;
}
verticalOffset += numeratorAscent + topShiftUp; // This is the middle of the stack gap.
m_ascent = verticalOffset + mathAxisHeight();
verticalOffset += bottomShiftDown - denominatorAscent;
} else {
LayoutUnit numeratorGapMin, denominatorGapMin, numeratorMinShiftUp, denominatorMinShiftDown;
getFractionParameters(numeratorGapMin, denominatorGapMin, numeratorMinShiftUp, denominatorMinShiftDown);
verticalOffset += std::max(numerator().logicalHeight() + numeratorGapMin + m_lineThickness / 2, numeratorAscent + numeratorMinShiftUp); // This is the middle of the fraction bar.
m_ascent = verticalOffset + mathAxisHeight();
verticalOffset += std::max(m_lineThickness / 2 + denominatorGapMin, denominatorMinShiftDown - denominatorAscent);
}
LayoutPoint denominatorLocation(horizontalOffset(denominator(), element().denominatorAlignment()), verticalOffset);
denominator().setLocation(denominatorLocation);
verticalOffset = std::max(verticalOffset + denominator().logicalHeight(), m_ascent + denominatorDescent); // This is the bottom of our renderer.
setLogicalHeight(verticalOffset);
clearNeedsLayout();
}
inline void RenderBlockFlow::layoutBlockFlow(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
{
LayoutUnit oldLeft = logicalLeft();
bool logicalWidthChanged = updateLogicalWidthAndColumnWidth();
relayoutChildren |= logicalWidthChanged;
LayoutState state(*this, locationOffset(), logicalWidthChanged);
LayoutUnit beforeEdge = borderBefore() + paddingBefore();
LayoutUnit afterEdge = borderAfter() + paddingAfter();
LayoutUnit previousHeight = logicalHeight();
setLogicalHeight(beforeEdge);
m_paintInvalidationLogicalTop = 0;
m_paintInvalidationLogicalBottom = 0;
if (!firstChild() && !isAnonymousBlock())
setChildrenInline(true);
if (childrenInline())
layoutInlineChildren(relayoutChildren, m_paintInvalidationLogicalTop, m_paintInvalidationLogicalBottom, afterEdge);
else
layoutBlockChildren(relayoutChildren, layoutScope, beforeEdge, afterEdge);
LayoutUnit oldClientAfterEdge = clientLogicalBottom();
updateLogicalHeight();
if (previousHeight != logicalHeight())
relayoutChildren = true;
layoutPositionedObjects(relayoutChildren || isDocumentElement(), oldLeft != logicalLeft() ? ForcedLayoutAfterContainingBlockMoved : DefaultLayout);
// Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).
computeOverflow(oldClientAfterEdge);
}
void RenderBlockFlow::layoutBlockChildren(bool relayoutChildren, SubtreeLayoutScope& layoutScope, LayoutUnit beforeEdge, LayoutUnit afterEdge)
{
dirtyForLayoutFromPercentageHeightDescendants(layoutScope);
RenderBox* next = firstChildBox();
RenderBox* lastNormalFlowChild = 0;
while (next) {
RenderBox* child = next;
next = child->nextSiblingBox();
// FIXME: this should only be set from clearNeedsLayout crbug.com/361250
child->setLayoutDidGetCalled(true);
updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, child);
if (child->isOutOfFlowPositioned()) {
child->containingBlock()->insertPositionedObject(child);
adjustPositionedBlock(child);
continue;
}
// Lay out the child.
layoutBlockChild(child);
lastNormalFlowChild = child;
}
// Negative margins can cause our height to shrink below our minimal height (border/padding).
// If this happens, ensure that the computed height is increased to the minimal height.
setLogicalHeight(std::max(logicalHeight() + afterEdge, beforeEdge + afterEdge));
}
void LayoutListMarker::layout()
{
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
if (isImage()) {
updateMarginsAndContent();
LayoutSize imageSize(imageBulletSize());
setWidth(imageSize.width());
setHeight(imageSize.height());
} else {
setLogicalWidth(minPreferredLogicalWidth());
setLogicalHeight(style()->fontMetrics().height());
}
setMarginStart(0);
setMarginEnd(0);
Length startMargin = style()->marginStart();
Length endMargin = style()->marginEnd();
if (startMargin.isFixed())
setMarginStart(startMargin.value());
if (endMargin.isFixed())
setMarginEnd(endMargin.value());
clearNeedsLayout();
}
void SVGRootInlineBox::layoutRootBox(const FloatRect& childRect)
{
RenderBlock* parentBlock = block();
ASSERT(parentBlock);
// Finally, assign the root block position, now that all content is laid out.
LayoutRect boundingRect = enclosingLayoutRect(childRect);
parentBlock->setLocation(boundingRect.location());
parentBlock->setSize(boundingRect.size());
// Position all children relative to the parent block.
for (InlineBox* child = firstChild(); child; child = child->nextOnLine()) {
// Skip generated content.
if (!child->renderer()->node())
continue;
child->adjustPosition(-childRect.x(), -childRect.y());
}
// Position ourselves.
setX(0);
setY(0);
setLogicalWidth(childRect.width());
setLogicalHeight(childRect.height());
setLineTopBottomPositions(0, boundingRect.height(), 0, boundingRect.height());
}
void RenderMathMLPadded::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
// We first layout our children as a normal <mrow> element.
LayoutUnit contentAscent, contentDescent, contentWidth;
contentAscent = contentDescent = 0;
RenderMathMLRow::computeLineVerticalStretch(contentAscent, contentDescent);
RenderMathMLRow::layoutRowItems(contentAscent, contentDescent);
contentWidth = logicalWidth();
// We parse the mpadded attributes using the content metrics as the default value.
LayoutUnit width = contentWidth;
LayoutUnit ascent = contentAscent;
LayoutUnit descent = contentDescent;
LayoutUnit lspace = 0;
LayoutUnit voffset = 0;
resolveAttributes(width, ascent, descent, lspace, voffset);
// Align children on the new baseline and shift them by (lspace, -voffset)
LayoutPoint contentLocation(lspace, ascent - contentAscent - voffset);
for (auto* child = firstChildBox(); child; child = child->nextSiblingBox())
child->setLocation(child->location() + contentLocation);
// Set the final metrics.
setLogicalWidth(width);
m_ascent = ascent;
setLogicalHeight(ascent + descent);
clearNeedsLayout();
}
void LayoutListMarker::layout() {
ASSERT(needsLayout());
LayoutAnalyzer::Scope analyzer(*this);
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 RenderRegion::updateLogicalHeight()
{
RenderBlock::updateLogicalHeight();
if (!hasAutoLogicalHeight())
return;
// We want to update the logical height based on the computed override logical
// content height only if the view is in the layout phase
// in which all the auto logical height regions have their override logical height set.
if (!m_flowThread->inConstrainedLayoutPhase())
return;
// There may be regions with auto logical height that during the prerequisite layout phase
// did not have the chance to layout flow thread content. Because of that, these regions do not
// have an overrideLogicalContentHeight computed and they will not be able to fragment any flow
// thread content.
if (!hasOverrideHeight())
return;
LayoutUnit newLogicalHeight = overrideLogicalContentHeight() + borderAndPaddingLogicalHeight();
ASSERT(newLogicalHeight < LayoutUnit::max() / 2);
if (newLogicalHeight > logicalHeight())
setLogicalHeight(newLogicalHeight);
}
void RenderNamedFlowFragment::updateLogicalHeight()
{
RenderRegion::updateLogicalHeight();
if (!hasAutoLogicalHeight())
return;
// We want to update the logical height based on the computed auto-height
// only after the measure cotnent layout phase when all the
// auto logical height regions have a computed auto-height.
if (m_flowThread->inMeasureContentLayoutPhase())
return;
// There may be regions with auto logical height that during the prerequisite layout phase
// did not have the chance to layout flow thread content. Because of that, these regions do not
// have a computedAutoHeight and they will not be able to fragment any flow
// thread content.
if (!hasComputedAutoHeight())
return;
LayoutUnit newLogicalHeight = computedAutoHeight() + borderAndPaddingLogicalHeight();
ASSERT(newLogicalHeight < RenderFlowThread::maxLogicalHeight());
if (newLogicalHeight > logicalHeight()) {
setLogicalHeight(newLogicalHeight);
// Recalculate position of the render block after new logical height is set.
// (needed in absolute positioning case with bottom alignment for example)
RenderRegion::updateLogicalHeight();
}
}
void RenderMultiColumnBlock::checkForPaginationLogicalHeightChange(LayoutUnit& /*pageLogicalHeight*/, bool& /*pageLogicalHeightChanged*/, bool& /*hasSpecifiedPageLogicalHeight*/)
{
// We don't actually update any of the variables. We just subclassed to adjust our column height.
updateLogicalHeight();
m_columnHeightAvailable = max<LayoutUnit>(contentLogicalHeight(), 0);
setLogicalHeight(0);
}
void RenderMultiColumnSet::computeLogicalHeight()
{
// Make sure our column height is up to date.
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnHeight(parentBlock->columnHeight()); // FIXME: Once we make more than one column set, this will become variable.
// Our logical height is always just the height of our columns.
setLogicalHeight(computedColumnHeight());
}
void RenderBlockFlow::layoutBlockChild(RenderBox* child)
{
child->computeAndSetBlockDirectionMargins(this);
LayoutUnit marginBefore = marginBeforeForChild(child);
child->setY(logicalHeight() + marginBefore);
child->layoutIfNeeded();
determineLogicalLeftPositionForChild(child);
setLogicalHeight(logicalHeight() + marginBefore + logicalHeightForChild(child) + marginAfterForChild(child));
}
void RenderGrid::layoutGridItems()
{
Vector<GridTrack> columnTracks(maximumIndexInDirection(ForColumns));
Vector<GridTrack> rowTracks(maximumIndexInDirection(ForRows));
computedUsedBreadthOfGridTracks(ForColumns, columnTracks, rowTracks);
ASSERT(tracksAreWiderThanMinTrackBreadth(ForColumns, columnTracks));
computedUsedBreadthOfGridTracks(ForRows, columnTracks, rowTracks);
ASSERT(tracksAreWiderThanMinTrackBreadth(ForRows, rowTracks));
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
LayoutPoint childPosition = findChildLogicalPosition(child, columnTracks, rowTracks);
size_t columnTrack = resolveGridPosition(child->style()->gridItemColumn());
size_t rowTrack = resolveGridPosition(child->style()->gridItemRow());
// Because the grid area cannot be styled, we don't need to adjust
// the grid breadth to account for 'box-sizing'.
LayoutUnit oldOverrideContainingBlockContentLogicalWidth = child->hasOverrideContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWidth() : LayoutUnit();
LayoutUnit oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
if (oldOverrideContainingBlockContentLogicalWidth != columnTracks[columnTrack].m_usedBreadth || oldOverrideContainingBlockContentLogicalHeight != rowTracks[rowTrack].m_usedBreadth)
child->setNeedsLayout(true, MarkOnlyThis);
child->setOverrideContainingBlockContentLogicalWidth(columnTracks[columnTrack].m_usedBreadth);
child->setOverrideContainingBlockContentLogicalHeight(rowTracks[rowTrack].m_usedBreadth);
// FIXME: Grid items should stretch to fill their cells. Once we
// implement grid-{column,row}-align, we can also shrink to fit. For
// now, just size as if we were a regular child.
child->layoutIfNeeded();
// FIXME: Handle border & padding on the grid element.
child->setLogicalLocation(childPosition);
}
for (size_t i = 0; i < rowTracks.size(); ++i)
setLogicalHeight(logicalHeight() + rowTracks[i].m_usedBreadth);
// FIXME: We should handle min / max logical height.
setLogicalHeight(logicalHeight() + borderAndPaddingLogicalHeight());
}
void RenderMultiColumnSet::updateLogicalHeight()
{
// FIXME: This is the only class that overrides updateLogicalHeight. If we didn't have to set computedColumnHeight,
// we could remove this and make updateLogicalHeight non-virtual. https://bugs.webkit.org/show_bug.cgi?id=96804
// Make sure our column height is up to date.
LogicalExtentComputedValues computedValues;
computeLogicalHeight(0, 0, computedValues);
setComputedColumnHeight(computedValues.m_extent); // FIXME: Once we make more than one column set, this will become variable.
// Our logical height is always just the height of our columns.
setLogicalHeight(computedColumnHeight());
}
void RenderGrid::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
// FIXME: Much of this method is boiler plate that matches RenderBox::layoutBlock and Render*FlexibleBox::layoutBlock.
// It would be nice to refactor some of the duplicate code.
LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
LayoutStateMaintainer statePusher(view(), this, locationOffset(), hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode());
if (inRenderFlowThread()) {
// Regions changing widths can force us to relayout our children.
if (logicalWidthChangedInRegions())
relayoutChildren = true;
}
computeInitialRegionRangeForBlock();
LayoutSize previousSize = size();
setLogicalHeight(0);
computeLogicalWidth();
m_overflow.clear();
layoutGridItems();
LayoutUnit oldClientAfterEdge = clientLogicalBottom();
computeLogicalHeight();
if (size() != previousSize)
relayoutChildren = true;
layoutPositionedObjects(relayoutChildren || isRoot());
computeRegionRangeForBlock();
computeOverflow(oldClientAfterEdge);
statePusher.pop();
updateLayerTransform();
// Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
// we overflow or not.
if (hasOverflowClip())
layer()->updateScrollInfoAfterLayout();
repainter.repaintAfterLayout();
setNeedsLayout(false);
}
void RenderMultiColumnBlock::checkForPaginationLogicalHeightChange(LayoutUnit& /*pageLogicalHeight*/, bool& /*pageLogicalHeightChanged*/, bool& /*hasSpecifiedPageLogicalHeight*/)
{
// We don't actually update any of the variables. We just subclassed to adjust our column height.
updateLogicalHeight();
LayoutUnit newContentLogicalHeight = contentLogicalHeight();
m_requiresBalancing = !newContentLogicalHeight;
if (!m_requiresBalancing) {
// The regions will be invalidated when we lay them out and they change size to
// the new column height.
if (columnHeight() != newContentLogicalHeight)
setColumnHeight(newContentLogicalHeight);
}
setLogicalHeight(0);
}
void RenderFlowThread::computeLogicalHeight()
{
LayoutUnit logicalHeight = 0;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
ASSERT(!region->needsLayout());
logicalHeight += isHorizontalWritingMode() ? region->contentHeight() : region->contentWidth();
}
setLogicalHeight(logicalHeight);
}
void RenderFlowThread::updateLogicalHeight()
{
LayoutUnit logicalHeight = 0;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
ASSERT(!region->needsLayout());
logicalHeight += region->logicalHeightOfAllFlowThreadContent();
}
setLogicalHeight(logicalHeight);
}
void RenderMultiColumnBlock::checkForPaginationLogicalHeightChange(LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight)
{
// We need to go ahead and set our explicit page height if one exists, so that we can
// avoid doing multiple layout passes.
computeLogicalHeight();
LayoutUnit newContentLogicalHeight = contentLogicalHeight();
if (newContentLogicalHeight > ZERO_LAYOUT_UNIT) {
pageLogicalHeight = newContentLogicalHeight;
hasSpecifiedPageLogicalHeight = true;
}
setLogicalHeight(ZERO_LAYOUT_UNIT);
if (columnHeight() != pageLogicalHeight && everHadLayout()) {
setColumnHeight(pageLogicalHeight);
pageLogicalHeightChanged = true;
}
// Set up our column sets.
ensureColumnSets();
}
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 SVGRootInlineBox::layoutRootBox()
{
RenderBlock* parentBlock = block();
ASSERT(parentBlock);
IntRect childRect;
for (InlineBox* child = firstChild(); child; child = child->nextOnLine()) {
// Skip generated content.
if (!child->renderer()->node())
continue;
childRect.unite(child->calculateBoundaries());
}
int xBlock = childRect.x();
int yBlock = childRect.y();
int widthBlock = childRect.width();
int heightBlock = childRect.height();
// Finally, assign the root block position, now that all content is laid out.
parentBlock->setLocation(xBlock, yBlock);
parentBlock->setWidth(widthBlock);
parentBlock->setHeight(heightBlock);
// Position all children relative to the parent block.
for (InlineBox* child = firstChild(); child; child = child->nextOnLine()) {
// Skip generated content.
if (!child->renderer()->node())
continue;
child->adjustPosition(-xBlock, -yBlock);
}
// Position ourselves.
setX(0);
setY(0);
setLogicalWidth(widthBlock);
setLogicalHeight(heightBlock);
setBlockLogicalHeight(heightBlock);
setLineTopBottomPositions(0, heightBlock);
}
void RenderGrid::layoutGridItems()
{
Vector<GridTrack> columnTracks, rowTracks;
computedUsedBreadthOfGridTracks(ForColumns, columnTracks);
// FIXME: The logical width of Grid Columns from the prior step is used in
// the formatting of Grid items in content-sized Grid Rows to determine
// their required height. We will probably need to pass columns through.
computedUsedBreadthOfGridTracks(ForRows, rowTracks);
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
LayoutPoint childPosition = findChildLogicalPosition(child, columnTracks, rowTracks);
// FIXME: Grid items should stretch to fill their cells. Once we
// implement grid-{column,row}-align, we can also shrink to fit. For
// now, just size as if we were a regular child.
child->layoutIfNeeded();
// FIXME: Handle border & padding on the grid element.
child->setLogicalLocation(childPosition);
}
// FIXME: Handle border & padding on the grid element.
for (size_t i = 0; i < rowTracks.size(); ++i)
setLogicalHeight(logicalHeight() + rowTracks[i].m_usedBreadth);
}
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 RenderSVGText::layout()
{
ASSERT(needsLayout());
subtreeStyleDidChange();
LayoutRepainter repainter(*this, SVGRenderSupport::checkForSVGRepaintDuringLayout(this));
bool updateCachedBoundariesInParents = false;
if (m_needsTransformUpdate) {
m_localTransform = toSVGTextElement(node())->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(!hasColumns());
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());
rebuildFloatsFromIntruding();
LayoutUnit beforeEdge = borderBefore() + paddingBefore();
LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
setLogicalHeight(beforeEdge);
LayoutUnit repaintLogicalTop = 0;
LayoutUnit repaintLogicalBottom = 0;
layoutInlineChildren(true, repaintLogicalTop, repaintLogicalBottom, afterEdge);
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 RenderView::computeLogicalHeight()
{
if (!shouldUsePrintingLayout() && m_frameView)
setLogicalHeight(viewLogicalHeight());
}
void RenderView::computeLogicalHeight()
{
if (!printing() && m_frameView)
setLogicalHeight(viewLogicalHeight());
}