void RenderMathMLRow::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty() && needsLayout());
computeChildrenPreferredLogicalHeights();
int stretchLogicalHeight = 0;
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isRenderMathMLBlock()) {
RenderMathMLOperator* renderMo = toRenderMathMLBlock(child)->unembellishedOperator();
// FIXME: Only skip renderMo if it is stretchy.
if (renderMo)
continue;
}
stretchLogicalHeight = max<int>(stretchLogicalHeight, roundToInt(preferredLogicalHeightAfterSizing(child)));
}
if (!stretchLogicalHeight)
stretchLogicalHeight = style()->fontSize();
// Set the sizes of (possibly embellished) stretchy operator children.
for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
if (child->isRenderMathMLBlock()) {
RenderMathMLOperator* renderMo = toRenderMathMLBlock(child)->unembellishedOperator();
if (renderMo)
renderMo->stretchToHeight(stretchLogicalHeight);
}
}
RenderMathMLBlock::computePreferredLogicalWidths();
// Shrink our logical width to its probable value now without triggering unnecessary relayout of our children.
ASSERT(needsLayout() && logicalWidth() >= maxPreferredLogicalWidth());
setLogicalWidth(maxPreferredLogicalWidth());
}
RenderMathMLOperator* RenderMathMLFenced::createMathMLOperator(UChar uChar)
{
RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
newStyle->setFlexDirection(FlowColumn);
newStyle->setPaddingRight(Length(static_cast<int>(gOperatorPadding * style()->fontSize()), Fixed));
RenderMathMLOperator* newOperator = new (renderArena()) RenderMathMLOperator(node() /* "almost anonymous" */, uChar);
newOperator->setStyle(newStyle.release());
return newOperator;
}
void RenderMathMLFenced::makeFences()
{
RenderMathMLOperator* openFence = createMathMLOperator(m_open, RenderMathMLOperator::Fence);
RenderMathMLRow::addChild(openFence, firstChild());
m_closeFenceRenderer = createMathMLOperator(m_close, RenderMathMLOperator::Fence);
RenderMathMLRow::addChild(m_closeFenceRenderer);
openFence->updateFromElement();
m_closeFenceRenderer->updateFromElement();
}
RenderMathMLOperator* RenderMathMLFenced::createMathMLOperator(UChar uChar, RenderMathMLOperator::OperatorType operatorType)
{
RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
newStyle->setFlexDirection(FlowColumn);
newStyle->setMarginEnd(Length((operatorType == RenderMathMLOperator::Fence ? gFenceMarginEms : gSeparatorMarginEndEms) * style()->fontSize(), Fixed));
if (operatorType == RenderMathMLOperator::Fence)
newStyle->setMarginStart(Length(gFenceMarginEms * style()->fontSize(), Fixed));
RenderMathMLOperator* newOperator = new (renderArena()) RenderMathMLOperator(toElement(node()), uChar);
newOperator->setOperatorType(operatorType);
newOperator->setStyle(newStyle.release());
return newOperator;
}
RenderMathMLOperator* RenderMathMLFenced::createMathMLOperator(UChar uChar, RenderMathMLOperator::OperatorType operatorType)
{
auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
newStyle.get().setFlexDirection(FlowColumn);
newStyle.get().setMarginEnd(Length((operatorType == RenderMathMLOperator::Fence ? gFenceMarginEms : gSeparatorMarginEndEms) * style()->fontSize(), Fixed));
if (operatorType == RenderMathMLOperator::Fence)
newStyle.get().setMarginStart(Length(gFenceMarginEms * style()->fontSize(), Fixed));
RenderMathMLOperator* newOperator = new RenderMathMLOperator(element(), uChar);
newOperator->setOperatorType(operatorType);
newOperator->setStyle(std::move(newStyle));
return newOperator;
}
void RenderMathMLFenced::makeFences()
{
RenderPtr<RenderMathMLOperator> openFence = createMathMLOperator(m_open, MathMLOperatorDictionary::Prefix, MathMLOperatorDictionary::Fence);
RenderMathMLOperator* openFencePtr = openFence.get();
RenderMathMLRow::addChild(openFence.leakPtr(), firstChild());
RenderPtr<RenderMathMLOperator> closeFence = createMathMLOperator(m_close, MathMLOperatorDictionary::Postfix, MathMLOperatorDictionary::Fence);
m_closeFenceRenderer = closeFence.get();
RenderMathMLRow::addChild(closeFence.leakPtr());
openFencePtr->updateFromElement();
m_closeFenceRenderer->updateFromElement();
}
void RenderMathMLRow::layout()
{
RenderBlock::layout();
// Calculate the maximum height of the row without the operators.
int maxHeight = nonOperatorHeight();
// Set the maximum height of the row for intermediate layouts.
style()->setHeight(Length(maxHeight, Fixed));
// Notify contained operators they may need to re-layout their stretched operators.
// We need to keep track of the number of children and operators because a row of
// operators needs some special handling.
int childCount = 0;
int operatorCount = 0;
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
childCount++;
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
block->stretchToHeight(maxHeight);
if (block->isRenderMathMLOperator())
operatorCount++;
}
}
// Layout the non-operators which have just been stretched.
setNeedsLayoutAndPrefWidthsRecalc();
markContainingBlocksForLayout();
RenderBlock::layout();
// Make a second pass with the real height of the operators.
int operatorHeight = 0;
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
if (!block->hasBase() && !block->isRenderMathMLOperator()) {
// Check to see if this box has a larger height.
if (block->offsetHeight() > maxHeight)
maxHeight = block->offsetHeight();
}
if (block->isRenderMathMLOperator())
if (block->offsetHeight() > operatorHeight)
operatorHeight = block->offsetHeight();
} else if (current->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(current);
// Check to see if this box has a larger height.
if (box->offsetHeight() > maxHeight)
maxHeight = box->offsetHeight();
}
}
if (childCount > 0 && childCount == operatorCount) {
// We have only operators and so set the max height to the operator height.
maxHeight = operatorHeight;
}
int stretchHeight = maxHeight;
// Stretch the operators again and re-calculate the row height.
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
if (block->isRenderMathMLOperator()) {
RenderMathMLOperator* mathop = toRenderMathMLOperator(block);
mathop->stretchToHeight(stretchHeight);
} else {
block->stretchToHeight(stretchHeight);
RenderBoxModelObject* box = toRenderBoxModelObject(current);
// Check to see if this box has a larger height
if (box->offsetHeight() > maxHeight)
maxHeight = box->offsetHeight();
}
} else if (current->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(current);
// Check to see if this box has a larger height
if (box->offsetHeight() > maxHeight)
maxHeight = box->offsetHeight();
}
}
// Set the maximum height of the row based on the calculations.
style()->setHeight(Length(maxHeight, Fixed));
// Do the final layout by calling our parent's layout again.
setNeedsLayoutAndPrefWidthsRecalc();
markContainingBlocksForLayout();
RenderBlock::layout();
}
