void RenderMathMLSquareRoot::layout()
{
int maxHeight = 0;
RenderObject* current = firstChild();
while (current) {
if (current->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(current);
if (box->offsetHeight() > maxHeight)
maxHeight = box->offsetHeight();
box->style()->setVerticalAlign(BASELINE);
}
current = current->nextSibling();
}
if (!maxHeight)
maxHeight = style()->fontSize();
if (maxHeight > static_cast<int>(gThresholdBaseHeight * style()->fontSize()))
style()->setPaddingBottom(Length(static_cast<int>(gRootBottomPadding * style()->fontSize()), Fixed));
RenderBlock::layout();
}
void RenderMathMLRow::layout()
{
RenderBlock::layout();
LayoutUnit maxHeight = 0;
int childCount = 0;
int operatorCount = 0;
// Calculate the non-operator max height of the row.
LayoutUnit operatorHeight = 0;
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
childCount++;
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
// Check to see if the non-operator block has a greater height.
if (!block->hasBase() && !block->isRenderMathMLOperator() && block->offsetHeight() > maxHeight)
maxHeight = block->offsetHeight();
if (block->hasBase() && block->nonOperatorHeight() > maxHeight)
maxHeight = block->nonOperatorHeight();
// If the block is an operator, capture the maximum height and increment the count.
if (block->isRenderMathMLOperator()) {
if (block->offsetHeight() > operatorHeight)
operatorHeight = block->offsetHeight();
operatorCount++;
}
} 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;
}
// Stretch everything to the same height (blocks can ignore the request).
if (maxHeight > 0) {
bool didStretch = false;
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
block->stretchToHeight(maxHeight);
didStretch = true;
}
}
if (didStretch) {
setNeedsLayout(true);
setPreferredLogicalWidthsDirty(true, false);
RenderBlock::layout();
}
}
}
int RenderMathMLSubSup::baselinePosition(bool firstLine, bool isRootLineBox) const
{
RenderObject* base = firstChild();
if (!base)
return offsetHeight();
base = base->firstChild();
if (!base)
return offsetHeight();
int baseline = offsetHeight();
switch (m_kind) {
case SubSup:
if (m_scripts) {
int topAdjust = 0;
if (base->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(base);
topAdjust = (m_scripts->offsetHeight() - box->offsetHeight()) / 2;
}
return topAdjust + (base ? base->baselinePosition(firstLine, isRootLineBox) : 0) + 4;
}
break;
case Sup:
if (base) {
baseline = base->baselinePosition(firstLine, isRootLineBox) + 4;
// FIXME: The extra amount of the superscript ascending above the base's box
// isn't taken into account. This should be calculated in a more reliable
// way.
RenderObject* sup = base->nextSibling();
if (sup && sup->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(sup);
// we'll take half of the sup's box height into account in the baseline
baseline += static_cast<int>(box->offsetHeight() * 0.5);
}
baseline++;
}
break;
case Sub:
if (base)
baseline = base->baselinePosition(true) + 4;
}
return baseline;
}
inline int getOffsetHeight(RenderObject* obj)
{
if (obj->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(obj);
return box->offsetHeight();
}
return 0;
}
void RenderMathMLRoot::layout()
{
RenderBlock::layout();
if (!firstChild() || !lastChild())
return;
int maxHeight = toRenderBoxModelObject(lastChild())->offsetHeight();
RenderObject* current = lastChild()->firstChild();
if (current)
current->style()->setVerticalAlign(BASELINE);
if (!maxHeight)
maxHeight = style()->fontSize();
// Base height above which the shape of the root changes
int thresholdHeight = static_cast<int>(gThresholdBaseHeight * style()->fontSize());
int topStartShift = 0;
if (maxHeight > thresholdHeight && thresholdHeight) {
float shift = (maxHeight - thresholdHeight) / static_cast<float>(thresholdHeight);
if (shift > 1.)
shift = 1.0f;
int frontWidth = static_cast<int>(style()->fontSize() * gRadicalWidth);
topStartShift = static_cast<int>(gRadicalBottomPointXPos * frontWidth * shift);
style()->setPaddingBottom(Length(static_cast<int>(gRootBottomPadding * style()->fontSize()), Fixed));
}
// Positioning of the index
RenderObject* possibleIndex = firstChild()->firstChild();
while (possibleIndex && !possibleIndex->isBoxModelObject())
possibleIndex = possibleIndex->nextSibling();
RenderBoxModelObject* indexBox = toRenderBoxModelObject(possibleIndex);
if (!indexBox)
return;
int indexShift = indexBox->offsetWidth() + topStartShift;
int radicalHeight = static_cast<int>((1 - gRadicalTopLeftPointYPos) * maxHeight);
int rootMarginTop = radicalHeight + style()->paddingBottom().value() + indexBox->offsetHeight() - (maxHeight + static_cast<int>(gRootPadding * style()->fontSize()));
style()->setPaddingLeft(Length(indexShift, Fixed));
if (rootMarginTop > 0)
style()->setPaddingTop(Length(rootMarginTop + static_cast<int>(gRootPadding * style()->fontSize()), Fixed));
setNeedsLayout(true);
setPreferredLogicalWidthsDirty(true, false);
RenderBlock::layout();
indexBox->style()->setBottom(Length(radicalHeight + style()->paddingBottom().value(), Fixed));
// Now that we've potentially changed its position, we need layout the index again.
indexBox->setNeedsLayout(true);
indexBox->layout();
}
int RenderMathMLRow::nonOperatorHeight() const
{
int maxHeight = 0;
for (RenderObject* current = firstChild(); current; current = current->nextSibling()) {
if (current->isRenderMathMLBlock()) {
RenderMathMLBlock* block = toRenderMathMLBlock(current);
int blockHeight = block->nonOperatorHeight();
// Check to see if this box has a larger height
if (blockHeight > maxHeight)
maxHeight = blockHeight;
} 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();
}
}
return maxHeight;
}
void RenderMathMLRoot::paint(PaintInfo& info, int tx, int ty)
{
RenderMathMLBlock::paint(info , tx , ty);
if (info.context->paintingDisabled())
return;
if (!firstChild() || !lastChild())
return;
tx += x();
ty += y();
RenderBoxModelObject* indexBox = toRenderBoxModelObject(lastChild());
int maxHeight = indexBox->offsetHeight();
// default to the font size in pixels if we're empty
if (!maxHeight)
maxHeight = style()->fontSize();
int width = indexBox->offsetWidth();
int indexWidth = 0;
RenderObject* current = firstChild();
while (current != lastChild()) {
if (current->isBoxModelObject()) {
RenderBoxModelObject* box = toRenderBoxModelObject(current);
indexWidth += box->offsetWidth();
}
current = current->nextSibling();
}
int frontWidth = static_cast<int>(style()->fontSize() * gRadicalWidth);
int topStartShift = 0;
// Base height above which the shape of the root changes
int thresholdHeight = static_cast<int>(gThresholdBaseHeight * style()->fontSize());
if (maxHeight > thresholdHeight && thresholdHeight) {
float shift = (maxHeight - thresholdHeight) / static_cast<float>(thresholdHeight);
if (shift > 1.)
shift = 1.0f;
topStartShift = static_cast<int>(gRadicalBottomPointXPos * frontWidth * shift);
}
width += topStartShift;
int rootPad = static_cast<int>(gRootPadding * style()->fontSize());
int start = tx + indexWidth + gRadicalLeftMargin + style()->paddingLeft().value() - rootPad;
ty += style()->paddingTop().value() - rootPad;
FloatPoint topStart(start - topStartShift, ty);
FloatPoint bottomLeft(start - gRadicalBottomPointXPos * frontWidth , ty + maxHeight + gRadicalBasePad);
FloatPoint topLeft(start - gRadicalTopLeftPointXPos * frontWidth , ty + gRadicalTopLeftPointYPos * maxHeight);
FloatPoint leftEnd(start - frontWidth , topLeft.y() + gRadicalLeftEndYShift * style()->fontSize());
info.context->save();
info.context->setStrokeThickness(gRadicalLineThickness * style()->fontSize());
info.context->setStrokeStyle(SolidStroke);
info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
info.context->setLineJoin(MiterJoin);
info.context->setMiterLimit(style()->fontSize());
Path root;
root.moveTo(FloatPoint(topStart.x() + width, ty));
// draw top
root.addLineTo(topStart);
// draw from top left corner to bottom point of radical
root.addLineTo(bottomLeft);
// draw from bottom point to top of left part of radical base "pocket"
root.addLineTo(topLeft);
// draw to end
root.addLineTo(leftEnd);
info.context->strokePath(root);
info.context->save();
// Build a mask to draw the thick part of the root.
Path mask;
mask.moveTo(topStart);
mask.addLineTo(bottomLeft);
mask.addLineTo(topLeft);
mask.addLineTo(FloatPoint(2 * topLeft.x() - leftEnd.x(), 2 * topLeft.y() - leftEnd.y()));
info.context->clip(mask);
// Draw the thick part of the root.
info.context->setStrokeThickness(gRadicalThickLineThickness * style()->fontSize());
info.context->setLineCap(SquareCap);
Path line;
line.moveTo(bottomLeft);
line.addLineTo(topLeft);
info.context->strokePath(line);
info.context->restore();
info.context->restore();
}
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();
}
