Roll out r156930 and r156937, they caused 34 assertion failures on bots.
[WebKit-https.git] / Source / WebCore / rendering / mathml / RenderMathMLRoot.cpp
1 /*
2  * Copyright (C) 2009 Alex Milowski (alex@milowski.com). All rights reserved.
3  * Copyright (C) 2010 Fran├žois Sausset (sausset@gmail.com). All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
18  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
20  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28
29 #if ENABLE(MATHML)
30
31 #include "RenderMathMLRoot.h"
32
33 #include "GraphicsContext.h"
34 #include "PaintInfo.h"
35 #include "RenderMathMLRow.h"
36
37 using namespace std;
38
39 namespace WebCore {
40     
41 // FIXME: This whole file should be changed to work with various writing modes. See https://bugs.webkit.org/show_bug.cgi?id=48951.
42
43 // Threshold above which the radical shape is modified to look nice with big bases (em)
44 const float gThresholdBaseHeightEms = 1.5f;
45 // Normal width of the front of the radical sign, before the base & overbar (em)
46 const float gFrontWidthEms = 0.75f;
47 // Gap between the base and overbar (em)
48 const float gSpaceAboveEms = 0.2f;
49 // Horizontal position of the bottom point of the radical (* frontWidth)
50 const float gRadicalBottomPointXFront = 0.5f;
51 // Lower the radical sign's bottom point (px)
52 const int gRadicalBottomPointLower = 3;
53 // Horizontal position of the top left point of the radical "dip" (* frontWidth)
54 const float gRadicalDipLeftPointXFront = 0.8f;
55 // Vertical position of the top left point of a sqrt radical "dip" (* baseHeight)
56 const float gSqrtRadicalDipLeftPointYPos = 0.5f;
57 // Vertical position of the top left point of an nth root radical "dip" (* baseHeight)
58 const float gRootRadicalDipLeftPointYPos = 0.625f;
59 // Vertical shift of the left end point of the radical (em)
60 const float gRadicalLeftEndYShiftEms = 0.05f;
61 // Additional bottom root padding if baseHeight > threshold (em)
62 const float gBigRootBottomPaddingEms = 0.2f;
63
64 // Radical line thickness (em)
65 const float gRadicalLineThicknessEms = 0.02f;
66 // Radical thick line thickness (em)
67 const float gRadicalThickLineThicknessEms = 0.1f;
68     
69 RenderMathMLRoot::RenderMathMLRoot(Element* element)
70     : RenderMathMLBlock(element)
71     , m_intrinsicPaddingBefore(0)
72     , m_intrinsicPaddingAfter(0)
73     , m_intrinsicPaddingStart(0)
74     , m_intrinsicPaddingEnd(0)
75 {
76 }
77
78 LayoutUnit RenderMathMLRoot::paddingTop() const
79 {
80     LayoutUnit result = computedCSSPaddingTop();
81     switch (style()->writingMode()) {
82     case TopToBottomWritingMode:
83         return result + m_intrinsicPaddingBefore;
84     case BottomToTopWritingMode:
85         return result + m_intrinsicPaddingAfter;
86     case LeftToRightWritingMode:
87     case RightToLeftWritingMode:
88         return result + (style()->isLeftToRightDirection() ? m_intrinsicPaddingStart : m_intrinsicPaddingEnd);
89     }
90     ASSERT_NOT_REACHED();
91     return result;
92 }
93
94 LayoutUnit RenderMathMLRoot::paddingBottom() const
95 {
96     LayoutUnit result = computedCSSPaddingBottom();
97     switch (style()->writingMode()) {
98     case TopToBottomWritingMode:
99         return result + m_intrinsicPaddingAfter;
100     case BottomToTopWritingMode:
101         return result + m_intrinsicPaddingBefore;
102     case LeftToRightWritingMode:
103     case RightToLeftWritingMode:
104         return result + (style()->isLeftToRightDirection() ? m_intrinsicPaddingEnd : m_intrinsicPaddingStart);
105     }
106     ASSERT_NOT_REACHED();
107     return result;
108 }
109
110 LayoutUnit RenderMathMLRoot::paddingLeft() const
111 {
112     LayoutUnit result = computedCSSPaddingLeft();
113     switch (style()->writingMode()) {
114     case LeftToRightWritingMode:
115         return result + m_intrinsicPaddingBefore;
116     case RightToLeftWritingMode:
117         return result + m_intrinsicPaddingAfter;
118     case TopToBottomWritingMode:
119     case BottomToTopWritingMode:
120         return result + (style()->isLeftToRightDirection() ? m_intrinsicPaddingStart : m_intrinsicPaddingEnd);
121     }
122     ASSERT_NOT_REACHED();
123     return result;
124 }
125
126 LayoutUnit RenderMathMLRoot::paddingRight() const
127 {
128     LayoutUnit result = computedCSSPaddingRight();
129     switch (style()->writingMode()) {
130     case RightToLeftWritingMode:
131         return result + m_intrinsicPaddingBefore;
132     case LeftToRightWritingMode:
133         return result + m_intrinsicPaddingAfter;
134     case TopToBottomWritingMode:
135     case BottomToTopWritingMode:
136         return result + (style()->isLeftToRightDirection() ? m_intrinsicPaddingEnd : m_intrinsicPaddingStart);
137     }
138     ASSERT_NOT_REACHED();
139     return result;
140 }
141
142 LayoutUnit RenderMathMLRoot::paddingBefore() const
143 {
144     return computedCSSPaddingBefore() + m_intrinsicPaddingBefore;
145 }
146
147 LayoutUnit RenderMathMLRoot::paddingAfter() const
148 {
149     return computedCSSPaddingAfter() + m_intrinsicPaddingAfter;
150 }
151
152 LayoutUnit RenderMathMLRoot::paddingStart() const
153 {
154     return computedCSSPaddingStart() + m_intrinsicPaddingStart;
155 }
156
157 LayoutUnit RenderMathMLRoot::paddingEnd() const
158 {
159     return computedCSSPaddingEnd() + m_intrinsicPaddingEnd;
160 }
161
162 void RenderMathMLRoot::addChild(RenderObject* newChild, RenderObject* beforeChild)
163 {
164     // Insert an implicit <mrow> for <mroot> as well as <msqrt>, to ensure firstChild() will have a box
165     // to measure and store a glyph-based height for preferredLogicalHeightAfterSizing.
166     if (!firstChild())
167         RenderMathMLBlock::addChild(RenderMathMLRow::createAnonymousWithParentRenderer(this));
168     
169     // An <mroot>'s index has { position: absolute }.
170     if (newChild->style()->position() == AbsolutePosition)
171         RenderMathMLBlock::addChild(newChild);
172     else
173         toRenderElement(firstChild())->addChild(newChild, beforeChild && beforeChild->parent() == firstChild() ? beforeChild : 0);
174 }
175
176 RenderBoxModelObject* RenderMathMLRoot::index() const
177 {
178     if (!firstChild())
179         return 0;
180     RenderObject* index = firstChild()->nextSibling();
181     if (!index || !index->isBoxModelObject())
182         return 0;
183     return toRenderBoxModelObject(index);
184 }
185
186 void RenderMathMLRoot::computePreferredLogicalWidths()
187 {
188     ASSERT(preferredLogicalWidthsDirty() && needsLayout());
189     
190 #ifndef NDEBUG
191     // FIXME: Remove this once mathml stops modifying the render tree here.
192     SetLayoutNeededForbiddenScope layoutForbiddenScope(this, false);
193 #endif
194     
195     computeChildrenPreferredLogicalHeights();
196     
197     int baseHeight = firstChild() ? roundToInt(preferredLogicalHeightAfterSizing(firstChild())) : style()->fontSize();
198     
199     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
200     
201     // Base height above which the shape of the root changes
202     float thresholdHeight = gThresholdBaseHeightEms * style()->fontSize();
203     if (baseHeight > thresholdHeight && thresholdHeight) {
204         float shift = min<float>((baseHeight - thresholdHeight) / thresholdHeight, 1.0f);
205         m_overbarLeftPointShift = static_cast<int>(shift * gRadicalBottomPointXFront * frontWidth);
206         m_intrinsicPaddingAfter = lroundf(gBigRootBottomPaddingEms * style()->fontSize());
207     } else {
208         m_overbarLeftPointShift = 0;
209         m_intrinsicPaddingAfter = 0;
210     }
211     
212     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
213     m_intrinsicPaddingBefore = rootPad;
214     m_indexTop = 0;
215     if (RenderBoxModelObject* index = this->index()) {
216         m_intrinsicPaddingStart = roundToInt(index->maxPreferredLogicalWidth()) + m_overbarLeftPointShift;
217         
218         int indexHeight = roundToInt(preferredLogicalHeightAfterSizing(index));
219         int partDipHeight = lroundf((1 - gRootRadicalDipLeftPointYPos) * baseHeight);
220         int rootExtraTop = partDipHeight + indexHeight - (baseHeight + rootPad);
221         if (rootExtraTop > 0)
222             m_intrinsicPaddingBefore += rootExtraTop;
223         else
224             m_indexTop = - rootExtraTop;
225     } else
226         m_intrinsicPaddingStart = frontWidth;
227
228     RenderMathMLBlock::computePreferredLogicalWidths();
229     
230     // Shrink our logical width to its probable value now without triggering unnecessary relayout of our children.
231     ASSERT(needsLayout() && logicalWidth() >= maxPreferredLogicalWidth());
232     setLogicalWidth(maxPreferredLogicalWidth());
233 }
234
235 void RenderMathMLRoot::layout()
236 {
237     // Our computePreferredLogicalWidths() may change our logical width and then layout our children, which
238     // RenderBlock::layout()'s relayoutChildren logic isn't expecting.
239     if (preferredLogicalWidthsDirty())
240         computePreferredLogicalWidths();
241     
242     RenderMathMLBlock::layout();
243     
244     RenderBoxModelObject* index = this->index();
245     // If |index|, it should be a RenderBlock here, unless the user has overriden its { position: absolute }.
246     if (index && index->isBox())
247         toRenderBox(index)->setLogicalTop(m_indexTop);
248 }
249
250 void RenderMathMLRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
251 {
252     RenderMathMLBlock::paint(info, paintOffset);
253     
254     if (info.context->paintingDisabled() || style()->visibility() != VISIBLE)
255         return;
256     
257     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + contentBoxRect().location());
258     
259     int startX = adjustedPaintOffset.x();
260     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
261     int overbarWidth = roundToInt(contentLogicalWidth()) + m_overbarLeftPointShift;
262     
263     int baseHeight = roundToInt(contentLogicalHeight());
264     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
265     adjustedPaintOffset.setY(adjustedPaintOffset.y() - rootPad);
266     
267     float radicalDipLeftPointYPos = (index() ? gRootRadicalDipLeftPointYPos : gSqrtRadicalDipLeftPointYPos) * baseHeight;
268     
269     FloatPoint overbarLeftPoint(startX - m_overbarLeftPointShift, adjustedPaintOffset.y());
270     FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);
271     FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + radicalDipLeftPointYPos);
272     FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style()->fontSize());
273     
274     GraphicsContextStateSaver stateSaver(*info.context);
275     
276     info.context->setStrokeThickness(gRadicalLineThicknessEms * style()->fontSize());
277     info.context->setStrokeStyle(SolidStroke);
278     info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
279     info.context->setLineJoin(MiterJoin);
280     info.context->setMiterLimit(style()->fontSize());
281     
282     Path root;
283     
284     root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));
285     // draw top
286     root.addLineTo(overbarLeftPoint);
287     // draw from top left corner to bottom point of radical
288     root.addLineTo(bottomPoint);
289     // draw from bottom point to top of left part of radical base "dip"
290     root.addLineTo(dipLeftPoint);
291     // draw to end
292     root.addLineTo(leftEnd);
293     
294     info.context->strokePath(root);
295     
296     GraphicsContextStateSaver maskStateSaver(*info.context);
297     
298     // Build a mask to draw the thick part of the root.
299     Path mask;
300     
301     mask.moveTo(overbarLeftPoint);
302     mask.addLineTo(bottomPoint);
303     mask.addLineTo(dipLeftPoint);
304     mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));
305     
306     info.context->clip(mask);
307     
308     // Draw the thick part of the root.
309     info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style()->fontSize());
310     info.context->setLineCap(SquareCap);
311     
312     Path line;
313     line.moveTo(bottomPoint);
314     line.addLineTo(dipLeftPoint);
315     
316     info.context->strokePath(line);
317 }
318
319 }
320
321 #endif // ENABLE(MATHML)