MathML preferred widths should not depend on layout information
[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         firstChild()->addChild(newChild, beforeChild && beforeChild->parent() == firstChild() ? beforeChild : 0);
174 }
175
176 RenderBox* RenderMathMLRoot::index() const
177 {
178     if (!firstChild())
179         return 0;
180     RenderObject* index = firstChild()->nextSibling();
181     if (!index || !index->isBox())
182         return 0;
183     return toRenderBox(index);
184 }
185
186 void RenderMathMLRoot::layout()
187 {
188     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
189         if (!child->isBox())
190             continue;
191         child->layoutIfNeeded();
192     }
193
194     int baseHeight = firstChild() && firstChild()->isBox() ? roundToInt(toRenderBox(firstChild())->logicalHeight()) : style()->fontSize();
195     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
196     
197     // Base height above which the shape of the root changes
198     float thresholdHeight = gThresholdBaseHeightEms * style()->fontSize();
199     if (baseHeight > thresholdHeight && thresholdHeight) {
200         float shift = min<float>((baseHeight - thresholdHeight) / thresholdHeight, 1.0f);
201         m_overbarLeftPointShift = static_cast<int>(shift * gRadicalBottomPointXFront * frontWidth);
202         m_intrinsicPaddingAfter = lroundf(gBigRootBottomPaddingEms * style()->fontSize());
203     } else {
204         m_overbarLeftPointShift = 0;
205         m_intrinsicPaddingAfter = 0;
206     }
207     
208     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
209     m_intrinsicPaddingBefore = rootPad;
210     m_indexTop = 0;
211     if (RenderBox* index = this->index()) {
212         m_intrinsicPaddingStart = roundToInt(index->maxPreferredLogicalWidth()) + m_overbarLeftPointShift;
213         
214         int indexHeight = roundToInt(index->logicalHeight());
215         int partDipHeight = lroundf((1 - gRootRadicalDipLeftPointYPos) * baseHeight);
216         int rootExtraTop = partDipHeight + indexHeight - (baseHeight + rootPad);
217         if (rootExtraTop > 0)
218             m_intrinsicPaddingBefore += rootExtraTop;
219         else
220             m_indexTop = -rootExtraTop;
221     } else
222         m_intrinsicPaddingStart = frontWidth;
223
224     // FIXME: We should rewrite RenderMathMLRoot to rewrite -webkit-flex-order to get rid of the need
225     // for intrinsic padding. See https://bugs.webkit.org/show_bug.cgi?id=107151#c2.
226     // FIXME: We should make it so that the preferred width of RenderMathMLRoots doesn't change during layout.
227     // Technically, we currently only need to set the dirty bit here if one of the member variables above changes.
228     setPreferredLogicalWidthsDirty(true);
229
230     RenderMathMLBlock::layout();
231     if (RenderBox* index = this->index())
232         index->setLogicalTop(m_indexTop);
233 }
234
235 void RenderMathMLRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
236 {
237     RenderMathMLBlock::paint(info, paintOffset);
238     
239     if (info.context->paintingDisabled())
240         return;
241     
242     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + contentBoxRect().location());
243     
244     int startX = adjustedPaintOffset.x();
245     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
246     int overbarWidth = roundToInt(contentLogicalWidth()) + m_overbarLeftPointShift;
247     
248     int baseHeight = roundToInt(contentLogicalHeight());
249     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
250     adjustedPaintOffset.setY(adjustedPaintOffset.y() - rootPad);
251     
252     float radicalDipLeftPointYPos = (index() ? gRootRadicalDipLeftPointYPos : gSqrtRadicalDipLeftPointYPos) * baseHeight;
253     
254     FloatPoint overbarLeftPoint(startX - m_overbarLeftPointShift, adjustedPaintOffset.y());
255     FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);
256     FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + radicalDipLeftPointYPos);
257     FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style()->fontSize());
258     
259     GraphicsContextStateSaver stateSaver(*info.context);
260     
261     info.context->setStrokeThickness(gRadicalLineThicknessEms * style()->fontSize());
262     info.context->setStrokeStyle(SolidStroke);
263     info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
264     info.context->setLineJoin(MiterJoin);
265     info.context->setMiterLimit(style()->fontSize());
266     
267     Path root;
268     
269     root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));
270     // draw top
271     root.addLineTo(overbarLeftPoint);
272     // draw from top left corner to bottom point of radical
273     root.addLineTo(bottomPoint);
274     // draw from bottom point to top of left part of radical base "dip"
275     root.addLineTo(dipLeftPoint);
276     // draw to end
277     root.addLineTo(leftEnd);
278     
279     info.context->strokePath(root);
280     
281     GraphicsContextStateSaver maskStateSaver(*info.context);
282     
283     // Build a mask to draw the thick part of the root.
284     Path mask;
285     
286     mask.moveTo(overbarLeftPoint);
287     mask.addLineTo(bottomPoint);
288     mask.addLineTo(dipLeftPoint);
289     mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));
290     
291     info.context->clip(mask);
292     
293     // Draw the thick part of the root.
294     info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style()->fontSize());
295     info.context->setLineCap(SquareCap);
296     
297     Path line;
298     line.moveTo(bottomPoint);
299     line.addLineTo(dipLeftPoint);
300     
301     info.context->strokePath(line);
302 }
303
304 }
305
306 #endif // ENABLE(MATHML)