RenderMathMLRoot.cpp

@@namespace WebCore {

    

using namespace MathMLNames;

// Left margin of the radical (px)

const int gRadicalLeftMargin = 3;

// Bottom padding of the radical (px)

const int gRadicalBasePad = 3;

// Threshold above which the radical shape is modified to look nice with big bases (%)

const float gThresholdBaseHeight = 1.5f;

// Radical width (%)

const float gRadicalWidth = 0.75f;

// Horizontal position of the bottom point of the radical (%)

const float gRadicalBottomPointXPos= 0.5f;

// Horizontal position of the top left point of the radical (%)

const float gRadicalTopLeftPointXPos = 0.8f;

// Vertical position of the top left point of the radical (%)

const float gRadicalTopLeftPointYPos = 0.625f; 

// Vertical shift of the left end point of the radical (%)

const float gRadicalLeftEndYShift = 0.05f;

// Root padding around the base (%)

const float gRootPadding = 0.2f;

// Additional bottom root padding (%)

const float gRootBottomPadding = 0.2f;

// Radical line thickness (%)

const float gRadicalLineThickness = 0.02f;

// Radical thick line thickness (%)

const float gRadicalThickLineThickness = 0.1f;

// Extra space on the left for the radical sign (px)

const int gRadicalLeftExtra = 3;

// Lower the radical sign's bottom point (px)

const int gRadicalBottomPointLower = 3;

// Threshold above which the radical shape is modified to look nice with big bases (em)

const float gThresholdBaseHeightEms = 1.5f;

// Front width (em)

const float gFrontWidthEms = 0.75f;

// Horizontal position of the bottom point of the radical (* frontWidth)

const float gRadicalBottomPointXFront = 0.5f;

// Horizontal position of the top left point of the radical "dip" (* frontWidth)

const float gRadicalDipLeftPointXFront = 0.8f;

// Vertical position of the top left point of the radical "dip" (* baseHeight)

const float gRadicalDipLeftPointYPos = 0.625f; 

// Vertical shift of the left end point of the radical (em)

const float gRadicalLeftEndYShiftEms = 0.05f;

// Root padding around the base (em) (mroot padding-top/left from mathml.css)

const float gRootPaddingEms = 0.2f;

// Additional bottom root padding if baseHeight > threshold (em)

const float gBigRootBottomPaddingEms = 0.2f;

// Radical line thickness (em)

const float gRadicalLineThicknessEms = 0.02f;

// Radical thick line thickness (em)

const float gRadicalThickLineThicknessEms = 0.1f;

    
RenderMathMLRoot::RenderMathMLRoot(Element* element)

    : RenderMathMLBlock(element)

@@void RenderMathMLRoot::addChild(RenderOb

        // FIXME: the wrapping does not seem to be needed anymore.

        // this is the base, so wrap it so we can pad it

        RenderBlock* baseWrapper = createAlmostAnonymousBlock(INLINE_BLOCK);

82 baseWrapper->style()->setPaddingLeft(Length(5 * g~~Radical~~Width, Percent));

82 baseWrapper->style()->setPaddingLeft(Length(5 * gFrontWidthEms, Percent));

        RenderBlock::addChild(baseWrapper);

        baseWrapper->addChild(child);

    } else {

@@void RenderMathMLRoot::paint(PaintInfo&

    
    if (info.context->paintingDisabled())

        return;

9898 if (!firstChild() || !lastChild())

9999 return;

100

101101 IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());

102102

103 RenderBoxModelObject* ~~indexBox~~ = toRenderBoxModelObject(lastChild());

103 RenderBoxModelObject* baseWrapper = toRenderBoxModelObject(lastChild());

104104

105 int maxHeight = ~~indexBox~~->pixelSnappedOffsetHeight();

105 int baseHeight = baseWrapper->pixelSnappedOffsetHeight();

106106 // default to the font size in pixels if we're empty

    if (!maxHeight)

        maxHeight = style()->fontSize();

    int width = indexBox->pixelSnappedOffsetWidth();

    if (!baseHeight)

        baseHeight = style()->fontSize();

    int overbarWidth = baseWrapper->pixelSnappedOffsetWidth();

    
    int indexWidth = 0;

    RenderObject* current = firstChild();

@@void RenderMathMLRoot::paint(PaintInfo&

        current = current->nextSibling();

    }

121 int frontWidth = static_cast<int>(style()->fontSize() * g~~Radical~~Width);

122 int t~~opSt~~artShift = 0;

121 int frontWidth = static_cast<int>(style()->fontSize() * gFrontWidthEms);

122 int overbarLeftPointShift = 0;

123123 // Base height above which the shape of the root changes

124 int thresholdHeight = static_cast<int>(gThresholdBaseHeight * style()->fontSize());

124 int thresholdHeight = static_cast<int>(gThresholdBaseHeightEms * style()->fontSize());

125125

126 if (maxHeight > thresholdHeight && thresholdHeight) {

127 float shift = (maxHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

126 if (baseHeight > thresholdHeight && thresholdHeight) {

127 float shift = (baseHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

128128 if (shift > 1.)

129129 shift = 1.0f;

130 t~~opSt~~artShift = static_cast<int>(gRadicalBottomPointXPos * frontWidth * shift);

130 overbarLeftPointShift = static_cast<int>(gRadicalBottomPointXFront * frontWidth * shift);

131131 }

132132

133 width += t~~opSt~~artShift;

133 overbarWidth += overbarLeftPointShift;

134134

135 int rootPad = static_cast<int>(gRootPadding * style()->fontSize());

136 int start = adjustedPaintOffset.x() + indexWidth + gRadicalLeftM~~argin~~ + style()->paddingLeft().value() - rootPad;

135 int rootPad = static_cast<int>(gRootPaddingEms * style()->fontSize());

136 int startX = adjustedPaintOffset.x() + indexWidth + gRadicalLeftExtra + style()->paddingLeft().value() - rootPad;

137137 adjustedPaintOffset.setY(adjustedPaintOffset.y() + style()->paddingTop().value() - rootPad);

138138

    FloatPoint topStart(start - topStartShift, adjustedPaintOffset.y());

    FloatPoint bottomLeft(start - gRadicalBottomPointXPos * frontWidth , adjustedPaintOffset.y() + maxHeight + gRadicalBasePad);

    FloatPoint topLeft(start - gRadicalTopLeftPointXPos * frontWidth , adjustedPaintOffset.y() + gRadicalTopLeftPointYPos * maxHeight);

    FloatPoint leftEnd(start - frontWidth , topLeft.y() + gRadicalLeftEndYShift * style()->fontSize());

    FloatPoint overbarLeftPoint(startX - overbarLeftPointShift, adjustedPaintOffset.y());

    FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);

    FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + gRadicalDipLeftPointYPos * baseHeight);

    FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style()->fontSize());

    
    GraphicsContextStateSaver stateSaver(*info.context);

146 info.context->setStrokeThickness(gRadicalLineThickness * style()->fontSize());

146 info.context->setStrokeThickness(gRadicalLineThicknessEms * style()->fontSize());

    info.context->setStrokeStyle(SolidStroke);

    info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);

    info.context->setLineJoin(MiterJoin);

@@void RenderMathMLRoot::paint(PaintInfo&

    
    Path root;

154 root.moveTo(FloatPoint(t~~opSt~~art.x() + width, adjustedPaintOffset.y()));

154 root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));

155155 // draw top

156 root.addLineTo(t~~opSt~~art);

156 root.addLineTo(overbarLeftPoint);

157157 // 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);

    root.addLineTo(bottomPoint);

    // draw from bottom point to top of left part of radical base "dip"

    root.addLineTo(dipLeftPoint);

    // draw to end

    root.addLineTo(leftEnd);

@@void RenderMathMLRoot::paint(PaintInfo&

    // 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()));

    mask.moveTo(overbarLeftPoint);

    mask.addLineTo(bottomPoint);

    mask.addLineTo(dipLeftPoint);

    mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));

    
    info.context->clip(mask);

    // Draw the thick part of the root.

179 info.context->setStrokeThickness(gRadicalThickLineThickness * style()->fontSize());

179 info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style()->fontSize());

    info.context->setLineCap(SquareCap);

    Path line;

    line.moveTo(bottomLeft);

    line.addLineTo(topLeft);

    line.moveTo(bottomPoint);

    line.addLineTo(dipLeftPoint);

    info.context->strokePath(line);

}

@@void RenderMathMLRoot::layout()

    if (!firstChild() || !lastChild())

        return;

    int maxHeight = toRenderBoxModelObject(lastChild())->pixelSnappedOffsetHeight();

    RenderObject* current = lastChild()->firstChild();

    if (current)

        current->style()->setVerticalAlign(BASELINE);

    if (!maxHeight)

        maxHeight = style()->fontSize();

    int baseHeight = toRenderBoxModelObject(lastChild())->pixelSnappedOffsetHeight();

    if (!baseHeight)

        baseHeight = style()->fontSize();

    RenderObject* base = lastChild()->firstChild();

    if (base)

        base->style()->setVerticalAlign(BASELINE); // FIXME: Can this style be modified?

204203

205204 // Base height above which the shape of the root changes

206 int thresholdHeight = static_cast<int>(gThresholdBaseHeight * style()->fontSize());

207 int t~~opSt~~artShift = 0;

205 int thresholdHeight = static_cast<int>(gThresholdBaseHeightEms * style()->fontSize());

206 int overbarLeftPointShift = 0;

208207

209 if (maxHeight > thresholdHeight && thresholdHeight) {

210 float shift = (maxHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

    // FIXME: Can style() and indexBox->style() be modified (4 times below)?

    if (baseHeight > thresholdHeight && thresholdHeight) {

        float shift = (baseHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

211211 if (shift > 1.)

212212 shift = 1.0f;

213 int frontWidth = static_cast<int>(style()->fontSize() * g~~Radical~~Width);

214 t~~opSt~~artShift = static_cast<int>(gRadicalBottomPointXPos * frontWidth * shift);

213 int frontWidth = static_cast<int>(style()->fontSize() * gFrontWidthEms);

214 overbarLeftPointShift = static_cast<int>(gRadicalBottomPointXFront * frontWidth * shift);

215215

216 style()->setPaddingBottom(Length(static_cast<int>(gRootBottomPadding * style()->fontSize()), Fixed));

216 style()->setPaddingBottom(Length(static_cast<int>(gBigRootBottomPaddingEms * style()->fontSize()), Fixed));

    }

    // Positioning of the index

@@void RenderMathMLRoot::layout()

    if (!indexBox)

        return;

    int indexShift = indexBox->pixelSnappedOffsetWidth() + topStartShift;

    int radicalHeight = static_cast<int>((1 - gRadicalTopLeftPointYPos) * maxHeight);

    int rootMarginTop = radicalHeight + style()->paddingBottom().value() + indexBox->pixelSnappedOffsetHeight()

        - (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));

    int shiftForIndex = indexBox->pixelSnappedOffsetWidth() + overbarLeftPointShift;

    int partDipHeight = static_cast<int>((1 - gRadicalDipLeftPointYPos) * baseHeight);

    int rootExtraTop = partDipHeight + style()->paddingBottom().value() + indexBox->pixelSnappedOffsetHeight()

        - (baseHeight + static_cast<int>(gRootPaddingEms * style()->fontSize()));

    style()->setPaddingLeft(Length(shiftForIndex, Fixed));

    if (rootExtraTop > 0)

        style()->setPaddingTop(Length(rootExtraTop + static_cast<int>(gRootPaddingEms * style()->fontSize()), Fixed));

235235

236236 setNeedsLayout(true);

237 setPreferredLogicalWidthsDirty(true, false);

237 setPreferredLogicalWidthsDirty(true, false); // FIXME: Can this really be right?

238238 RenderBlock::layout();

239239

240 indexBox->style()->setBottom(Length(~~radical~~Height + style()->paddingBottom().value(), Fixed));

240 indexBox->style()->setBottom(Length(partDipHeight + style()->paddingBottom().value(), Fixed));

    // Now that we've potentially changed its position, we need layout the index again.

    indexBox->setNeedsLayout(true);

111083

Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.cpp

#include "GraphicsContext.h"

#include "MathMLNames.h"

#include "PaintInfo.h"

36 #include "Path.h"

namespace WebCore {

using namespace MathMLNames;

// Bottom padding of the radical (px)

const int gRadicalBasePad = 3;

// Threshold above which the radical shape is modified to look nice with big bases (%)

const float gThresholdBaseHeight = 1.5f;

// Radical width (%)

const float gRadicalWidth = 0.75f;

// Horizontal position of the bottom point of the radical (%)

const float gRadicalBottomPointXPos= 0.5f;

// Horizontal position of the top left point of the radical (%)

const float gRadicalTopLeftPointXPos = 0.2f;

// Vertical position of the top left point of the radical (%)

const float gRadicalTopLeftPointYPos = 0.5f; 

// Vertical shift of the left end point of the radical (%)

const float gRadicalLeftEndYShift = 0.05f;

// Additional bottom root padding (%)

const float gRootBottomPadding = 0.2f;

// Radical line thickness (%)

const float gRadicalLineThickness = 0.02f;

// Radical thick line thickness (%)

const float gRadicalThickLineThickness = 0.1f;

// Lower the radical sign's bottom point (px)

const int gRadicalBottomPointLower = 3;

// Threshold above which the radical shape is modified to look nice with big bases (em)

const float gThresholdBaseHeightEms = 1.5f;

// Front width (em)

const float gFrontWidthEms = 0.75f;

// Horizontal position of the bottom point of the radical (* frontWidth)

const float gRadicalBottomPointXFront = 0.5f;

// Horizontal position of the top left point of the radical "dip" (* frontWidth)

const float gRadicalDipLeftPointXFront = 0.2f;

// Vertical position of the top left point of the radical "dip" (* baseHeight)

const float gRadicalDipLeftPointYPos = 0.5f; 

// Vertical shift of the left end point of the radical (em)

const float gRadicalLeftEndYShiftEms = 0.05f;

// Additional bottom root padding if baseHeight > threshold (em)

const float gBigRootBottomPaddingEms = 0.2f;

// Radical line thickness (em)

const float gRadicalLineThicknessEms = 0.02f;

// Radical thick line thickness (em)

const float gRadicalThickLineThicknessEms = 0.1f;

    
RenderMathMLSquareRoot::RenderMathMLSquareRoot(Element* element)

    : RenderMathMLBlock(element)

@@RenderMathMLSquareRoot::RenderMathMLSqua

void RenderMathMLSquareRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)

{

    RenderMathMLBlock::paint(info, paintOffset);

    if (info.context->paintingDisabled())

        return;

    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());

    int maxHeight = 0;

    int width = 0;

    
    int baseHeight = 0;

    int overbarWidth = 0;

    RenderObject* current = firstChild();

    while (current) {

        if (current->isBoxModelObject()) {

            RenderBoxModelObject* box = toRenderBoxModelObject(current);

            // Check to see if this box has a larger height

            if (box->pixelSnappedOffsetHeight() > maxHeight)

                maxHeight = box->pixelSnappedOffsetHeight();

            width += box->pixelSnappedOffsetWidth();

            // FIXME: We should consider the height above & below the baseline separately. This will be

            // fixed by an <mrow> base wrapper, which is required anyway by the MathML spec.

            if (box->pixelSnappedOffsetHeight() > baseHeight)

                baseHeight = box->pixelSnappedOffsetHeight();

            overbarWidth += box->pixelSnappedOffsetWidth();

        }

        current = current->nextSibling();

    }

    // default to the font size in pixels if we're empty

94 if (!maxHeight)

95 maxHeight = style()->fontSize();

94 if (!baseHeight)

95 baseHeight = style()->fontSize();

9696

97 int frontWidth = static_cast<int>(style()->fontSize() * g~~Radical~~Width);

98 int t~~opSt~~artShift = 0;

97 int frontWidth = static_cast<int>(style()->fontSize() * gFrontWidthEms);

98 int overbarLeftPointShift = 0;

9999 // Base height above which the shape of the root changes

100 int thresholdHeight = static_cast<int>(gThresholdBaseHeight * style()->fontSize());

100 int thresholdHeight = static_cast<int>(gThresholdBaseHeightEms * style()->fontSize());

101101

102 if (maxHeight > thresholdHeight && thresholdHeight) {

103 float shift = (maxHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

102 if (baseHeight > thresholdHeight && thresholdHeight) {

103 float shift = (baseHeight - thresholdHeight) / static_cast<float>(thresholdHeight);

104104 if (shift > 1.)

105105 shift = 1.0f;

106 t~~opSt~~artShift = static_cast<int>(gRadicalBottomPointXPos * frontWidth * shift);

106 overbarLeftPointShift = static_cast<int>(gRadicalBottomPointXFront * frontWidth * shift);

107107 }

108108

109 width += t~~opSt~~artShift;

109 overbarWidth += overbarLeftPointShift;

110110

    FloatPoint topStart(adjustedPaintOffset.x() + frontWidth - topStartShift, adjustedPaintOffset.y());

    FloatPoint bottomLeft(adjustedPaintOffset.x() + frontWidth * gRadicalBottomPointXPos , adjustedPaintOffset.y() + maxHeight + gRadicalBasePad);

    FloatPoint topLeft(adjustedPaintOffset.x() + frontWidth * gRadicalTopLeftPointXPos , adjustedPaintOffset.y() + gRadicalTopLeftPointYPos * maxHeight);

    FloatPoint leftEnd(adjustedPaintOffset.x() , topLeft.y() + gRadicalLeftEndYShift * style()->fontSize());

    FloatPoint overbarLeftPoint(adjustedPaintOffset.x() + frontWidth - overbarLeftPointShift, adjustedPaintOffset.y());

    FloatPoint bottomPoint(adjustedPaintOffset.x() + frontWidth * gRadicalBottomPointXFront, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);

    FloatPoint dipLeftPoint(adjustedPaintOffset.x() + frontWidth * gRadicalDipLeftPointXFront, adjustedPaintOffset.y() + gRadicalDipLeftPointYPos * baseHeight);

    FloatPoint leftEnd(adjustedPaintOffset.x(), dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style()->fontSize());

    
    GraphicsContextStateSaver stateSaver(*info.context);

118 info.context->setStrokeThickness(gRadicalLineThickness * style()->fontSize());

118 info.context->setStrokeThickness(gRadicalLineThicknessEms * style()->fontSize());

    info.context->setStrokeStyle(SolidStroke);

    info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);

    info.context->setLineJoin(MiterJoin);

@@void RenderMathMLSquareRoot::paint(Paint

    
    Path root;

126 root.moveTo(FloatPoint(t~~opSt~~art.x() + width , adjustedPaintOffset.y()));

126 root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));

127127 // draw top

128 root.addLineTo(t~~opSt~~art);

128 root.addLineTo(overbarLeftPoint);

129129 // 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);

    root.addLineTo(bottomPoint);

    // draw from bottom point to top of left part of radical base "dip"

    root.addLineTo(dipLeftPoint);

133133 // draw to end

134134 root.addLineTo(leftEnd);

135

    info.context->strokePath(root);

    GraphicsContextStateSaver maskStateSaver(*info.context);

@@void RenderMathMLSquareRoot::paint(Paint

    // 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()));

    mask.moveTo(overbarLeftPoint);

    mask.addLineTo(bottomPoint);

    mask.addLineTo(dipLeftPoint);

    mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));

    
    info.context->clip(mask);

    // Draw the thick part of the root.

151 info.context->setStrokeThickness(gRadicalThickLineThickness * style()->fontSize());

151 info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style()->fontSize());

    info.context->setLineCap(SquareCap);

    Path line;

155 line.moveTo(bottom~~Lef~~t);

156 line.addLineTo(topLeft);

155 line.moveTo(bottomPoint);

156 line.addLineTo(dipLeftPoint);

    
    info.context->strokePath(line);

}

void RenderMathMLSquareRoot::layout()

{

163 int maxHeight = 0;

163 int baseHeight = 0;

    
    RenderObject* current = firstChild();

    while (current) {

        if (current->isBoxModelObject()) {

            RenderBoxModelObject* box = toRenderBoxModelObject(current);

170 if (box->pixelSnappedOffsetHeight() > maxHeight)

171 maxHeight = box->pixelSnappedOffsetHeight();

170 if (box->pixelSnappedOffsetHeight() > baseHeight)

171 baseHeight = box->pixelSnappedOffsetHeight();

172172

173 // FIXME: Can box->style() be modified?

            box->style()->setVerticalAlign(BASELINE);

        }

        current = current->nextSibling();

    }

    if (!maxHeight)

        maxHeight = style()->fontSize();

179 if (!baseHeight)

180 baseHeight = style()->fontSize();

181181

    if (maxHeight > static_cast<int>(gThresholdBaseHeight * style()->fontSize()))

        style()->setPaddingBottom(Length(static_cast<int>(gRootBottomPadding * style()->fontSize()), Fixed));

    // FIXME: Can style() be modified? And don't we need styleDidChange()?

    if (baseHeight > static_cast<int>(gThresholdBaseHeightEms * style()->fontSize()))

        style()->setPaddingBottom(Length(static_cast<int>(gBigRootBottomPaddingEms * style()->fontSize()), Fixed));

    
    RenderBlock::layout();

}

111083

Source/WebCore/ChangeLog

Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp

Source/WebCore/rendering/mathml/RenderMathMLRoot.h

Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.cpp

Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.h

Source/WebCore/rendering/mathml/RenderMathMLSubSup.h