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();
}
void RenderImageControlsButton::updateLogicalWidth()
{
RenderBox::updateLogicalWidth();
IntSize frameSize = theme().imageControlsButtonSize(*this);
setLogicalWidth(isHorizontalWritingMode() ? frameSize.width() : frameSize.height());
}
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 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 RenderFlowThread::updateLogicalWidth()
{
LayoutUnit logicalWidth = 0;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
ASSERT(!region->needsLayout());
logicalWidth = max(region->pageLogicalWidth(), logicalWidth);
}
setLogicalWidth(logicalWidth);
// If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
if (regionLogicalWidth != logicalWidth) {
LayoutUnit logicalLeft = style()->direction() == LTR ? ZERO_LAYOUT_UNIT : logicalWidth - regionLogicalWidth;
region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);
}
}
}
void RenderFlowThread::computeLogicalWidth()
{
LayoutUnit logicalWidth = 0;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
ASSERT(!region->needsLayout());
logicalWidth = max(isHorizontalWritingMode() ? region->contentWidth() : region->contentHeight(), logicalWidth);
}
setLogicalWidth(logicalWidth);
// If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->isValid())
continue;
LayoutUnit regionLogicalWidth = isHorizontalWritingMode() ? region->contentWidth() : region->contentHeight();
if (regionLogicalWidth != logicalWidth) {
LayoutUnit logicalLeft = style()->direction() == LTR ? zeroLayoutUnit : logicalWidth - regionLogicalWidth;
region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);
}
}
}
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 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 RenderMultiColumnSet::updateLogicalWidth()
{
RenderBlockFlow* parentBlock = toRenderBlockFlow(parent());
setComputedColumnWidthAndCount(parentBlock->multiColumnFlowThread()->columnWidth(), parentBlock->multiColumnFlowThread()->columnCount()); // FIXME: This will eventually vary if we are contained inside regions.
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
}
void RenderImageControls::updateLogicalWidth()
{
RenderBox::updateLogicalWidth();
RenderElement* renderer = element()->shadowHost()->renderer();
if (!is<RenderImage>(*renderer))
return;
setLogicalWidth(downcast<RenderImage>(*renderer).logicalWidth());
}
void RenderMultiColumnSet::computeLogicalWidth()
{
// Our logical width starts off matching the column block itself.
// This width will be fixed up after the flow thread lays out once it is determined exactly how many
// columns we ended up holding.
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnWidthAndCount(parentBlock->columnWidth(), parentBlock->columnCount()); // FIXME: This will eventually vary if we are contained inside regions.
}
void RenderMultiColumnSet::updateLogicalWidth()
{
RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread();
setComputedColumnWidthAndCount(flowThread->columnWidth(), flowThread->columnCount());
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
// If we overflow, increase our logical width.
unsigned colCount = columnCount();
LayoutUnit colGap = columnGap();
LayoutUnit minimumContentLogicalWidth = colCount * computedColumnWidth() + (colCount - 1) * colGap;
LayoutUnit currentContentLogicalWidth = contentLogicalWidth();
LayoutUnit delta = max(LayoutUnit(), minimumContentLogicalWidth - currentContentLogicalWidth);
if (!delta)
return;
// Increase our logical width by the delta.
setLogicalWidth(logicalWidth() + delta);
}
void RenderMultiColumnSet::updateLogicalWidth()
{
RenderMultiColumnBlock* parentBlock = toRenderMultiColumnBlock(parent());
setComputedColumnWidthAndCount(parentBlock->columnWidth(), parentBlock->columnCount()); // FIXME: This will eventually vary if we are contained inside regions.
// FIXME: When we add regions support, we'll start it off at the width of the multi-column
// block in that particular region.
setLogicalWidth(parentBox()->contentLogicalWidth());
// If we overflow, increase our logical width.
unsigned colCount = columnCount();
if (!colCount)
return;
LayoutUnit colGap = columnGap();
LayoutUnit minimumContentLogicalWidth = colCount * computedColumnWidth() + (colCount - 1) * colGap;
LayoutUnit currentContentLogicalWidth = contentLogicalWidth();
LayoutUnit delta = max(LayoutUnit(), minimumContentLogicalWidth - currentContentLogicalWidth);
if (!delta)
return;
// Increase our logical width by the delta.
setLogicalWidth(logicalWidth() + delta);
}
void RenderMathMLRoot::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty() && needsLayout());
#ifndef NDEBUG
// FIXME: Remove this once mathml stops modifying the render tree here.
SetLayoutNeededForbiddenScope layoutForbiddenScope(this, false);
#endif
computeChildrenPreferredLogicalHeights();
int baseHeight = firstChild() ? roundToInt(preferredLogicalHeightAfterSizing(firstChild())) : style()->fontSize();
int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
// Base height above which the shape of the root changes
float thresholdHeight = gThresholdBaseHeightEms * style()->fontSize();
if (baseHeight > thresholdHeight && thresholdHeight) {
float shift = min<float>((baseHeight - thresholdHeight) / thresholdHeight, 1.0f);
m_overbarLeftPointShift = static_cast<int>(shift * gRadicalBottomPointXFront * frontWidth);
m_intrinsicPaddingAfter = lroundf(gBigRootBottomPaddingEms * style()->fontSize());
} else {
m_overbarLeftPointShift = 0;
m_intrinsicPaddingAfter = 0;
}
int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
m_intrinsicPaddingBefore = rootPad;
m_indexTop = 0;
if (RenderBoxModelObject* index = this->index()) {
m_intrinsicPaddingStart = roundToInt(index->maxPreferredLogicalWidth()) + m_overbarLeftPointShift;
int indexHeight = roundToInt(preferredLogicalHeightAfterSizing(index));
int partDipHeight = lroundf((1 - gRootRadicalDipLeftPointYPos) * baseHeight);
int rootExtraTop = partDipHeight + indexHeight - (baseHeight + rootPad);
if (rootExtraTop > 0)
m_intrinsicPaddingBefore += rootExtraTop;
else
m_indexTop = - rootExtraTop;
} else
m_intrinsicPaddingStart = frontWidth;
RenderMathMLBlock::computePreferredLogicalWidths();
// Shrink our logical width to its probable value now without triggering unnecessary relayout of our children.
ASSERT(needsLayout() && logicalWidth() >= maxPreferredLogicalWidth());
setLogicalWidth(maxPreferredLogicalWidth());
}
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 RenderMultiColumnSet::setFlowThreadPortionRect(const LayoutRect& rect)
{
RenderRegion::setFlowThreadPortionRect(rect);
// Mutate the dimensions of the column set once our flow portion is set if the flow portion has more columns
// than can fit inside our current dimensions.
unsigned colCount = columnCount();
if (!colCount)
return;
LayoutUnit colGap = columnGap();
LayoutUnit minimumContentLogicalWidth = colCount * computedColumnWidth() + (colCount - 1) * colGap;
LayoutUnit currentContentLogicalWidth = contentLogicalWidth();
LayoutUnit delta = max(LayoutUnit(), minimumContentLogicalWidth - currentContentLogicalWidth);
if (!delta)
return;
// Increase our logical width by the delta.
setLogicalWidth(logicalWidth() + delta);
// Shift our position left by the delta if we are RTL.
if (!style()->isLeftToRightDirection())
setLogicalLeft(logicalLeft() - delta);
}
void RenderView::updateLogicalWidth()
{
if (m_frameView)
setLogicalWidth(viewLogicalWidth());
}
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 RenderView::updateLogicalWidth()
{
setLogicalWidth(viewLogicalWidth());
}
void RenderView::updateLogicalWidth()
{
if (!shouldUsePrintingLayout())
setLogicalWidth(viewLogicalWidth());
}
void RenderView::computeLogicalWidth()
{
if (!shouldUsePrintingLayout() && m_frameView)
setLogicalWidth(viewLogicalWidth());
}
void LayoutMultiColumnFlowThread::updateLogicalWidth()
{
LayoutUnit columnWidth;
calculateColumnCountAndWidth(columnWidth, m_columnCount);
setLogicalWidth(columnWidth);
}
void RenderView::computeLogicalWidth()
{
if (!printing() && m_frameView)
setLogicalWidth(viewLogicalWidth());
}
