Roll out r156930 and r156937, they caused 34 assertion failures on bots.
[WebKit-https.git] / Source / WebCore / rendering / mathml / RenderMathMLBlock.cpp
1 /*
2  * Copyright (C) 2009 Alex Milowski (alex@milowski.com). All rights reserved.
3  * Copyright (C) 2012 David Barton (dbarton@mathscribe.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 "RenderMathMLBlock.h"
32
33 #include "GraphicsContext.h"
34 #include "MathMLNames.h"
35 #include "RenderView.h"
36 #include <wtf/text/StringBuilder.h>
37
38 #if ENABLE(DEBUG_MATH_LAYOUT)
39 #include "PaintInfo.h"
40 #endif
41
42 namespace WebCore {
43     
44 using namespace MathMLNames;
45     
46 RenderMathMLBlock::RenderMathMLBlock(Element* container)
47     : RenderFlexibleBox(container)
48     , m_ignoreInAccessibilityTree(false)
49     , m_preferredLogicalHeight(preferredLogicalHeightUnset)
50 {
51 }
52
53 bool RenderMathMLBlock::isChildAllowed(RenderObject* child, RenderStyle*) const
54 {
55     return child->node() && child->node()->nodeType() == Node::ELEMENT_NODE;
56 }
57
58 void RenderMathMLBlock::computePreferredLogicalWidths()
59 {
60     ASSERT(preferredLogicalWidthsDirty());
61     m_preferredLogicalHeight = preferredLogicalHeightUnset;
62     RenderFlexibleBox::computePreferredLogicalWidths();
63 }
64
65 RenderMathMLBlock* RenderMathMLBlock::createAnonymousMathMLBlock(EDisplay display)
66 {
67     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), display);
68     RenderMathMLBlock* newBlock = new (renderArena()) RenderMathMLBlock(0);
69     newBlock->setDocumentForAnonymous(document());
70     newBlock->setStyle(newStyle.release());
71     return newBlock;
72 }
73
74 // An arbitrary large value, like RenderBlock.cpp BLOCK_MAX_WIDTH or FixedTableLayout.cpp TABLE_MAX_WIDTH.
75 static const int cLargeLogicalWidth = 15000;
76
77 void RenderMathMLBlock::computeChildrenPreferredLogicalHeights()
78 {
79     ASSERT(needsLayout());
80
81     // This is ugly, but disable fragmentation when computing the preferred heights.
82     FragmentationDisabler fragmentationDisabler(this);
83
84     // Ensure a full repaint will happen after layout finishes.
85     setNeedsLayout(MarkOnlyThis);
86
87     bool hadLayoutState = view().layoutState();
88     if (!hadLayoutState)
89         view().pushLayoutState(this);
90
91     {
92         LayoutStateDisabler layoutStateDisabler(&view());
93         
94         LayoutUnit oldAvailableLogicalWidth = availableLogicalWidth();
95         setLogicalWidth(cLargeLogicalWidth);
96         
97         for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
98             if (!child->isBox())
99                 continue;
100             
101             // Because our width changed, |child| may need layout.
102             if (child->maxPreferredLogicalWidth() > oldAvailableLogicalWidth)
103                 child->setNeedsLayout(MarkOnlyThis);
104             
105             RenderMathMLBlock* childMathMLBlock = child->isRenderMathMLBlock() ? toRenderMathMLBlock(child) : 0;
106             if (childMathMLBlock && !childMathMLBlock->isPreferredLogicalHeightDirty())
107                 continue;
108             // Layout our child to compute its preferred logical height.
109             child->layoutIfNeeded();
110             if (childMathMLBlock)
111                 childMathMLBlock->setPreferredLogicalHeight(childMathMLBlock->logicalHeight());
112         }
113     }
114     if (!hadLayoutState)
115         view().popLayoutState(this);
116 }
117
118 LayoutUnit RenderMathMLBlock::preferredLogicalHeightAfterSizing(RenderObject* child)
119 {
120     if (child->isRenderMathMLBlock())
121         return toRenderMathMLBlock(child)->preferredLogicalHeight();
122     if (child->isBox()) {
123         ASSERT(!child->needsLayout());
124         return toRenderBox(child)->logicalHeight();
125     }
126     // This currently ignores -webkit-line-box-contain:
127     return child->style()->fontSize();
128 }
129
130 int RenderMathMLBlock::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
131 {
132     // mathml.css sets math { -webkit-line-box-contain: glyphs replaced; line-height: 0; }, so when linePositionMode == PositionOfInteriorLineBoxes we want to
133     // return 0 here to match our line-height. This matters when RootInlineBox::ascentAndDescentForBox is called on a RootInlineBox for an inline-block.
134     if (linePositionMode == PositionOfInteriorLineBoxes)
135         return 0;
136     
137     LayoutUnit baseline = firstLineBoxBaseline(); // FIXME: This may be unnecessary after flex baselines are implemented (https://bugs.webkit.org/show_bug.cgi?id=96188).
138     if (baseline != -1)
139         return baseline;
140     
141     return RenderFlexibleBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
142 }
143
144 const char* RenderMathMLBlock::renderName() const
145 {
146     EDisplay display = style()->display();
147     if (display == FLEX)
148         return isAnonymous() ? "RenderMathMLBlock (anonymous, flex)" : "RenderMathMLBlock (flex)";
149     if (display == INLINE_FLEX)
150         return isAnonymous() ? "RenderMathMLBlock (anonymous, inline-flex)" : "RenderMathMLBlock (inline-flex)";
151     // |display| should be one of the above.
152     ASSERT_NOT_REACHED();
153     return isAnonymous() ? "RenderMathMLBlock (anonymous)" : "RenderMathMLBlock";
154 }
155
156 #if ENABLE(DEBUG_MATH_LAYOUT)
157 void RenderMathMLBlock::paint(PaintInfo& info, const LayoutPoint& paintOffset)
158 {
159     RenderFlexibleBox::paint(info, paintOffset);
160     
161     if (info.context->paintingDisabled() || info.phase != PaintPhaseForeground)
162         return;
163
164     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
165
166     GraphicsContextStateSaver stateSaver(*info.context);
167     
168     info.context->setStrokeThickness(1.0f);
169     info.context->setStrokeStyle(SolidStroke);
170     info.context->setStrokeColor(Color(0, 0, 255), ColorSpaceSRGB);
171     
172     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y()));
173     info.context->drawLine(IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y()), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
174     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
175     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
176     
177     int topStart = paddingTop();
178     
179     info.context->setStrokeColor(Color(0, 255, 0), ColorSpaceSRGB);
180     
181     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + topStart), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + topStart));
182     
183     int baseline = roundToInt(baselinePosition(AlphabeticBaseline, true, HorizontalLine));
184     
185     info.context->setStrokeColor(Color(255, 0, 0), ColorSpaceSRGB);
186     
187     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + baseline), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + baseline));
188 }
189 #endif // ENABLE(DEBUG_MATH_LAYOUT)
190
191 //
192 // The MathML specification says:
193 // (http://www.w3.org/TR/MathML/chapter2.html#fund.units)
194 //
195 // "Most presentation elements have attributes that accept values representing
196 // lengths to be used for size, spacing or similar properties. The syntax of a
197 // length is specified as
198 //
199 // number | number unit | namedspace
200 //
201 // There should be no space between the number and the unit of a length."
202 // 
203 // "A trailing '%' represents a percent of the default value. The default
204 // value, or how it is obtained, is listed in the table of attributes for each
205 // element. [...] A number without a unit is intepreted as a multiple of the
206 // default value."
207 //
208 // "The possible units in MathML are:
209 //  
210 // Unit Description
211 // em   an em (font-relative unit traditionally used for horizontal lengths)
212 // ex   an ex (font-relative unit traditionally used for vertical lengths)
213 // px   pixels, or size of a pixel in the current display
214 // in   inches (1 inch = 2.54 centimeters)
215 // cm   centimeters
216 // mm   millimeters
217 // pt   points (1 point = 1/72 inch)
218 // pc   picas (1 pica = 12 points)
219 // %    percentage of default value"
220 //
221 // The numbers are defined that way:
222 // - unsigned-number: "a string of decimal digits with up to one decimal point
223 //   (U+002E), representing a non-negative terminating decimal number (a type of
224 //   rational number)"
225 // - number: "an optional prefix of '-' (U+002D), followed by an unsigned
226 //   number, representing a terminating decimal number (a type of rational
227 //   number)"
228 //
229 bool parseMathMLLength(const String& string, LayoutUnit& lengthValue, const RenderStyle* style, bool allowNegative)
230 {
231     String s = string.simplifyWhiteSpace();
232
233     int stringLength = s.length();
234     if (!stringLength)
235         return false;
236
237     if (parseMathMLNamedSpace(s, lengthValue, style, allowNegative))
238         return true;
239
240     StringBuilder number;
241     String unit;
242
243     // This verifies whether the negative sign is there.
244     int i = 0;
245     UChar c = s[0];
246     if (c == '-') {
247         number.append(c);
248         i++;
249     }
250
251     // This gathers up characters that make up the number.
252     bool gotDot = false;
253     for ( ; i < stringLength; i++) {
254         c = s[i];
255         // The string is invalid if it contains two dots.
256         if (gotDot && c == '.')
257             return false;
258         if (c == '.')
259             gotDot = true;
260         else if (!isASCIIDigit(c)) {
261             unit = s.substring(i, stringLength - i);
262             // Some authors leave blanks before the unit, but that shouldn't
263             // be allowed, so don't simplifyWhitespace on 'unit'.
264             break;
265         }
266         number.append(c);
267     }
268
269     // Convert number to floating point
270     bool ok;
271     float floatValue = number.toString().toFloat(&ok);
272     if (!ok)
273         return false;
274     if (floatValue < 0 && !allowNegative)
275         return false;
276
277     if (unit.isEmpty()) {
278         // no explicit unit, this is a number that will act as a multiplier
279         lengthValue *= floatValue;
280         return true;
281     }
282     if (unit == "%") {
283         lengthValue *= floatValue / 100;
284         return true;
285     }
286     if (unit == "em") {
287         lengthValue = floatValue * style->font().size();
288         return true;
289     }
290     if (unit == "ex") {
291         lengthValue = floatValue * style->fontMetrics().xHeight();
292         return true;
293     }
294     if (unit == "px") {
295         lengthValue = floatValue;
296         return true;
297     }
298     if (unit == "pt") {
299         lengthValue = 4 * (floatValue / 3);
300         return true;
301     }
302     if (unit == "pc") {
303         lengthValue = 16 * floatValue;
304         return true;
305     }
306     if (unit == "in") {
307         lengthValue = 96 * floatValue;
308         return true;
309     }
310     if (unit == "cm") {
311         lengthValue = 96 * (floatValue / 2.54);
312         return true;
313     }
314     if (unit == "mm") {
315         lengthValue = 96 * (floatValue / 25.4);
316         return true;
317     }
318
319     // unexpected unit
320     return false;
321 }
322
323 bool parseMathMLNamedSpace(const String& string, LayoutUnit& lengthValue, const RenderStyle* style, bool allowNegative)
324 {
325     float length = 0;
326     // See if it is one of the namedspaces (ranging -7/18em, -6/18, ... 7/18em)
327     if (string == "veryverythinmathspace")
328         length = 1;
329     else if (string == "verythinmathspace")
330         length = 2;
331     else if (string == "thinmathspace")
332         length = 3;
333     else if (string == "mediummathspace")
334         length = 4;
335     else if (string == "thickmathspace")
336         length = 5;
337     else if (string == "verythickmathspace")
338         length = 6;
339     else if (string == "veryverythickmathspace")
340         length = 7;
341     else if (allowNegative) {
342         if (string == "negativeveryverythinmathspace")
343             length = -1;
344         else if (string == "negativeverythinmathspace")
345             length = -2;
346         else if (string == "negativethinmathspace")
347             length = -3;
348         else if (string == "negativemediummathspace")
349             length = -4;
350         else if (string == "negativethickmathspace")
351             length = -5;
352         else if (string == "negativeverythickmathspace")
353             length = -6;
354         else if (string == "negativeveryverythickmathspace")
355             length = -7;        
356     }
357     if (length) {
358         lengthValue = length * style->font().size() / 18;
359         return true;
360     }
361     return false;
362 }
363
364 int RenderMathMLTable::firstLineBoxBaseline() const
365 {
366     // In legal MathML, we'll have a MathML parent. That RenderFlexibleBox parent will use our firstLineBoxBaseline() for baseline alignment, per
367     // http://dev.w3.org/csswg/css3-flexbox/#flex-baselines. We want to vertically center an <mtable>, such as a matrix. Essentially the whole <mtable> element fits on a
368     // single line, whose baseline gives this centering. This is different than RenderTable::firstLineBoxBaseline, which returns the baseline of the first row of a <table>.
369     return (logicalHeight() + style()->fontMetrics().xHeight()) / 2;
370 }
371
372 }    
373
374 #endif