ba91c29487774244e0400de9641e8a8e28a881b4
[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 {
50 }
51
52 bool RenderMathMLBlock::isChildAllowed(RenderObject* child, RenderStyle*) const
53 {
54     return child->node() && child->node()->nodeType() == Node::ELEMENT_NODE;
55 }
56
57 RenderMathMLBlock* RenderMathMLBlock::createAnonymousMathMLBlock(EDisplay display)
58 {
59     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), display);
60     RenderMathMLBlock* newBlock = new (renderArena()) RenderMathMLBlock(0);
61     newBlock->setDocumentForAnonymous(document());
62     newBlock->setStyle(newStyle.release());
63     return newBlock;
64 }
65
66 int RenderMathMLBlock::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
67 {
68     // mathml.css sets math { -webkit-line-box-contain: glyphs replaced; line-height: 0; }, so when linePositionMode == PositionOfInteriorLineBoxes we want to
69     // return 0 here to match our line-height. This matters when RootInlineBox::ascentAndDescentForBox is called on a RootInlineBox for an inline-block.
70     if (linePositionMode == PositionOfInteriorLineBoxes)
71         return 0;
72     
73     LayoutUnit baseline = firstLineBoxBaseline(); // FIXME: This may be unnecessary after flex baselines are implemented (https://bugs.webkit.org/show_bug.cgi?id=96188).
74     if (baseline != -1)
75         return baseline;
76     
77     return RenderFlexibleBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
78 }
79
80 const char* RenderMathMLBlock::renderName() const
81 {
82     EDisplay display = style()->display();
83     if (display == FLEX)
84         return isAnonymous() ? "RenderMathMLBlock (anonymous, flex)" : "RenderMathMLBlock (flex)";
85     if (display == INLINE_FLEX)
86         return isAnonymous() ? "RenderMathMLBlock (anonymous, inline-flex)" : "RenderMathMLBlock (inline-flex)";
87     // |display| should be one of the above.
88     ASSERT_NOT_REACHED();
89     return isAnonymous() ? "RenderMathMLBlock (anonymous)" : "RenderMathMLBlock";
90 }
91
92 #if ENABLE(DEBUG_MATH_LAYOUT)
93 void RenderMathMLBlock::paint(PaintInfo& info, const LayoutPoint& paintOffset)
94 {
95     RenderFlexibleBox::paint(info, paintOffset);
96     
97     if (info.context->paintingDisabled() || info.phase != PaintPhaseForeground)
98         return;
99
100     IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
101
102     GraphicsContextStateSaver stateSaver(*info.context);
103     
104     info.context->setStrokeThickness(1.0f);
105     info.context->setStrokeStyle(SolidStroke);
106     info.context->setStrokeColor(Color(0, 0, 255), ColorSpaceSRGB);
107     
108     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y()));
109     info.context->drawLine(IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y()), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
110     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
111     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + pixelSnappedOffsetHeight()));
112     
113     int topStart = paddingTop();
114     
115     info.context->setStrokeColor(Color(0, 255, 0), ColorSpaceSRGB);
116     
117     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + topStart), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + topStart));
118     
119     int baseline = roundToInt(baselinePosition(AlphabeticBaseline, true, HorizontalLine));
120     
121     info.context->setStrokeColor(Color(255, 0, 0), ColorSpaceSRGB);
122     
123     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + baseline), IntPoint(adjustedPaintOffset.x() + pixelSnappedOffsetWidth(), adjustedPaintOffset.y() + baseline));
124 }
125 #endif // ENABLE(DEBUG_MATH_LAYOUT)
126
127 //
128 // The MathML specification says:
129 // (http://www.w3.org/TR/MathML/chapter2.html#fund.units)
130 //
131 // "Most presentation elements have attributes that accept values representing
132 // lengths to be used for size, spacing or similar properties. The syntax of a
133 // length is specified as
134 //
135 // number | number unit | namedspace
136 //
137 // There should be no space between the number and the unit of a length."
138 // 
139 // "A trailing '%' represents a percent of the default value. The default
140 // value, or how it is obtained, is listed in the table of attributes for each
141 // element. [...] A number without a unit is intepreted as a multiple of the
142 // default value."
143 //
144 // "The possible units in MathML are:
145 //  
146 // Unit Description
147 // em   an em (font-relative unit traditionally used for horizontal lengths)
148 // ex   an ex (font-relative unit traditionally used for vertical lengths)
149 // px   pixels, or size of a pixel in the current display
150 // in   inches (1 inch = 2.54 centimeters)
151 // cm   centimeters
152 // mm   millimeters
153 // pt   points (1 point = 1/72 inch)
154 // pc   picas (1 pica = 12 points)
155 // %    percentage of default value"
156 //
157 // The numbers are defined that way:
158 // - unsigned-number: "a string of decimal digits with up to one decimal point
159 //   (U+002E), representing a non-negative terminating decimal number (a type of
160 //   rational number)"
161 // - number: "an optional prefix of '-' (U+002D), followed by an unsigned
162 //   number, representing a terminating decimal number (a type of rational
163 //   number)"
164 //
165 bool parseMathMLLength(const String& string, LayoutUnit& lengthValue, const RenderStyle* style, bool allowNegative)
166 {
167     String s = string.simplifyWhiteSpace();
168
169     int stringLength = s.length();
170     if (!stringLength)
171         return false;
172
173     if (parseMathMLNamedSpace(s, lengthValue, style, allowNegative))
174         return true;
175
176     StringBuilder number;
177     String unit;
178
179     // This verifies whether the negative sign is there.
180     int i = 0;
181     UChar c = s[0];
182     if (c == '-') {
183         number.append(c);
184         i++;
185     }
186
187     // This gathers up characters that make up the number.
188     bool gotDot = false;
189     for ( ; i < stringLength; i++) {
190         c = s[i];
191         // The string is invalid if it contains two dots.
192         if (gotDot && c == '.')
193             return false;
194         if (c == '.')
195             gotDot = true;
196         else if (!isASCIIDigit(c)) {
197             unit = s.substring(i, stringLength - i);
198             // Some authors leave blanks before the unit, but that shouldn't
199             // be allowed, so don't simplifyWhitespace on 'unit'.
200             break;
201         }
202         number.append(c);
203     }
204
205     // Convert number to floating point
206     bool ok;
207     float floatValue = number.toString().toFloat(&ok);
208     if (!ok)
209         return false;
210     if (floatValue < 0 && !allowNegative)
211         return false;
212
213     if (unit.isEmpty()) {
214         // no explicit unit, this is a number that will act as a multiplier
215         lengthValue *= floatValue;
216         return true;
217     }
218     if (unit == "%") {
219         lengthValue *= floatValue / 100;
220         return true;
221     }
222     if (unit == "em") {
223         lengthValue = floatValue * style->font().size();
224         return true;
225     }
226     if (unit == "ex") {
227         lengthValue = floatValue * style->fontMetrics().xHeight();
228         return true;
229     }
230     if (unit == "px") {
231         lengthValue = floatValue;
232         return true;
233     }
234     if (unit == "pt") {
235         lengthValue = 4 * (floatValue / 3);
236         return true;
237     }
238     if (unit == "pc") {
239         lengthValue = 16 * floatValue;
240         return true;
241     }
242     if (unit == "in") {
243         lengthValue = 96 * floatValue;
244         return true;
245     }
246     if (unit == "cm") {
247         lengthValue = 96 * (floatValue / 2.54);
248         return true;
249     }
250     if (unit == "mm") {
251         lengthValue = 96 * (floatValue / 25.4);
252         return true;
253     }
254
255     // unexpected unit
256     return false;
257 }
258
259 bool parseMathMLNamedSpace(const String& string, LayoutUnit& lengthValue, const RenderStyle* style, bool allowNegative)
260 {
261     float length = 0;
262     // See if it is one of the namedspaces (ranging -7/18em, -6/18, ... 7/18em)
263     if (string == "veryverythinmathspace")
264         length = 1;
265     else if (string == "verythinmathspace")
266         length = 2;
267     else if (string == "thinmathspace")
268         length = 3;
269     else if (string == "mediummathspace")
270         length = 4;
271     else if (string == "thickmathspace")
272         length = 5;
273     else if (string == "verythickmathspace")
274         length = 6;
275     else if (string == "veryverythickmathspace")
276         length = 7;
277     else if (allowNegative) {
278         if (string == "negativeveryverythinmathspace")
279             length = -1;
280         else if (string == "negativeverythinmathspace")
281             length = -2;
282         else if (string == "negativethinmathspace")
283             length = -3;
284         else if (string == "negativemediummathspace")
285             length = -4;
286         else if (string == "negativethickmathspace")
287             length = -5;
288         else if (string == "negativeverythickmathspace")
289             length = -6;
290         else if (string == "negativeveryverythickmathspace")
291             length = -7;        
292     }
293     if (length) {
294         lengthValue = length * style->font().size() / 18;
295         return true;
296     }
297     return false;
298 }
299
300 int RenderMathMLTable::firstLineBoxBaseline() const
301 {
302     // In legal MathML, we'll have a MathML parent. That RenderFlexibleBox parent will use our firstLineBoxBaseline() for baseline alignment, per
303     // 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
304     // single line, whose baseline gives this centering. This is different than RenderTable::firstLineBoxBaseline, which returns the baseline of the first row of a <table>.
305     return (logicalHeight() + style()->fontMetrics().xHeight()) / 2;
306 }
307
308 }    
309
310 #endif