MathML padding overrides only need to be on RenderMathMLRoot
[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 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     computeChildrenPreferredLogicalHeights();
191     
192     int baseHeight = firstChild() ? roundToInt(preferredLogicalHeightAfterSizing(firstChild())) : style()->fontSize();
193     
194     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
195     
196     // Base height above which the shape of the root changes
197     float thresholdHeight = gThresholdBaseHeightEms * style()->fontSize();
198     if (baseHeight > thresholdHeight && thresholdHeight) {
199         float shift = min<float>((baseHeight - thresholdHeight) / thresholdHeight, 1.0f);
200         m_overbarLeftPointShift = static_cast<int>(shift * gRadicalBottomPointXFront * frontWidth);
201         m_intrinsicPaddingAfter = lroundf(gBigRootBottomPaddingEms * style()->fontSize());
202     } else {
203         m_overbarLeftPointShift = 0;
204         m_intrinsicPaddingAfter = 0;
205     }
206     
207     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
208     m_intrinsicPaddingBefore = rootPad;
209     m_indexTop = 0;
210     if (RenderBoxModelObject* index = this->index()) {
211         m_intrinsicPaddingStart = roundToInt(index->maxPreferredLogicalWidth()) + m_overbarLeftPointShift;
212         
213         int indexHeight = roundToInt(preferredLogicalHeightAfterSizing(index));
214         int partDipHeight = lroundf((1 - gRootRadicalDipLeftPointYPos) * baseHeight);
215         int rootExtraTop = partDipHeight + indexHeight - (baseHeight + rootPad);
216         if (rootExtraTop > 0)
217             m_intrinsicPaddingBefore += rootExtraTop;
218         else
219             m_indexTop = - rootExtraTop;
220     } else
221         m_intrinsicPaddingStart = frontWidth;
222     
223     RenderMathMLBlock::computePreferredLogicalWidths();
224     
225     // Shrink our logical width to its probable value now without triggering unnecessary relayout of our children.
226     ASSERT(needsLayout() && logicalWidth() >= maxPreferredLogicalWidth());
227     setLogicalWidth(maxPreferredLogicalWidth());
228 }
229
230 void RenderMathMLRoot::layout()
231 {
232     // Our computePreferredLogicalWidths() may change our logical width and then layout our children, which
233     // RenderBlock::layout()'s relayoutChildren logic isn't expecting.
234     if (preferredLogicalWidthsDirty())
235         computePreferredLogicalWidths();
236     
237     RenderMathMLBlock::layout();
238     
239     RenderBoxModelObject* index = this->index();
240     // If |index|, it should be a RenderBlock here, unless the user has overriden its { position: absolute }.
241     if (index && index->isBox())
242         toRenderBox(index)->setLogicalTop(m_indexTop);
243 }
244
245 void RenderMathMLRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
246 {
247     RenderMathMLBlock::paint(info, paintOffset);
248     
249     if (info.context->paintingDisabled())
250         return;
251     
252     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + contentBoxRect().location());
253     
254     int startX = adjustedPaintOffset.x();
255     int frontWidth = lroundf(gFrontWidthEms * style()->fontSize());
256     int overbarWidth = roundToInt(contentLogicalWidth()) + m_overbarLeftPointShift;
257     
258     int baseHeight = roundToInt(contentLogicalHeight());
259     int rootPad = lroundf(gSpaceAboveEms * style()->fontSize());
260     adjustedPaintOffset.setY(adjustedPaintOffset.y() - rootPad);
261     
262     float radicalDipLeftPointYPos = (index() ? gRootRadicalDipLeftPointYPos : gSqrtRadicalDipLeftPointYPos) * baseHeight;
263     
264     FloatPoint overbarLeftPoint(startX - m_overbarLeftPointShift, adjustedPaintOffset.y());
265     FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);
266     FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + radicalDipLeftPointYPos);
267     FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style()->fontSize());
268     
269     GraphicsContextStateSaver stateSaver(*info.context);
270     
271     info.context->setStrokeThickness(gRadicalLineThicknessEms * style()->fontSize());
272     info.context->setStrokeStyle(SolidStroke);
273     info.context->setStrokeColor(style()->visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
274     info.context->setLineJoin(MiterJoin);
275     info.context->setMiterLimit(style()->fontSize());
276     
277     Path root;
278     
279     root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));
280     // draw top
281     root.addLineTo(overbarLeftPoint);
282     // draw from top left corner to bottom point of radical
283     root.addLineTo(bottomPoint);
284     // draw from bottom point to top of left part of radical base "dip"
285     root.addLineTo(dipLeftPoint);
286     // draw to end
287     root.addLineTo(leftEnd);
288     
289     info.context->strokePath(root);
290     
291     GraphicsContextStateSaver maskStateSaver(*info.context);
292     
293     // Build a mask to draw the thick part of the root.
294     Path mask;
295     
296     mask.moveTo(overbarLeftPoint);
297     mask.addLineTo(bottomPoint);
298     mask.addLineTo(dipLeftPoint);
299     mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));
300     
301     info.context->clip(mask);
302     
303     // Draw the thick part of the root.
304     info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style()->fontSize());
305     info.context->setLineCap(SquareCap);
306     
307     Path line;
308     line.moveTo(bottomPoint);
309     line.addLineTo(dipLeftPoint);
310     
311     info.context->strokePath(line);
312 }
313
314 }
315
316 #endif // ENABLE(MATHML)