Draw radicals with glyphs for better rendering
authorfred.wang@free.fr <fred.wang@free.fr@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 16 Jun 2014 10:07:32 +0000 (10:07 +0000)
committerfred.wang@free.fr <fred.wang@free.fr@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 16 Jun 2014 10:07:32 +0000 (10:07 +0000)
https://bugs.webkit.org/show_bug.cgi?id=119038

Reviewed by Chris Fleizach.

Source/WebCore:
We rewrite RenderMathMLRoot in order to fix bugs with SVG transforms and dynamic modification of children and allow drawing with an OpenType MATH table.
The drawing of the radical sign (without the top bar) is now moved to a RenderMathMLRadicalOperator class inheriting from RenderMathMLOperator.
This class fallbacks to the original drawing with graphic primitives if an OpenType MATH table is not available.

Tests: mathml/opentype/roots-LatinModern.html
       mathml/presentation/mroot-transform.html

* CMakeLists.txt: add files to build system.
* WebCore.vcxproj/WebCore.vcxproj: ditto.
* WebCore.vcxproj/WebCore.vcxproj.filters: ditto.
* WebCore.xcodeproj/project.pbxproj: ditto
* css/mathml.css: remove rules for msqrt/mroot. The "script level" in mroot is not incremented by 2 as specified in the spec.
(math, mrow, mfenced, merror, mphantom, mstyle, menclose):
(mroot > *:last-child):
(math, mrow, mfenced, msqrt, mroot, merror, mphantom, mstyle, menclose): Deleted.
(msqrt > *): Deleted.
(mroot): Deleted. This rule was causing bug 126516.
(mroot > * + *): Deleted.
* rendering/RenderObject.h: Add two new isRenderMathML* functions for dynamic casting.
(WebCore::RenderObject::isRenderMathMLRadicalOperator):
(WebCore::RenderObject::isRenderMathMLRootWrapper):
* rendering/mathml/RenderMathMLOperator.cpp: Accept a set of operator dictionary flags, all disabled by default. This is to allow anonymous radicas, which don't have any flag.
isFencedOperator() is now replaced with the more general isAnonymous() since we allow anonymous radical operator fors msqrt/mroot.
(WebCore::RenderMathMLOperator::RenderMathMLOperator):
(WebCore::RenderMathMLOperator::setOperatorFlagFromAttribute):
(WebCore::RenderMathMLOperator::setOperatorPropertiesFromOpDictEntry):
(WebCore::RenderMathMLOperator::SetOperatorProperties):
(WebCore::RenderMathMLOperator::updateTokenContent):
* rendering/mathml/RenderMathMLOperator.h: Allow class to be overriden, redefine the anonymous constructor, remove isFencedOperator().
* rendering/mathml/RenderMathMLRadicalOperator.cpp: Added.
(WebCore::RenderMathMLRadicalOperator::RenderMathMLRadicalOperator):
(WebCore::RenderMathMLRadicalOperator::stretchTo):
(WebCore::RenderMathMLRadicalOperator::SetOperatorProperties):
(WebCore::RenderMathMLRadicalOperator::computePreferredLogicalWidths):
(WebCore::RenderMathMLRadicalOperator::computeLogicalHeight):
(WebCore::RenderMathMLRadicalOperator::paint):
(WebCore::RenderMathMLRadicalOperator::trailingSpaceError):
* rendering/mathml/RenderMathMLRadicalOperator.h: Added.
* rendering/mathml/RenderMathMLRoot.cpp: Rewritten. Some parts to use graphic primitives are moved to RenderMathMLRadicalOperator.cpp.
(WebCore::RenderMathMLRoot::RenderMathMLRoot):
(WebCore::RenderMathMLRoot::baseWrapper):
(WebCore::RenderMathMLRoot::radicalWrapper):
(WebCore::RenderMathMLRoot::indexWrapper):
(WebCore::RenderMathMLRoot::radicalOperator):
(WebCore::RenderMathMLRoot::restructureWrappers):
(WebCore::RenderMathMLRoot::addChild):
(WebCore::RenderMathMLRoot::styleDidChange):
(WebCore::RenderMathMLRoot::updateFromElement):
(WebCore::RenderMathMLRoot::updateStyle):
(WebCore::RenderMathMLRoot::firstLineBaseline):
(WebCore::RenderMathMLRoot::layout):
(WebCore::RenderMathMLRoot::paint):
(WebCore::RenderMathMLRootWrapper::createAnonymousWrapper):
(WebCore::RenderMathMLRootWrapper::removeChildWithoutRestructuring):
(WebCore::RenderMathMLRootWrapper::removeChild):
(WebCore::RenderMathMLRoot::paddingTop): Deleted.
(WebCore::RenderMathMLRoot::paddingBottom): Deleted.
(WebCore::RenderMathMLRoot::paddingLeft): Deleted.
(WebCore::RenderMathMLRoot::paddingRight): Deleted.
(WebCore::RenderMathMLRoot::paddingBefore): Deleted.
(WebCore::RenderMathMLRoot::paddingAfter): Deleted.
(WebCore::RenderMathMLRoot::paddingStart): Deleted.
(WebCore::RenderMathMLRoot::paddingEnd): Deleted.
(WebCore::RenderMathMLRoot::index): Deleted.
* rendering/mathml/RenderMathMLRoot.h: Rewritten.
(WebCore::RenderMathMLRootWrapper::RenderMathMLRootWrapper):

LayoutTests:
We update the reference for some tests with radicals and update the expectation of tests for addition/removal of children in an msqrt/mroot element.
We also add a test for bug 126516 (SVG transforms not applied to mroot) and a new test for radical drawing using an OpenType MATH table.

* TestExpectations: enable the tests for addition/removal of children.
* mathml/opentype/roots-LatinModern.html: Added.
* mathml/presentation/mroot-transform-expected.html: Added.
* mathml/presentation/mroot-transform.html: Added.
* platform/efl/TestExpectations: mark failures for bad references.
* platform/efl/mathml/opentype/roots-LatinModern-expected.txt: Added.
* platform/gtk/mathml/opentype/roots-LatinModern-expected.png: Added.
* platform/gtk/mathml/opentype/roots-LatinModern-expected.txt: Added.
* platform/gtk/mathml/presentation/mo-stretch-expected.png: update reference.
* platform/gtk/mathml/presentation/mo-stretch-expected.txt: update reference.
* platform/gtk/mathml/presentation/roots-expected.png: update reference.
* platform/gtk/mathml/presentation/roots-expected.txt: update reference.
* platform/mac/TestExpectations: mark failures for bad references.
* platform/mac/mathml/opentype/roots-LatinModern-expected.txt: Added.
* platform/win/TestExpectations: mark failures for bad references.
* platform/win/mathml/opentype/roots-LatinModern-expected.txt: Added.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@170005 268f45cc-cd09-0410-ab3c-d52691b4dbfc

30 files changed:
LayoutTests/ChangeLog
LayoutTests/TestExpectations
LayoutTests/mathml/opentype/roots-LatinModern.html [new file with mode: 0644]
LayoutTests/mathml/presentation/mroot-transform-expected.html [new file with mode: 0644]
LayoutTests/mathml/presentation/mroot-transform.html [new file with mode: 0644]
LayoutTests/platform/efl/TestExpectations
LayoutTests/platform/efl/mathml/opentype/roots-LatinModern-expected.txt [new file with mode: 0644]
LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.png [new file with mode: 0644]
LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.txt [new file with mode: 0644]
LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.png
LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.txt
LayoutTests/platform/gtk/mathml/presentation/roots-expected.png
LayoutTests/platform/gtk/mathml/presentation/roots-expected.txt
LayoutTests/platform/mac/TestExpectations
LayoutTests/platform/mac/mathml/opentype/roots-LatinModern-expected.txt [new file with mode: 0644]
LayoutTests/platform/win/TestExpectations
LayoutTests/platform/win/mathml/opentype/roots-LatinModern-expected.txt [new file with mode: 0644]
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/WebCore.vcxproj/WebCore.vcxproj
Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/css/mathml.css
Source/WebCore/rendering/RenderObject.h
Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp
Source/WebCore/rendering/mathml/RenderMathMLOperator.h
Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.cpp [new file with mode: 0644]
Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.h [new file with mode: 0644]
Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp
Source/WebCore/rendering/mathml/RenderMathMLRoot.h

index 33fd0f8..653f727 100644 (file)
@@ -1,3 +1,30 @@
+2014-06-16  Frédéric Wang  <fred.wang@free.fr>
+
+        Draw radicals with glyphs for better rendering
+        https://bugs.webkit.org/show_bug.cgi?id=119038
+
+        Reviewed by Chris Fleizach.
+
+        We update the reference for some tests with radicals and update the expectation of tests for addition/removal of children in an msqrt/mroot element.
+        We also add a test for bug 126516 (SVG transforms not applied to mroot) and a new test for radical drawing using an OpenType MATH table.
+
+        * TestExpectations: enable the tests for addition/removal of children.
+        * mathml/opentype/roots-LatinModern.html: Added.
+        * mathml/presentation/mroot-transform-expected.html: Added.
+        * mathml/presentation/mroot-transform.html: Added.
+        * platform/efl/TestExpectations: mark failures for bad references.
+        * platform/efl/mathml/opentype/roots-LatinModern-expected.txt: Added.
+        * platform/gtk/mathml/opentype/roots-LatinModern-expected.png: Added.
+        * platform/gtk/mathml/opentype/roots-LatinModern-expected.txt: Added.
+        * platform/gtk/mathml/presentation/mo-stretch-expected.png: update reference.
+        * platform/gtk/mathml/presentation/mo-stretch-expected.txt: update reference.
+        * platform/gtk/mathml/presentation/roots-expected.png: update reference.
+        * platform/gtk/mathml/presentation/roots-expected.txt: update reference.
+        * platform/mac/TestExpectations: mark failures for bad references.
+        * platform/mac/mathml/opentype/roots-LatinModern-expected.txt: Added.
+        * platform/win/TestExpectations: mark failures for bad references.
+        * platform/win/mathml/opentype/roots-LatinModern-expected.txt: Added.
+
 2014-06-16  Andrzej Badowski  <a.badowski@samsung.com>
 
         [EFL] Change expectations for three failing or flaky layout tests.
index 8715037..c797cf1 100644 (file)
@@ -67,10 +67,8 @@ webkit.org/b/126166 [ Debug ] js/dfg-uint32array-overflow-values.html [ Skip ]
 
 webkit.org/b/127860 [ Debug ] js/function-apply-aliased.html [ Skip ]
 
-# These tests verify dynamic manipulation of the mroot and msqrt elements.
-# Unfortunately, the current MathML code does not handle them well.
-webkit.org/b/119038 mathml/roots-addChild.html [ Skip ]
-webkit.org/b/119038 mathml/roots-removeChild.html [ Skip ]
+# This test verifies dynamic manipulation of the mroot and msqrt elements.
+mathml/roots-removeChild.html [ ImageOnlyFailure ]
 
 # This test verifies that a mismatch reftest will fail as intended if both results are same. (introduced in r93187)
 fast/harness/sample-fail-mismatch-reftest.html [ WontFix ImageOnlyFailure ]
diff --git a/LayoutTests/mathml/opentype/roots-LatinModern.html b/LayoutTests/mathml/opentype/roots-LatinModern.html
new file mode 100644 (file)
index 0000000..94a2b2d
--- /dev/null
@@ -0,0 +1,80 @@
+<!doctype html>
+<html> 
+  <head>
+    <title>Roots Latin Modern</title>
+    <meta charset="utf-8"/>
+    <style type="text/css">
+      @font-face {
+      font-family: "Latin Modern Math";
+      src: local("Latin Modern Math"), local("LatinModernMath-Regular"), url("latinmodern-math.woff");
+      }
+      math {
+      font-family: "Latin Modern Math";
+      }      
+    </style>
+  </head>
+  <body>
+
+    <!-- We test the rendering roots with the Latin Modern Math font -->
+
+    <!-- nested square roots of various sizes -->
+    <math display="block">
+      <mrow>
+        <msqrt>
+          <mn>1</mn>
+          <mo>+</mo>
+          <msqrt>
+            <mn>1</mn>
+            <mo>+</mo>
+            <msqrt>
+              <mn>1</mn>
+              <mo>+</mo>
+              <msqrt>
+                <mn>1</mn>
+                <mo>+</mo>
+                <msqrt>
+                  <mn>1</mn>
+                  <mo>+</mo>
+                  <msqrt>
+                    <mn>1</mn>
+                    <mo>+</mo>
+                    <msqrt>
+                      <mn>1</mn>
+                      <mo>+</mo>
+                      <mi>x</mi>
+                    </msqrt>
+                  </msqrt>
+                </msqrt>
+              </msqrt>
+            </msqrt>
+          </msqrt>
+        </msqrt>
+      </mrow>
+    </math>
+
+    <!-- mroot with short index -->
+    <math display="block">
+      <mroot>
+        <mspace width="20px" height="50px" mathbackground="red"/>
+        <mspace width="20px" height="10px" mathbackground="green"/>
+      </mroot>
+      <mroot>
+        <mspace width="20px" height="20px" mathbackground="red"/>
+        <mspace width="20px" height="5px" mathbackground="blue"/>
+      </mroot>
+    </math>
+
+    <!-- mroot with tall index -->
+    <math display="block">
+      <mroot>
+        <mspace width="20px" height="50px" mathbackground="red"/>
+        <mspace width="20px" height="50px" mathbackground="green"/>
+      </mroot>
+      <mroot>
+        <mspace width="20px" height="20px" mathbackground="red"/>
+        <mspace width="20px" height="20px" mathbackground="blue"/>
+      </mroot>
+    </math>
+
+  </body>
+</html>
diff --git a/LayoutTests/mathml/presentation/mroot-transform-expected.html b/LayoutTests/mathml/presentation/mroot-transform-expected.html
new file mode 100644 (file)
index 0000000..55f0848
--- /dev/null
@@ -0,0 +1,17 @@
+<!doctype html>
+<html>
+  <head>
+    <title>mroot transform (bug 126516)</title>
+  </head>
+  <body>
+
+    <div style="position: absolute; top: 0; left: 0;">
+      <svg>
+        <g transform="translate(200,0)">
+          <rect width="100" height="100" fill="red"/>
+        </g>
+      </svg>
+    </div>
+
+  </body>
+</html>
diff --git a/LayoutTests/mathml/presentation/mroot-transform.html b/LayoutTests/mathml/presentation/mroot-transform.html
new file mode 100644 (file)
index 0000000..6ef325b
--- /dev/null
@@ -0,0 +1,33 @@
+<!doctype html>
+<html>
+  <head>
+    <title>mroot transform (bug 126516)</title>
+  </head>
+  <body>
+
+    <!-- This cubic root should be translated to the left... -->
+    <div style="position: absolute; top: 0; left: 0;">
+      <svg>
+        <g transform="translate(200,0)">
+          <switch>
+            <foreignObject width="100" height="100">
+              <math>
+                <mroot><mi>x</mi><mn>3</mn></mroot>
+              </math>
+            </foreignObject>
+          </switch>
+        </g>
+      </svg>
+    </div>
+
+    <!-- ... and thus hidden by this red rectangle. -->
+    <div style="position: absolute; top: 0; left: 0;">
+      <svg>
+        <g transform="translate(200,0)">
+          <rect width="100" height="100" fill="red"/>
+        </g>
+      </svg>
+    </div>
+
+  </body>
+</html>
index 20143b3..f83e269 100644 (file)
@@ -1635,6 +1635,9 @@ webkit.org/b/130322 mathml/opentype/vertical-LatinModern.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/opentype-stretchy-horizontal.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern-munderover.html [ Failure ]
+webkit.org/b/119038 mathml/opentype/roots-LatinModern.html [ Failure ]
+webkit.org/b/119038 mathml/presentation/mo-stretch.html [ Failure ]
+webkit.org/b/119038 mathml/presentation/roots.xhtml [ Failure ]
 
 # Failures EFL since the inception
 webkit.org/b/133734 css3/viewport-percentage-lengths/viewport-percentage-lengths-anonymous-block.html [ Failure ]
diff --git a/LayoutTests/platform/efl/mathml/opentype/roots-LatinModern-expected.txt b/LayoutTests/platform/efl/mathml/opentype/roots-LatinModern-expected.txt
new file mode 100644 (file)
index 0000000..ba958d5
--- /dev/null
@@ -0,0 +1,184 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x259
+  RenderBlock {HTML} at (0,0) size 800x260
+    RenderBody {BODY} at (8,8) size 784x236
+      RenderMathMLMath {math} at (0,0) size 784x53 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (232,0) size 320x53
+          RenderMathMLSquareRoot {msqrt} at (0,0) size 319x53
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x53
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x53
+                  RenderBlock (anonymous) at (0,0) size 13x53
+                    RenderText at (0,-56) size 13x106
+                      text run at (0,-56) width 13: "\x{221A}"
+            RenderMathMLRootWrapper at (17,2) size 302x51
+              RenderMathMLToken {mn} at (0,12) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-46) size 8x106
+                      text run at (0,-46) width 8: "1"
+              RenderMathMLOperator {mo} at (8,13) size 20x12
+                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                  RenderBlock (anonymous) at (0,0) size 12x12
+                    RenderText at (0,-47) size 12x106
+                      text run at (0,-47) width 12: "+"
+              RenderMathMLSquareRoot {msqrt} at (27,0) size 275x51
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x51
+                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x51
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x51
+                      RenderBlock (anonymous) at (0,0) size 13x51
+                        RenderText at (0,-56) size 13x106
+                          text run at (0,-56) width 13: "\x{221A}"
+                RenderMathMLRootWrapper at (17,2) size 258x49
+                  RenderMathMLToken {mn} at (0,10) size 8x12
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                      RenderBlock (anonymous) at (0,0) size 8x12
+                        RenderText {#text} at (0,-46) size 8x106
+                          text run at (0,-46) width 8: "1"
+                  RenderMathMLOperator {mo} at (8,11) size 20x12
+                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                      RenderBlock (anonymous) at (0,0) size 12x12
+                        RenderText at (0,-47) size 12x106
+                          text run at (0,-47) width 12: "+"
+                  RenderMathMLSquareRoot {msqrt} at (27,0) size 231x49
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x49
+                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x49
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x48
+                          RenderBlock (anonymous) at (0,0) size 13x48
+                            RenderText at (0,-56) size 13x106
+                              text run at (0,-56) width 13: "\x{221A}"
+                    RenderMathMLRootWrapper at (17,2) size 214x47
+                      RenderMathMLToken {mn} at (0,8) size 8x12
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                          RenderBlock (anonymous) at (0,0) size 8x12
+                            RenderText {#text} at (0,-46) size 8x106
+                              text run at (0,-46) width 8: "1"
+                      RenderMathMLOperator {mo} at (8,9) size 20x12
+                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                          RenderBlock (anonymous) at (0,0) size 12x12
+                            RenderText at (0,-47) size 12x106
+                              text run at (0,-47) width 12: "+"
+                      RenderMathMLSquareRoot {msqrt} at (27,0) size 187x41
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 17x41
+                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x41
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x40
+                              RenderBlock (anonymous) at (0,0) size 13x40
+                                RenderText at (0,-56) size 13x106
+                                  text run at (0,-56) width 13: "\x{221A}"
+                        RenderMathMLRootWrapper at (17,2) size 169x39
+                          RenderMathMLToken {mn} at (0,6) size 8x12
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                              RenderBlock (anonymous) at (0,0) size 8x12
+                                RenderText {#text} at (0,-46) size 8x106
+                                  text run at (0,-46) width 8: "1"
+                          RenderMathMLOperator {mo} at (8,7) size 20x12
+                            RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                              RenderBlock (anonymous) at (0,0) size 12x12
+                                RenderText at (0,-47) size 12x106
+                                  text run at (0,-47) width 12: "+"
+                          RenderMathMLSquareRoot {msqrt} at (27,0) size 142x31
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x31
+                              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                                  RenderBlock (anonymous) at (0,0) size 13x30
+                                    RenderText at (0,-56) size 13x106
+                                      text run at (0,-56) width 13: "\x{221A}"
+                            RenderMathMLRootWrapper at (17,2) size 125x29
+                              RenderMathMLToken {mn} at (0,4) size 8x12
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                  RenderBlock (anonymous) at (0,0) size 8x12
+                                    RenderText {#text} at (0,-46) size 8x106
+                                      text run at (0,-46) width 8: "1"
+                              RenderMathMLOperator {mo} at (8,5) size 20x12
+                                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                  RenderBlock (anonymous) at (0,0) size 12x12
+                                    RenderText at (0,-47) size 12x106
+                                      text run at (0,-47) width 12: "+"
+                              RenderMathMLSquareRoot {msqrt} at (27,0) size 98x21
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x21
+                                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x21
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x20
+                                      RenderBlock (anonymous) at (0,0) size 13x20
+                                        RenderText at (0,-56) size 13x106
+                                          text run at (0,-56) width 13: "\x{221A}"
+                                RenderMathMLRootWrapper at (17,2) size 81x19
+                                  RenderMathMLToken {mn} at (0,2) size 8x12
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                      RenderBlock (anonymous) at (0,0) size 8x12
+                                        RenderText {#text} at (0,-46) size 8x106
+                                          text run at (0,-46) width 8: "1"
+                                  RenderMathMLOperator {mo} at (8,3) size 20x12
+                                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                      RenderBlock (anonymous) at (0,0) size 12x12
+                                        RenderText at (0,-47) size 12x106
+                                          text run at (0,-47) width 12: "+"
+                                  RenderMathMLSquareRoot {msqrt} at (27,0) size 54x18
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x18
+                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x18
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x17
+                                          RenderBlock (anonymous) at (0,0) size 13x17
+                                            RenderText at (0,-56) size 13x106
+                                              text run at (0,-56) width 13: "\x{221A}"
+                                    RenderMathMLRootWrapper at (17,2) size 37x16
+                                      RenderMathMLToken {mn} at (0,0) size 8x12
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                          RenderBlock (anonymous) at (0,0) size 8x12
+                                            RenderText {#text} at (0,-46) size 8x106
+                                              text run at (0,-46) width 8: "1"
+                                      RenderMathMLOperator {mo} at (8,1) size 20x12
+                                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                          RenderBlock (anonymous) at (0,0) size 12x12
+                                            RenderText at (0,-47) size 12x106
+                                              text run at (0,-47) width 12: "+"
+                                      RenderMathMLToken {mi} at (27,4) size 10x8 [padding: 0 2 0 0]
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x8
+                                          RenderBlock (anonymous) at (0,0) size 8x8
+                                            RenderText {#text} at (0,-50) size 8x106
+                                              text run at (0,-50) width 8: "x"
+      RenderMathMLMath {math} at (0,68) size 784x62 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x53
+          RenderMathMLRootWrapper at (4,10) size 21x43
+            RenderMathMLSpace {mspace} at (0,0) size 20x10 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x53
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,30) size 53x31
+          RenderMathMLRootWrapper at (4,7) size 21x24
+            RenderMathMLSpace {mspace} at (0,0) size 20x5 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x31
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
+      RenderMathMLMath {math} at (0,145) size 784x91 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x82
+          RenderMathMLRootWrapper at (4,0) size 21x82
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x82
+            RenderMathMLRadicalOperator (anonymous) at (0,29) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,31) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,52) size 53x38
+          RenderMathMLRootWrapper at (4,0) size 21x38
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x38
+            RenderMathMLRadicalOperator (anonymous) at (0,8) size 17x30
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,9) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
diff --git a/LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.png b/LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.png
new file mode 100644 (file)
index 0000000..25ccf53
Binary files /dev/null and b/LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.png differ
diff --git a/LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.txt b/LayoutTests/platform/gtk/mathml/opentype/roots-LatinModern-expected.txt
new file mode 100644 (file)
index 0000000..ba958d5
--- /dev/null
@@ -0,0 +1,184 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x259
+  RenderBlock {HTML} at (0,0) size 800x260
+    RenderBody {BODY} at (8,8) size 784x236
+      RenderMathMLMath {math} at (0,0) size 784x53 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (232,0) size 320x53
+          RenderMathMLSquareRoot {msqrt} at (0,0) size 319x53
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x53
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x53
+                  RenderBlock (anonymous) at (0,0) size 13x53
+                    RenderText at (0,-56) size 13x106
+                      text run at (0,-56) width 13: "\x{221A}"
+            RenderMathMLRootWrapper at (17,2) size 302x51
+              RenderMathMLToken {mn} at (0,12) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-46) size 8x106
+                      text run at (0,-46) width 8: "1"
+              RenderMathMLOperator {mo} at (8,13) size 20x12
+                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                  RenderBlock (anonymous) at (0,0) size 12x12
+                    RenderText at (0,-47) size 12x106
+                      text run at (0,-47) width 12: "+"
+              RenderMathMLSquareRoot {msqrt} at (27,0) size 275x51
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x51
+                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x51
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x51
+                      RenderBlock (anonymous) at (0,0) size 13x51
+                        RenderText at (0,-56) size 13x106
+                          text run at (0,-56) width 13: "\x{221A}"
+                RenderMathMLRootWrapper at (17,2) size 258x49
+                  RenderMathMLToken {mn} at (0,10) size 8x12
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                      RenderBlock (anonymous) at (0,0) size 8x12
+                        RenderText {#text} at (0,-46) size 8x106
+                          text run at (0,-46) width 8: "1"
+                  RenderMathMLOperator {mo} at (8,11) size 20x12
+                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                      RenderBlock (anonymous) at (0,0) size 12x12
+                        RenderText at (0,-47) size 12x106
+                          text run at (0,-47) width 12: "+"
+                  RenderMathMLSquareRoot {msqrt} at (27,0) size 231x49
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x49
+                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x49
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x48
+                          RenderBlock (anonymous) at (0,0) size 13x48
+                            RenderText at (0,-56) size 13x106
+                              text run at (0,-56) width 13: "\x{221A}"
+                    RenderMathMLRootWrapper at (17,2) size 214x47
+                      RenderMathMLToken {mn} at (0,8) size 8x12
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                          RenderBlock (anonymous) at (0,0) size 8x12
+                            RenderText {#text} at (0,-46) size 8x106
+                              text run at (0,-46) width 8: "1"
+                      RenderMathMLOperator {mo} at (8,9) size 20x12
+                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                          RenderBlock (anonymous) at (0,0) size 12x12
+                            RenderText at (0,-47) size 12x106
+                              text run at (0,-47) width 12: "+"
+                      RenderMathMLSquareRoot {msqrt} at (27,0) size 187x41
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 17x41
+                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x41
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x40
+                              RenderBlock (anonymous) at (0,0) size 13x40
+                                RenderText at (0,-56) size 13x106
+                                  text run at (0,-56) width 13: "\x{221A}"
+                        RenderMathMLRootWrapper at (17,2) size 169x39
+                          RenderMathMLToken {mn} at (0,6) size 8x12
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                              RenderBlock (anonymous) at (0,0) size 8x12
+                                RenderText {#text} at (0,-46) size 8x106
+                                  text run at (0,-46) width 8: "1"
+                          RenderMathMLOperator {mo} at (8,7) size 20x12
+                            RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                              RenderBlock (anonymous) at (0,0) size 12x12
+                                RenderText at (0,-47) size 12x106
+                                  text run at (0,-47) width 12: "+"
+                          RenderMathMLSquareRoot {msqrt} at (27,0) size 142x31
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x31
+                              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                                  RenderBlock (anonymous) at (0,0) size 13x30
+                                    RenderText at (0,-56) size 13x106
+                                      text run at (0,-56) width 13: "\x{221A}"
+                            RenderMathMLRootWrapper at (17,2) size 125x29
+                              RenderMathMLToken {mn} at (0,4) size 8x12
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                  RenderBlock (anonymous) at (0,0) size 8x12
+                                    RenderText {#text} at (0,-46) size 8x106
+                                      text run at (0,-46) width 8: "1"
+                              RenderMathMLOperator {mo} at (8,5) size 20x12
+                                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                  RenderBlock (anonymous) at (0,0) size 12x12
+                                    RenderText at (0,-47) size 12x106
+                                      text run at (0,-47) width 12: "+"
+                              RenderMathMLSquareRoot {msqrt} at (27,0) size 98x21
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x21
+                                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x21
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x20
+                                      RenderBlock (anonymous) at (0,0) size 13x20
+                                        RenderText at (0,-56) size 13x106
+                                          text run at (0,-56) width 13: "\x{221A}"
+                                RenderMathMLRootWrapper at (17,2) size 81x19
+                                  RenderMathMLToken {mn} at (0,2) size 8x12
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                      RenderBlock (anonymous) at (0,0) size 8x12
+                                        RenderText {#text} at (0,-46) size 8x106
+                                          text run at (0,-46) width 8: "1"
+                                  RenderMathMLOperator {mo} at (8,3) size 20x12
+                                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                      RenderBlock (anonymous) at (0,0) size 12x12
+                                        RenderText at (0,-47) size 12x106
+                                          text run at (0,-47) width 12: "+"
+                                  RenderMathMLSquareRoot {msqrt} at (27,0) size 54x18
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x18
+                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x18
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x17
+                                          RenderBlock (anonymous) at (0,0) size 13x17
+                                            RenderText at (0,-56) size 13x106
+                                              text run at (0,-56) width 13: "\x{221A}"
+                                    RenderMathMLRootWrapper at (17,2) size 37x16
+                                      RenderMathMLToken {mn} at (0,0) size 8x12
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                          RenderBlock (anonymous) at (0,0) size 8x12
+                                            RenderText {#text} at (0,-46) size 8x106
+                                              text run at (0,-46) width 8: "1"
+                                      RenderMathMLOperator {mo} at (8,1) size 20x12
+                                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                          RenderBlock (anonymous) at (0,0) size 12x12
+                                            RenderText at (0,-47) size 12x106
+                                              text run at (0,-47) width 12: "+"
+                                      RenderMathMLToken {mi} at (27,4) size 10x8 [padding: 0 2 0 0]
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x8
+                                          RenderBlock (anonymous) at (0,0) size 8x8
+                                            RenderText {#text} at (0,-50) size 8x106
+                                              text run at (0,-50) width 8: "x"
+      RenderMathMLMath {math} at (0,68) size 784x62 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x53
+          RenderMathMLRootWrapper at (4,10) size 21x43
+            RenderMathMLSpace {mspace} at (0,0) size 20x10 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x53
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,30) size 53x31
+          RenderMathMLRootWrapper at (4,7) size 21x24
+            RenderMathMLSpace {mspace} at (0,0) size 20x5 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x31
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
+      RenderMathMLMath {math} at (0,145) size 784x91 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x82
+          RenderMathMLRootWrapper at (4,0) size 21x82
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x82
+            RenderMathMLRadicalOperator (anonymous) at (0,29) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,31) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,52) size 53x38
+          RenderMathMLRootWrapper at (4,0) size 21x38
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x38
+            RenderMathMLRadicalOperator (anonymous) at (0,8) size 17x30
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,9) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
index a9e1184..20b1356 100644 (file)
Binary files a/LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.png and b/LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.png differ
index c9350e5..7cf2651 100644 (file)
@@ -1,8 +1,8 @@
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
-layer at (0,0) size 800x260
-  RenderBlock {HTML} at (0,0) size 800x260
-    RenderBody {BODY} at (8,8) size 784x244
+layer at (0,0) size 800x259
+  RenderBlock {HTML} at (0,0) size 800x259
+    RenderBody {BODY} at (8,8) size 784x243
       RenderMathMLMath {math} at (0,0) size 126x24 [padding: 0 1 0 1]
         RenderMathMLRow {mrow} at (1,0) size 124x24
           RenderMathMLOperator {mo} at (0,5) size 7x14
@@ -305,8 +305,14 @@ layer at (0,0) size 800x260
         text run at (383,85) width 5: " "
       RenderBR {BR} at (0,0) size 0x0
       RenderMathMLMath {math} at (0,166) size 138x78 [padding: 0 1 0 1]
-        RenderMathMLSquareRoot {msqrt} at (1,0) size 136x78 [intrinsic padding: 3 0 3 12]
-          RenderMathMLRow (anonymous) at (12,3) size 124x72
+        RenderMathMLSquareRoot {msqrt} at (1,0) size 136x78
+          RenderMathMLBlock (anonymous, flex) at (0,0) size 12x78
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x78
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 12x78
+                RenderBlock (anonymous) at (0,0) size 12x78
+                  RenderText at (0,-1) size 15x25
+                    text run at (0,-1) width 15: "\x{221A}"
+          RenderMathMLRootWrapper at (12,3) size 124x75
             RenderMathMLOperator {mo} at (0,0) size 7x72
               RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
                 RenderBlock (anonymous) at (0,0) size 5x14
index c4a01f5..45ecd5d 100644 (file)
Binary files a/LayoutTests/platform/gtk/mathml/presentation/roots-expected.png and b/LayoutTests/platform/gtk/mathml/presentation/roots-expected.png differ
index 2d8904c..4638fb6 100644 (file)
@@ -1,25 +1,37 @@
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
-layer at (0,0) size 800x512
-  RenderBlock {html} at (0,0) size 800x512
-    RenderBody {body} at (8,16) size 784x480
-      RenderBlock {p} at (0,0) size 784x17
-        RenderText {#text} at (0,0) size 177x17
-          text run at (0,0) width 177: "square root (should be red): "
-        RenderMathMLMath {math} at (177,0) size 22x15 [padding: 0 1 0 1]
-          RenderMathMLSquareRoot {msqrt} at (1,0) size 20x15 [color=#FF0000] [intrinsic padding: 3 0 0 12]
-            RenderMathMLRow (anonymous) at (12,3) size 8x12
+layer at (0,0) size 800x506
+  RenderBlock {html} at (0,0) size 800x506
+    RenderBody {body} at (8,16) size 784x474
+      RenderBlock {p} at (0,0) size 784x18
+        RenderText {#text} at (0,1) size 177x17
+          text run at (0,1) width 177: "square root (should be red): "
+        RenderMathMLMath {math} at (177,0) size 22x18 [padding: 0 1 0 1]
+          RenderMathMLSquareRoot {msqrt} at (1,0) size 20x18 [color=#FF0000]
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x18
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                  RenderBlock (anonymous) at (0,0) size 12x18
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 8x15
               RenderMathMLToken {mn} at (0,0) size 8x12
                 RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                   RenderBlock (anonymous) at (0,0) size 8x12
                     RenderText {#text} at (0,-6) size 8x25
                       text run at (0,-6) width 8: "2"
-      RenderBlock {p} at (0,33) size 784x17
-        RenderText {#text} at (0,0) size 110x17
-          text run at (0,0) width 110: "long square root: "
-        RenderMathMLMath {math} at (110,0) size 49x15 [padding: 0 1 0 1]
-          RenderMathMLSquareRoot {msqrt} at (1,0) size 47x15 [intrinsic padding: 3 0 0 12]
-            RenderMathMLRow (anonymous) at (12,3) size 35x12
+      RenderBlock {p} at (0,34) size 784x18
+        RenderText {#text} at (0,1) size 110x17
+          text run at (0,1) width 110: "long square root: "
+        RenderMathMLMath {math} at (110,0) size 49x18 [padding: 0 1 0 1]
+          RenderMathMLSquareRoot {msqrt} at (1,0) size 47x18
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x18
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                  RenderBlock (anonymous) at (0,0) size 12x18
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 35x15
               RenderMathMLRow {mrow} at (0,0) size 35x12
                 RenderMathMLToken {mi} at (0,3) size 9x9 [padding: 0 2 0 0]
                   RenderMathMLBlock (anonymous, flex) at (0,0) size 7x9
@@ -36,12 +48,18 @@ layer at (0,0) size 800x512
                     RenderBlock (anonymous) at (0,0) size 8x12
                       RenderText {#text} at (0,-6) size 8x25
                         text run at (0,-6) width 8: "1"
-      RenderBlock {p} at (0,66) size 784x21
-        RenderText {#text} at (0,4) size 222x17
-          text run at (0,4) width 222: "long square root with implied row: "
-        RenderMathMLMath {math} at (222,0) size 55x19 [padding: 0 1 0 1]
-          RenderMathMLSquareRoot {msqrt} at (1,0) size 53x19 [intrinsic padding: 3 0 0 12]
-            RenderMathMLRow (anonymous) at (12,3) size 41x16
+      RenderBlock {p} at (0,68) size 784x22
+        RenderText {#text} at (0,5) size 222x17
+          text run at (0,5) width 222: "long square root with implied row: "
+        RenderMathMLMath {math} at (222,0) size 55x22 [padding: 0 1 0 1]
+          RenderMathMLSquareRoot {msqrt} at (1,0) size 53x22
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x22
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x22
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x22
+                  RenderBlock (anonymous) at (0,0) size 12x22
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 41x19
               RenderMathMLScripts {msup} at (0,0) size 15x16
                 Base Wrapper at (0,0) size 9x16 [padding: 7 0 0 0]
                   RenderMathMLToken {mi} at (0,7) size 9x9 [padding: 0 2 0 0]
@@ -65,12 +83,18 @@ layer at (0,0) size 800x512
                   RenderBlock (anonymous) at (0,0) size 8x12
                     RenderText {#text} at (0,-6) size 8x25
                       text run at (0,-6) width 8: "1"
-      RenderBlock {p} at (0,103) size 784x37
-        RenderText {#text} at (0,9) size 113x17
-          text run at (0,9) width 113: "root of a fraction: "
+      RenderBlock {p} at (0,106) size 784x37
+        RenderText {#text} at (0,10) size 113x17
+          text run at (0,10) width 113: "root of a fraction: "
         RenderMathMLMath {math} at (113,0) size 51x38 [padding: 0 1 0 1]
-          RenderMathMLSquareRoot {msqrt} at (1,0) size 49x38 [intrinsic padding: 3 0 3 12]
-            RenderMathMLRow (anonymous) at (12,3) size 37x32
+          RenderMathMLSquareRoot {msqrt} at (1,0) size 49x38
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x38
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x38
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x37
+                  RenderBlock (anonymous) at (0,0) size 12x37
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 37x35
               RenderMathMLFraction {mfrac} at (1,0) size 35x32
                 RenderMathMLBlock (anonymous, flex) at (0,0) size 35x16
                   RenderMathMLRow {mrow} at (0,0) size 35x12
@@ -106,443 +130,551 @@ layer at (0,0) size 800x512
                         RenderBlock (anonymous) at (0,0) size 8x12
                           RenderText {#text} at (0,-6) size 8x25
                             text run at (0,-6) width 8: "2"
-      RenderBlock {p} at (0,156) size 784x21
-        RenderText {#text} at (0,4) size 173x17
-          text run at (0,4) width 173: "cube root (should be blue): "
+      RenderBlock {p} at (0,159) size 784x18
+        RenderText {#text} at (0,1) size 173x17
+          text run at (0,1) width 173: "cube root (should be blue): "
         RenderMathMLMath {math} at (173,0) size 23x19 [color=#0000FF] [padding: 0 1 0 1]
-      RenderBlock {p} at (0,193) size 784x21
-        RenderText {#text} at (0,4) size 75x17
-          text run at (0,4) width 75: "long index: "
-        RenderMathMLMath {math} at (75,0) size 62x19 [padding: 0 1 0 1]
-      RenderBlock {p} at (0,230) size 784x37
-        RenderText {#text} at (0,9) size 185x17
-          text run at (0,9) width 185: "long index w/ complex base: "
-        RenderMathMLMath {math} at (185,0) size 92x38 [padding: 0 1 0 1]
-      RenderBlock {p} at (0,283) size 784x46
-        RenderText {#text} at (0,29) size 75x17
-          text run at (0,29) width 75: "high index: "
-        RenderMathMLMath {math} at (75,0) size 25x44 [padding: 0 1 0 1]
-      RenderBlock {p} at (0,345) size 784x45
-        RenderText {#text} at (0,21) size 155x17
-          text run at (0,21) width 155: "Imbricated square roots: "
-        RenderMathMLMath {math} at (155,0) size 293x45 [padding: 0 1 0 1]
-          RenderMathMLSquareRoot {msqrt} at (1,0) size 291x45 [intrinsic padding: 3 0 3 12]
-            RenderMathMLRow (anonymous) at (12,3) size 279x39
-              RenderMathMLToken {mn} at (0,21) size 8x12
+          RenderMathMLRoot {mroot} at (1,0) size 21x19
+            RenderMathMLRootWrapper at (4,0) size 6x19
+              RenderMathMLToken {mn} at (0,0) size 5x8
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                  RenderBlock (anonymous) at (0,0) size 5x8
+                    RenderText {#text} at (0,-3) size 5x15
+                      text run at (0,-3) width 5: "3"
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x19
+              RenderMathMLRadicalOperator (anonymous) at (0,1) size 12x18
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                  RenderBlock (anonymous) at (0,0) size 12x18
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,4) size 9x15
+              RenderMathMLToken {mn} at (0,0) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-6) size 8x25
+                      text run at (0,-6) width 8: "2"
+      RenderBlock {p} at (0,193) size 784x18
+        RenderText {#text} at (0,1) size 75x17
+          text run at (0,1) width 75: "long index: "
+        RenderMathMLMath {math} at (75,0) size 53x18 [padding: 0 1 0 1]
+          RenderMathMLRoot {mroot} at (1,0) size 51x18
+            RenderMathMLRootWrapper at (4,0) size 36x18
+              RenderMathMLRow {mrow} at (0,0) size 35x7
+                RenderMathMLToken {mi} at (0,1) size 5x5 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                    RenderBlock (anonymous) at (0,0) size 4x5
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "x"
+                RenderMathMLOperator {mo} at (4,0) size 11x6
+                  RenderMathMLBlock (anonymous, flex) at (2,0) size 6x6
+                    RenderBlock (anonymous) at (0,0) size 6x6
+                      RenderText at (0,-5) size 6x15
+                        text run at (0,-5) width 6: "+"
+                RenderMathMLToken {mi} at (14,1) size 6x6 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x6
+                    RenderBlock (anonymous) at (0,0) size 4x6
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "y"
+                RenderMathMLOperator {mo} at (19,0) size 11x6
+                  RenderMathMLBlock (anonymous, flex) at (2,0) size 6x6
+                    RenderBlock (anonymous) at (0,0) size 6x6
+                      RenderText at (0,-5) size 6x15
+                        text run at (0,-5) width 6: "+"
+                RenderMathMLToken {mi} at (29,1) size 6x5 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                    RenderBlock (anonymous) at (0,0) size 4x5
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "z"
+            RenderMathMLBlock (anonymous, flex) at (30,0) size 13x18
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x18
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                  RenderBlock (anonymous) at (0,0) size 12x18
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (42,3) size 9x15
+              RenderMathMLToken {mn} at (0,0) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-6) size 8x25
+                      text run at (0,-6) width 8: "2"
+      RenderBlock {p} at (0,227) size 784x37
+        RenderText {#text} at (0,10) size 185x17
+          text run at (0,10) width 185: "long index w/ complex base: "
+        RenderMathMLMath {math} at (185,0) size 81x38 [padding: 0 1 0 1]
+          RenderMathMLRoot {mroot} at (1,0) size 79x38
+            RenderMathMLRootWrapper at (4,8) size 36x30
+              RenderMathMLRow {mrow} at (0,0) size 35x7
+                RenderMathMLToken {mi} at (0,1) size 5x5 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                    RenderBlock (anonymous) at (0,0) size 4x5
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "x"
+                RenderMathMLOperator {mo} at (4,0) size 11x6
+                  RenderMathMLBlock (anonymous, flex) at (2,0) size 6x6
+                    RenderBlock (anonymous) at (0,0) size 6x6
+                      RenderText at (0,-5) size 6x15
+                        text run at (0,-5) width 6: "+"
+                RenderMathMLToken {mi} at (14,1) size 6x6 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x6
+                    RenderBlock (anonymous) at (0,0) size 4x6
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "y"
+                RenderMathMLOperator {mo} at (19,0) size 11x6
+                  RenderMathMLBlock (anonymous, flex) at (2,0) size 6x6
+                    RenderBlock (anonymous) at (0,0) size 6x6
+                      RenderText at (0,-5) size 6x15
+                        text run at (0,-5) width 6: "+"
+                RenderMathMLToken {mi} at (29,1) size 6x5 [padding: 0 1 0 0]
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                    RenderBlock (anonymous) at (0,0) size 4x5
+                      RenderText {#text} at (0,-6) size 4x15
+                        text run at (0,-6) width 4: "z"
+            RenderMathMLBlock (anonymous, flex) at (30,0) size 13x38
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x38
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x37
+                  RenderBlock (anonymous) at (0,0) size 12x37
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (42,3) size 37x35
+              RenderMathMLFraction {mfrac} at (1,0) size 35x32
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 35x16
+                  RenderMathMLRow {mrow} at (0,0) size 35x12
+                    RenderMathMLToken {mi} at (0,3) size 9x9 [padding: 0 2 0 0]
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 7x9
+                        RenderBlock (anonymous) at (0,0) size 7x9
+                          RenderText {#text} at (0,-9) size 7x25
+                            text run at (0,-9) width 7: "x"
+                    RenderMathMLOperator {mo} at (8,2) size 19x10
+                      RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                        RenderBlock (anonymous) at (0,0) size 11x10
+                          RenderText at (0,-8) size 11x25
+                            text run at (0,-8) width 11: "+"
+                    RenderMathMLToken {mn} at (26,0) size 9x12
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                        RenderBlock (anonymous) at (0,0) size 8x12
+                          RenderText {#text} at (0,-6) size 8x25
+                            text run at (0,-6) width 8: "1"
+                RenderMathMLBlock (anonymous, flex) at (0,15) size 35x17 [padding: 1 0 0 0]
+                  RenderMathMLRow {mrow} at (0,4) size 35x13
+                    RenderMathMLToken {mi} at (0,3) size 9x9 [padding: 0 2 0 0]
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 7x9
+                        RenderBlock (anonymous) at (0,0) size 7x9
+                          RenderText {#text} at (0,-9) size 7x25
+                            text run at (0,-9) width 7: "x"
+                    RenderMathMLOperator {mo} at (8,2) size 19x10
+                      RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                        RenderBlock (anonymous) at (0,0) size 11x10
+                          RenderText at (0,-8) size 11x25
+                            text run at (0,-8) width 11: "+"
+                    RenderMathMLToken {mn} at (26,0) size 9x12
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                        RenderBlock (anonymous) at (0,0) size 8x12
+                          RenderText {#text} at (0,-6) size 8x25
+                            text run at (0,-6) width 8: "2"
+      RenderBlock {p} at (0,280) size 784x35
+        RenderText {#text} at (0,18) size 75x17
+          text run at (0,18) width 75: "high index: "
+        RenderMathMLMath {math} at (75,0) size 27x36 [padding: 0 1 0 1]
+          RenderMathMLRoot {mroot} at (1,0) size 25x36
+            RenderMathMLRootWrapper at (4,0) size 10x36
+              RenderMathMLFraction {mfrac} at (1,0) size 7x26
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 7x18
+                  RenderMathMLFraction {mfrac} at (1,0) size 5x16
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
+                      RenderMathMLToken {mi} at (0,0) size 5x5 [padding: 0 1 0 0]
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                          RenderBlock (anonymous) at (0,0) size 4x5
+                            RenderText {#text} at (0,-6) size 4x15
+                              text run at (0,-6) width 4: "x"
+                    RenderMathMLBlock (anonymous, flex) at (0,6) size 5x10 [padding: 1 0 0 0]
+                      RenderMathMLToken {mi} at (0,2) size 5x7 [padding: 0 1 0 0]
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 4x6
+                          RenderBlock (anonymous) at (0,0) size 4x6
+                            RenderText {#text} at (0,-6) size 4x15
+                              text run at (0,-6) width 4: "y"
+                RenderMathMLBlock (anonymous, flex) at (0,17) size 7x9 [padding: 1 0 0 0]
+                  RenderMathMLToken {mi} at (1,2) size 5x6 [padding: 0 1 0 0]
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                      RenderBlock (anonymous) at (0,0) size 4x5
+                        RenderText {#text} at (0,-6) size 4x15
+                          text run at (0,-6) width 4: "z"
+            RenderMathMLBlock (anonymous, flex) at (4,0) size 13x36
+              RenderMathMLRadicalOperator (anonymous) at (0,18) size 12x18
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                  RenderBlock (anonymous) at (0,0) size 12x18
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (16,21) size 9x15
+              RenderMathMLToken {mn} at (0,0) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-6) size 8x25
+                      text run at (0,-6) width 8: "2"
+      RenderBlock {p} at (0,331) size 784x59
+        RenderText {#text} at (0,29) size 155x17
+          text run at (0,29) width 155: "Imbricated square roots: "
+        RenderMathMLMath {math} at (155,0) size 293x60 [padding: 0 1 0 1]
+          RenderMathMLSquareRoot {msqrt} at (1,0) size 291x60
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x60
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x60
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x60
+                  RenderBlock (anonymous) at (0,0) size 12x60
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 279x57
+              RenderMathMLToken {mn} at (0,28) size 8x12
                 RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                   RenderBlock (anonymous) at (0,0) size 8x12
                     RenderText {#text} at (0,-6) size 8x25
                       text run at (0,-6) width 8: "1"
-              RenderMathMLOperator {mo} at (8,23) size 19x10
+              RenderMathMLOperator {mo} at (8,30) size 19x10
                 RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                   RenderBlock (anonymous) at (0,0) size 11x10
                     RenderText at (0,-8) size 11x25
                       text run at (0,-8) width 11: "+"
-              RenderMathMLSquareRoot {msqrt} at (26,0) size 253x39 [intrinsic padding: 3 0 3 12]
-                RenderMathMLRow (anonymous) at (12,3) size 241x33
-                  RenderMathMLRow {mrow} at (0,0) size 241x33
-                    RenderMathMLToken {mn} at (0,18) size 8x12
+              RenderMathMLSquareRoot {msqrt} at (26,0) size 253x54
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x54
+                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x54
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 12x54
+                      RenderBlock (anonymous) at (0,0) size 12x54
+                        RenderText at (0,-1) size 15x25
+                          text run at (0,-1) width 15: "\x{221A}"
+                RenderMathMLRootWrapper at (12,3) size 241x51
+                  RenderMathMLRow {mrow} at (0,0) size 241x48
+                    RenderMathMLToken {mn} at (0,24) size 8x12
                       RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                         RenderBlock (anonymous) at (0,0) size 8x12
                           RenderText {#text} at (0,-6) size 8x25
                             text run at (0,-6) width 8: "2"
-                    RenderMathMLOperator {mo} at (8,20) size 19x10
+                    RenderMathMLOperator {mo} at (8,26) size 19x10
                       RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                         RenderBlock (anonymous) at (0,0) size 11x10
                           RenderText at (0,-8) size 11x25
                             text run at (0,-8) width 11: "+"
-                    RenderMathMLSquareRoot {msqrt} at (26,0) size 215x33 [intrinsic padding: 3 0 3 12]
-                      RenderMathMLRow (anonymous) at (12,3) size 203x27
-                        RenderMathMLRow {mrow} at (0,0) size 203x27
-                          RenderMathMLToken {mn} at (0,15) size 8x12
+                    RenderMathMLSquareRoot {msqrt} at (26,0) size 215x48
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 12x48
+                        RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x48
+                          RenderMathMLBlock (anonymous, flex) at (0,0) size 12x48
+                            RenderBlock (anonymous) at (0,0) size 12x48
+                              RenderText at (0,-1) size 15x25
+                                text run at (0,-1) width 15: "\x{221A}"
+                      RenderMathMLRootWrapper at (12,3) size 203x45
+                        RenderMathMLRow {mrow} at (0,0) size 203x42
+                          RenderMathMLToken {mn} at (0,20) size 8x12
                             RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                               RenderBlock (anonymous) at (0,0) size 8x12
                                 RenderText {#text} at (0,-6) size 8x25
                                   text run at (0,-6) width 8: "3"
-                          RenderMathMLOperator {mo} at (8,17) size 19x10
+                          RenderMathMLOperator {mo} at (8,22) size 19x10
                             RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                               RenderBlock (anonymous) at (0,0) size 11x10
                                 RenderText at (0,-8) size 11x25
                                   text run at (0,-8) width 11: "+"
-                          RenderMathMLSquareRoot {msqrt} at (26,0) size 177x27 [intrinsic padding: 3 0 0 12]
-                            RenderMathMLRow (anonymous) at (12,3) size 164x24
-                              RenderMathMLRow {mrow} at (0,0) size 164x24
-                                RenderMathMLToken {mn} at (0,12) size 8x12
+                          RenderMathMLSquareRoot {msqrt} at (26,0) size 177x42
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x42
+                              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x42
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x42
+                                  RenderBlock (anonymous) at (0,0) size 12x42
+                                    RenderText at (0,-1) size 15x25
+                                      text run at (0,-1) width 15: "\x{221A}"
+                            RenderMathMLRootWrapper at (12,3) size 164x39
+                              RenderMathMLRow {mrow} at (0,0) size 164x36
+                                RenderMathMLToken {mn} at (0,16) size 8x12
                                   RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                                     RenderBlock (anonymous) at (0,0) size 8x12
                                       RenderText {#text} at (0,-6) size 8x25
                                         text run at (0,-6) width 8: "4"
-                                RenderMathMLOperator {mo} at (8,14) size 19x10
+                                RenderMathMLOperator {mo} at (8,18) size 19x10
                                   RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                                     RenderBlock (anonymous) at (0,0) size 11x10
                                       RenderText at (0,-8) size 11x25
                                         text run at (0,-8) width 11: "+"
-                                RenderMathMLSquareRoot {msqrt} at (26,0) size 138x24 [intrinsic padding: 3 0 0 12]
-                                  RenderMathMLRow (anonymous) at (12,3) size 126x21
-                                    RenderMathMLRow {mrow} at (0,0) size 126x21
-                                      RenderMathMLToken {mn} at (0,8) size 8x13
+                                RenderMathMLSquareRoot {msqrt} at (26,0) size 138x36
+                                  RenderMathMLBlock (anonymous, flex) at (0,0) size 12x36
+                                    RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x36
+                                      RenderMathMLBlock (anonymous, flex) at (0,0) size 12x36
+                                        RenderBlock (anonymous) at (0,0) size 12x36
+                                          RenderText at (0,-1) size 15x25
+                                            text run at (0,-1) width 15: "\x{221A}"
+                                  RenderMathMLRootWrapper at (12,3) size 126x33
+                                    RenderMathMLRow {mrow} at (0,0) size 126x30
+                                      RenderMathMLToken {mn} at (0,11) size 8x13
                                         RenderMathMLBlock (anonymous, flex) at (0,0) size 8x13
                                           RenderBlock (anonymous) at (0,0) size 8x13
                                             RenderText {#text} at (0,-5) size 8x25
                                               text run at (0,-5) width 8: "5"
-                                      RenderMathMLOperator {mo} at (8,11) size 19x10
+                                      RenderMathMLOperator {mo} at (8,14) size 19x10
                                         RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                                           RenderBlock (anonymous) at (0,0) size 11x10
                                             RenderText at (0,-8) size 11x25
                                               text run at (0,-8) width 11: "+"
-                                      RenderMathMLSquareRoot {msqrt} at (26,0) size 100x21 [intrinsic padding: 3 0 0 12]
-                                        RenderMathMLRow (anonymous) at (12,3) size 88x18
-                                          RenderMathMLRow {mrow} at (0,0) size 88x18
-                                            RenderMathMLToken {mn} at (0,6) size 8x12
+                                      RenderMathMLSquareRoot {msqrt} at (26,0) size 100x30
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 12x30
+                                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x30
+                                            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x30
+                                              RenderBlock (anonymous) at (0,0) size 12x30
+                                                RenderText at (0,-1) size 15x25
+                                                  text run at (0,-1) width 15: "\x{221A}"
+                                        RenderMathMLRootWrapper at (12,3) size 88x27
+                                          RenderMathMLRow {mrow} at (0,0) size 88x24
+                                            RenderMathMLToken {mn} at (0,8) size 8x12
                                               RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                                                 RenderBlock (anonymous) at (0,0) size 8x12
                                                   RenderText {#text} at (0,-6) size 8x25
                                                     text run at (0,-6) width 8: "6"
-                                            RenderMathMLOperator {mo} at (8,8) size 19x10
+                                            RenderMathMLOperator {mo} at (8,10) size 19x10
                                               RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                                                 RenderBlock (anonymous) at (0,0) size 11x10
                                                   RenderText at (0,-8) size 11x25
                                                     text run at (0,-8) width 11: "+"
-                                            RenderMathMLSquareRoot {msqrt} at (26,0) size 62x18 [intrinsic padding: 3 0 0 12]
-                                              RenderMathMLRow (anonymous) at (12,3) size 50x15
-                                                RenderMathMLRow {mrow} at (0,0) size 50x15
-                                                  RenderMathMLToken {mn} at (0,3) size 8x12
+                                            RenderMathMLSquareRoot {msqrt} at (26,0) size 62x24
+                                              RenderMathMLBlock (anonymous, flex) at (0,0) size 12x24
+                                                RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x24
+                                                  RenderMathMLBlock (anonymous, flex) at (0,0) size 12x24
+                                                    RenderBlock (anonymous) at (0,0) size 12x24
+                                                      RenderText at (0,-1) size 15x25
+                                                        text run at (0,-1) width 15: "\x{221A}"
+                                              RenderMathMLRootWrapper at (12,3) size 50x21
+                                                RenderMathMLRow {mrow} at (0,0) size 50x18
+                                                  RenderMathMLToken {mn} at (0,4) size 8x12
                                                     RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
                                                       RenderBlock (anonymous) at (0,0) size 8x12
                                                         RenderText {#text} at (0,-6) size 8x25
                                                           text run at (0,-6) width 8: "7"
-                                                  RenderMathMLOperator {mo} at (8,5) size 19x10
+                                                  RenderMathMLOperator {mo} at (8,6) size 19x10
                                                     RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
                                                       RenderBlock (anonymous) at (0,0) size 11x10
                                                         RenderText at (0,-8) size 11x25
                                                           text run at (0,-8) width 11: "+"
-                                                  RenderMathMLSquareRoot {msqrt} at (26,0) size 24x15 [intrinsic padding: 3 0 0 12]
-                                                    RenderMathMLRow (anonymous) at (12,3) size 12x12
+                                                  RenderMathMLSquareRoot {msqrt} at (26,0) size 24x18
+                                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x18
+                                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                                                          RenderBlock (anonymous) at (0,0) size 12x18
+                                                            RenderText at (0,-1) size 15x25
+                                                              text run at (0,-1) width 15: "\x{221A}"
+                                                    RenderMathMLRootWrapper at (12,3) size 12x15
                                                       RenderMathMLToken {mi} at (0,0) size 12x12 [padding: 0 2 0 0]
                                                         RenderMathMLBlock (anonymous, flex) at (0,0) size 10x12
                                                           RenderBlock (anonymous) at (0,0) size 10x12
                                                             RenderText {#text} at (0,-6) size 10x25
                                                               text run at (0,-6) width 10: "A"
         RenderText {#text} at (0,0) size 0x0
-      RenderBlock {p} at (0,406) size 784x74
+      RenderBlock {p} at (0,406) size 784x68
         RenderText {#text} at (0,38) size 110x17
           text run at (0,38) width 110: "Imbricated roots: "
-        RenderMathMLMath {math} at (110,0) size 355x74 [padding: 0 1 0 1]
+        RenderMathMLMath {math} at (110,0) size 314x69 [padding: 0 1 0 1]
+          RenderMathMLRoot {mroot} at (1,0) size 312x69
+            RenderMathMLRootWrapper at (4,19) size 6x50
+              RenderMathMLToken {mn} at (0,0) size 5x8
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                  RenderBlock (anonymous) at (0,0) size 5x8
+                    RenderText {#text} at (0,-3) size 5x15
+                      text run at (0,-3) width 5: "3"
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x69
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x69
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 12x68
+                  RenderBlock (anonymous) at (0,0) size 12x68
+                    RenderText at (0,-1) size 15x25
+                      text run at (0,-1) width 15: "\x{221A}"
+            RenderMathMLRootWrapper at (12,3) size 300x66
+              RenderMathMLRow {mrow} at (0,0) size 299x63
+                RenderMathMLToken {mn} at (0,37) size 8x12
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                    RenderBlock (anonymous) at (0,0) size 8x12
+                      RenderText {#text} at (0,-6) size 8x25
+                        text run at (0,-6) width 8: "1"
+                RenderMathMLOperator {mo} at (8,39) size 19x10
+                  RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                    RenderBlock (anonymous) at (0,0) size 11x10
+                      RenderText at (0,-8) size 11x25
+                        text run at (0,-8) width 11: "+"
+                RenderMathMLRoot {mroot} at (26,0) size 273x63
+                  RenderMathMLRootWrapper at (4,17) size 6x46
+                    RenderMathMLToken {mn} at (0,0) size 5x8
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                        RenderBlock (anonymous) at (0,0) size 5x8
+                          RenderText {#text} at (0,-3) size 5x15
+                            text run at (0,-3) width 5: "4"
+                  RenderMathMLBlock (anonymous, flex) at (0,0) size 13x63
+                    RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x63
+                      RenderMathMLBlock (anonymous, flex) at (0,0) size 12x63
+                        RenderBlock (anonymous) at (0,0) size 12x63
+                          RenderText at (0,-1) size 15x25
+                            text run at (0,-1) width 15: "\x{221A}"
+                  RenderMathMLRootWrapper at (12,3) size 261x60
+                    RenderMathMLRow {mrow} at (0,0) size 261x57
+                      RenderMathMLToken {mn} at (0,33) size 8x12
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                          RenderBlock (anonymous) at (0,0) size 8x12
+                            RenderText {#text} at (0,-6) size 8x25
+                              text run at (0,-6) width 8: "2"
+                      RenderMathMLOperator {mo} at (8,35) size 19x10
+                        RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                          RenderBlock (anonymous) at (0,0) size 11x10
+                            RenderText at (0,-8) size 11x25
+                              text run at (0,-8) width 11: "+"
+                      RenderMathMLRoot {mroot} at (26,0) size 235x57
+                        RenderMathMLRootWrapper at (4,15) size 6x42
+                          RenderMathMLToken {mn} at (0,0) size 5x8
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                              RenderBlock (anonymous) at (0,0) size 5x8
+                                RenderText {#text} at (0,-3) size 5x15
+                                  text run at (0,-3) width 5: "5"
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x57
+                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x57
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 12x57
+                              RenderBlock (anonymous) at (0,0) size 12x57
+                                RenderText at (0,-1) size 15x25
+                                  text run at (0,-1) width 15: "\x{221A}"
+                        RenderMathMLRootWrapper at (12,3) size 223x54
+                          RenderMathMLRow {mrow} at (0,0) size 222x51
+                            RenderMathMLToken {mn} at (0,29) size 8x12
+                              RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                RenderBlock (anonymous) at (0,0) size 8x12
+                                  RenderText {#text} at (0,-6) size 8x25
+                                    text run at (0,-6) width 8: "3"
+                            RenderMathMLOperator {mo} at (8,31) size 19x10
+                              RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                                RenderBlock (anonymous) at (0,0) size 11x10
+                                  RenderText at (0,-8) size 11x25
+                                    text run at (0,-8) width 11: "+"
+                            RenderMathMLRoot {mroot} at (26,0) size 196x51
+                              RenderMathMLRootWrapper at (4,12) size 6x39
+                                RenderMathMLToken {mn} at (0,0) size 5x8
+                                  RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                                    RenderBlock (anonymous) at (0,0) size 5x8
+                                      RenderText {#text} at (0,-3) size 5x15
+                                        text run at (0,-3) width 5: "6"
+                              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x51
+                                RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x51
+                                  RenderMathMLBlock (anonymous, flex) at (0,0) size 12x51
+                                    RenderBlock (anonymous) at (0,0) size 12x51
+                                      RenderText at (0,-1) size 15x25
+                                        text run at (0,-1) width 15: "\x{221A}"
+                              RenderMathMLRootWrapper at (12,3) size 184x48
+                                RenderMathMLRow {mrow} at (0,0) size 183x45
+                                  RenderMathMLToken {mn} at (0,25) size 8x12
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                      RenderBlock (anonymous) at (0,0) size 8x12
+                                        RenderText {#text} at (0,-6) size 8x25
+                                          text run at (0,-6) width 8: "4"
+                                  RenderMathMLOperator {mo} at (8,27) size 19x10
+                                    RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                                      RenderBlock (anonymous) at (0,0) size 11x10
+                                        RenderText at (0,-8) size 11x25
+                                          text run at (0,-8) width 11: "+"
+                                  RenderMathMLRoot {mroot} at (26,0) size 157x45
+                                    RenderMathMLRootWrapper at (4,11) size 6x34
+                                      RenderMathMLToken {mn} at (0,0) size 5x7
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
+                                          RenderBlock (anonymous) at (0,0) size 5x7
+                                            RenderText {#text} at (0,-4) size 5x15
+                                              text run at (0,-4) width 5: "7"
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x45
+                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x45
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 12x45
+                                          RenderBlock (anonymous) at (0,0) size 12x45
+                                            RenderText at (0,-1) size 15x25
+                                              text run at (0,-1) width 15: "\x{221A}"
+                                    RenderMathMLRootWrapper at (12,3) size 145x42
+                                      RenderMathMLRow {mrow} at (0,0) size 145x39
+                                        RenderMathMLToken {mn} at (0,20) size 8x13
+                                          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x13
+                                            RenderBlock (anonymous) at (0,0) size 8x13
+                                              RenderText {#text} at (0,-5) size 8x25
+                                                text run at (0,-5) width 8: "5"
+                                        RenderMathMLOperator {mo} at (8,23) size 19x10
+                                          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                                            RenderBlock (anonymous) at (0,0) size 11x10
+                                              RenderText at (0,-8) size 11x25
+                                                text run at (0,-8) width 11: "+"
+                                        RenderMathMLRoot {mroot} at (26,0) size 119x39
+                                          RenderMathMLRootWrapper at (4,8) size 6x31
+                                            RenderMathMLToken {mn} at (0,0) size 5x8
+                                              RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                                                RenderBlock (anonymous) at (0,0) size 5x8
+                                                  RenderText {#text} at (0,-3) size 5x15
+                                                    text run at (0,-3) width 5: "8"
+                                          RenderMathMLBlock (anonymous, flex) at (0,0) size 13x39
+                                            RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x39
+                                              RenderMathMLBlock (anonymous, flex) at (0,0) size 12x39
+                                                RenderBlock (anonymous) at (0,0) size 12x39
+                                                  RenderText at (0,-1) size 15x25
+                                                    text run at (0,-1) width 15: "\x{221A}"
+                                          RenderMathMLRootWrapper at (12,3) size 107x36
+                                            RenderMathMLRow {mrow} at (0,0) size 106x33
+                                              RenderMathMLToken {mn} at (0,17) size 8x12
+                                                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                                  RenderBlock (anonymous) at (0,0) size 8x12
+                                                    RenderText {#text} at (0,-6) size 8x25
+                                                      text run at (0,-6) width 8: "6"
+                                              RenderMathMLOperator {mo} at (8,19) size 19x10
+                                                RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                                                  RenderBlock (anonymous) at (0,0) size 11x10
+                                                    RenderText at (0,-8) size 11x25
+                                                      text run at (0,-8) width 11: "+"
+                                              RenderMathMLRoot {mroot} at (26,0) size 80x33
+                                                RenderMathMLRootWrapper at (4,5) size 6x28
+                                                  RenderMathMLToken {mn} at (0,0) size 5x8
+                                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 5x8
+                                                      RenderBlock (anonymous) at (0,0) size 5x8
+                                                        RenderText {#text} at (0,-3) size 5x15
+                                                          text run at (0,-3) width 5: "9"
+                                                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x33
+                                                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 12x33
+                                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 12x33
+                                                      RenderBlock (anonymous) at (0,0) size 12x33
+                                                        RenderText at (0,-1) size 15x25
+                                                          text run at (0,-1) width 15: "\x{221A}"
+                                                RenderMathMLRootWrapper at (12,3) size 68x30
+                                                  RenderMathMLRow {mrow} at (0,0) size 68x27
+                                                    RenderMathMLToken {mn} at (0,13) size 8x12
+                                                      RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                                        RenderBlock (anonymous) at (0,0) size 8x12
+                                                          RenderText {#text} at (0,-6) size 8x25
+                                                            text run at (0,-6) width 8: "7"
+                                                    RenderMathMLOperator {mo} at (8,15) size 19x10
+                                                      RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
+                                                        RenderBlock (anonymous) at (0,0) size 11x10
+                                                          RenderText at (0,-8) size 11x25
+                                                            text run at (0,-8) width 11: "+"
+                                                    RenderMathMLRoot {mroot} at (26,0) size 42x27
+                                                      RenderMathMLRootWrapper at (4,0) size 23x27
+                                                        RenderMathMLFraction {mfrac} at (1,0) size 20x17
+                                                          RenderMathMLBlock (anonymous, flex) at (0,0) size 20x9
+                                                            RenderMathMLRow {mrow} at (0,0) size 20x7
+                                                              RenderMathMLToken {mi} at (0,1) size 5x5 [padding: 0 1 0 0]
+                                                                RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                                                                  RenderBlock (anonymous) at (0,0) size 4x5
+                                                                    RenderText {#text} at (0,-6) size 4x15
+                                                                      text run at (0,-6) width 4: "x"
+                                                              RenderMathMLOperator {mo} at (4,0) size 11x6
+                                                                RenderMathMLBlock (anonymous, flex) at (2,0) size 6x6
+                                                                  RenderBlock (anonymous) at (0,0) size 6x6
+                                                                    RenderText at (0,-5) size 6x15
+                                                                      text run at (0,-5) width 6: "+"
+                                                              RenderMathMLToken {mi} at (14,1) size 6x6 [padding: 0 1 0 0]
+                                                                RenderMathMLBlock (anonymous, flex) at (0,0) size 4x6
+                                                                  RenderBlock (anonymous) at (0,0) size 4x6
+                                                                    RenderText {#text} at (0,-6) size 4x15
+                                                                      text run at (0,-6) width 4: "y"
+                                                          RenderMathMLBlock (anonymous, flex) at (0,8) size 20x9 [padding: 1 0 0 0]
+                                                            RenderMathMLToken {mi} at (7,2) size 6x6 [padding: 0 1 0 0]
+                                                              RenderMathMLBlock (anonymous, flex) at (0,0) size 4x5
+                                                                RenderBlock (anonymous) at (0,0) size 4x5
+                                                                  RenderText {#text} at (0,-6) size 4x15
+                                                                    text run at (0,-6) width 4: "z"
+                                                      RenderMathMLBlock (anonymous, flex) at (17,0) size 13x27
+                                                        RenderMathMLRadicalOperator (anonymous) at (0,9) size 12x18
+                                                          RenderMathMLBlock (anonymous, flex) at (0,0) size 12x18
+                                                            RenderBlock (anonymous) at (0,0) size 12x18
+                                                              RenderText at (0,-1) size 15x25
+                                                                text run at (0,-1) width 15: "\x{221A}"
+                                                      RenderMathMLRootWrapper at (29,12) size 12x15
+                                                        RenderMathMLToken {mi} at (0,0) size 12x12 [padding: 0 2 0 0]
+                                                          RenderMathMLBlock (anonymous, flex) at (0,0) size 10x12
+                                                            RenderBlock (anonymous) at (0,0) size 10x12
+                                                              RenderText {#text} at (0,-6) size 10x25
+                                                                text run at (0,-6) width 10: "A"
         RenderText {#text} at (0,0) size 0x0
-layer at (182,172) size 21x19
-  RenderMathMLRoot {mroot} at (1,0) size 21x19 [intrinsic padding: 7 0 0 13]
-    RenderMathMLRow (anonymous) at (13,7) size 8x12
-      RenderMathMLToken {mn} at (0,0) size 8x12
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-          RenderBlock (anonymous) at (0,0) size 8x12
-            RenderText {#text} at (0,-6) size 8x25
-              text run at (0,-6) width 8: "2"
-layer at (182,172) size 13x14
-  RenderMathMLToken {mn} at (0,0) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "3"
-layer at (84,209) size 60x19
-  RenderMathMLRoot {mroot} at (1,0) size 60x19 [intrinsic padding: 7 0 0 52]
-    RenderMathMLRow (anonymous) at (52,7) size 8x12
-      RenderMathMLToken {mn} at (0,0) size 8x12
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-          RenderBlock (anonymous) at (0,0) size 8x12
-            RenderText {#text} at (0,-6) size 8x25
-              text run at (0,-6) width 8: "2"
-layer at (84,209) size 52x14
-  RenderMathMLRow {mrow} at (0,0) size 53x15 [padding: 0 5 4 2]
-    RenderMathMLToken {mi} at (2,1) size 7x7 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-        RenderBlock (anonymous) at (0,0) size 5x7
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "x"
-    RenderMathMLOperator {mo} at (8,0) size 14x8
-      RenderMathMLBlock (anonymous, flex) at (2,0) size 9x8
-        RenderBlock (anonymous) at (0,0) size 8x8
-          RenderText at (0,-6) size 8x19
-            text run at (0,-6) width 8: "+"
-    RenderMathMLToken {mi} at (21,1) size 8x9 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x9
-        RenderBlock (anonymous) at (0,0) size 5x9
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "y"
-    RenderMathMLOperator {mo} at (28,0) size 14x8
-      RenderMathMLBlock (anonymous, flex) at (2,0) size 9x8
-        RenderBlock (anonymous) at (0,0) size 8x8
-          RenderText at (0,-6) size 8x19
-            text run at (0,-6) width 8: "+"
-    RenderMathMLToken {mi} at (41,1) size 7x7 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-        RenderBlock (anonymous) at (0,0) size 5x7
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "z"
-layer at (194,246) size 90x37
-  RenderMathMLRoot {mroot} at (1,0) size 90x38 [intrinsic padding: 3 0 3 53]
-    RenderMathMLRow (anonymous) at (53,3) size 37x32
-      RenderMathMLFraction {mfrac} at (1,0) size 35x32
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 35x16
-          RenderMathMLRow {mrow} at (0,0) size 35x12
-            RenderMathMLToken {mi} at (0,3) size 9x9 [padding: 0 2 0 0]
-              RenderMathMLBlock (anonymous, flex) at (0,0) size 7x9
-                RenderBlock (anonymous) at (0,0) size 7x9
-                  RenderText {#text} at (0,-9) size 7x25
-                    text run at (0,-9) width 7: "x"
-            RenderMathMLOperator {mo} at (8,2) size 19x10
-              RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-                RenderBlock (anonymous) at (0,0) size 11x10
-                  RenderText at (0,-8) size 11x25
-                    text run at (0,-8) width 11: "+"
-            RenderMathMLToken {mn} at (26,0) size 9x12
-              RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-                RenderBlock (anonymous) at (0,0) size 8x12
-                  RenderText {#text} at (0,-6) size 8x25
-                    text run at (0,-6) width 8: "1"
-        RenderMathMLBlock (anonymous, flex) at (0,15) size 35x17 [padding: 1 0 0 0]
-          RenderMathMLRow {mrow} at (0,4) size 35x13
-            RenderMathMLToken {mi} at (0,3) size 9x9 [padding: 0 2 0 0]
-              RenderMathMLBlock (anonymous, flex) at (0,0) size 7x9
-                RenderBlock (anonymous) at (0,0) size 7x9
-                  RenderText {#text} at (0,-9) size 7x25
-                    text run at (0,-9) width 7: "x"
-            RenderMathMLOperator {mo} at (8,2) size 19x10
-              RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-                RenderBlock (anonymous) at (0,0) size 11x10
-                  RenderText at (0,-8) size 11x25
-                    text run at (0,-8) width 11: "+"
-            RenderMathMLToken {mn} at (26,0) size 9x12
-              RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-                RenderBlock (anonymous) at (0,0) size 8x12
-                  RenderText {#text} at (0,-6) size 8x25
-                    text run at (0,-6) width 8: "2"
-layer at (194,254) size 52x14
-  RenderMathMLRow {mrow} at (0,8) size 53x15 [padding: 0 5 4 2]
-    RenderMathMLToken {mi} at (2,1) size 7x7 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-        RenderBlock (anonymous) at (0,0) size 5x7
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "x"
-    RenderMathMLOperator {mo} at (8,0) size 14x8
-      RenderMathMLBlock (anonymous, flex) at (2,0) size 9x8
-        RenderBlock (anonymous) at (0,0) size 8x8
-          RenderText at (0,-6) size 8x19
-            text run at (0,-6) width 8: "+"
-    RenderMathMLToken {mi} at (21,1) size 8x9 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x9
-        RenderBlock (anonymous) at (0,0) size 5x9
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "y"
-    RenderMathMLOperator {mo} at (28,0) size 14x8
-      RenderMathMLBlock (anonymous, flex) at (2,0) size 9x8
-        RenderBlock (anonymous) at (0,0) size 8x8
-          RenderText at (0,-6) size 8x19
-            text run at (0,-6) width 8: "+"
-    RenderMathMLToken {mi} at (41,1) size 7x7 [padding: 0 1 0 0]
-      RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-        RenderBlock (anonymous) at (0,0) size 5x7
-          RenderText {#text} at (0,-7) size 5x19
-            text run at (0,-7) width 5: "z"
-layer at (84,299) size 23x44
-  RenderMathMLRoot {mroot} at (1,0) size 23x44 [intrinsic padding: 32 0 0 15]
-    RenderMathMLRow (anonymous) at (15,32) size 8x12
-      RenderMathMLToken {mn} at (0,0) size 8x12
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-          RenderBlock (anonymous) at (0,0) size 8x12
-            RenderText {#text} at (0,-6) size 8x25
-              text run at (0,-6) width 8: "2"
-layer at (85,299) size 15x39
-  RenderMathMLFraction {mfrac} at (1,0) size 16x39 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 9x25
-      RenderMathMLFraction {mfrac} at (1,0) size 7x22
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 7x10
-          RenderMathMLToken {mi} at (0,0) size 7x7 [padding: 0 1 0 0]
-            RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-              RenderBlock (anonymous) at (0,0) size 5x7
-                RenderText {#text} at (0,-7) size 5x19
-                  text run at (0,-7) width 5: "x"
-        RenderMathMLBlock (anonymous, flex) at (0,9) size 7x13 [padding: 1 0 0 0]
-          RenderMathMLToken {mi} at (0,3) size 7x10 [padding: 0 1 0 0]
-            RenderMathMLBlock (anonymous, flex) at (0,0) size 5x9
-              RenderBlock (anonymous) at (0,0) size 5x9
-                RenderText {#text} at (0,-7) size 5x19
-                  text run at (0,-7) width 5: "y"
-    RenderMathMLBlock (anonymous, flex) at (2,24) size 9x11 [padding: 1 0 0 0]
-      RenderMathMLToken {mi} at (1,3) size 7x8 [padding: 0 1 0 0]
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-          RenderBlock (anonymous) at (0,0) size 5x7
-            RenderText {#text} at (0,-7) size 5x19
-              text run at (0,-7) width 5: "z"
-layer at (119,422) size 352x74
-  RenderMathMLRoot {mroot} at (1,0) size 353x74 [intrinsic padding: 3 0 3 19]
-    RenderMathMLRow (anonymous) at (19,3) size 334x68
-      RenderMathMLRow {mrow} at (0,0) size 334x68
-        RenderMathMLToken {mn} at (0,38) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "1"
-        RenderMathMLOperator {mo} at (8,40) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (164,425) size 307x68
-  RenderMathMLRoot {mroot} at (26,0) size 308x68 [intrinsic padding: 3 0 3 19]
-    RenderMathMLRow (anonymous) at (19,3) size 289x62
-      RenderMathMLRow {mrow} at (0,0) size 289x62
-        RenderMathMLToken {mn} at (0,35) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "2"
-        RenderMathMLOperator {mo} at (8,37) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (209,428) size 262x62
-  RenderMathMLRoot {mroot} at (26,0) size 263x62 [intrinsic padding: 3 0 3 19]
-    RenderMathMLRow (anonymous) at (19,3) size 244x56
-      RenderMathMLRow {mrow} at (0,0) size 244x56
-        RenderMathMLToken {mn} at (0,32) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "3"
-        RenderMathMLOperator {mo} at (8,34) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (254,431) size 217x56
-  RenderMathMLRoot {mroot} at (26,0) size 218x56 [intrinsic padding: 3 0 3 19]
-    RenderMathMLRow (anonymous) at (19,3) size 198x50
-      RenderMathMLRow {mrow} at (0,0) size 198x50
-        RenderMathMLToken {mn} at (0,29) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "4"
-        RenderMathMLOperator {mo} at (8,31) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (299,434) size 172x50
-  RenderMathMLRoot {mroot} at (26,0) size 172x50 [intrinsic padding: 3 0 3 18]
-    RenderMathMLRow (anonymous) at (18,3) size 154x44
-      RenderMathMLRow {mrow} at (0,0) size 154x44
-        RenderMathMLToken {mn} at (0,25) size 8x13
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x13
-            RenderBlock (anonymous) at (0,0) size 8x13
-              RenderText {#text} at (0,-5) size 8x25
-                text run at (0,-5) width 8: "5"
-        RenderMathMLOperator {mo} at (8,28) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (343,437) size 128x44
-  RenderMathMLRoot {mroot} at (26,0) size 128x44 [intrinsic padding: 3 0 3 16]
-    RenderMathMLRow (anonymous) at (16,3) size 112x38
-      RenderMathMLRow {mrow} at (0,0) size 112x38
-        RenderMathMLToken {mn} at (0,23) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "6"
-        RenderMathMLOperator {mo} at (8,25) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (386,440) size 86x38
-  RenderMathMLRoot {mroot} at (26,0) size 86x38 [intrinsic padding: 3 0 3 15]
-    RenderMathMLRow (anonymous) at (15,3) size 71x32
-      RenderMathMLRow {mrow} at (0,0) size 71x32
-        RenderMathMLToken {mn} at (0,20) size 8x12
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
-            RenderBlock (anonymous) at (0,0) size 8x12
-              RenderText {#text} at (0,-6) size 8x25
-                text run at (0,-6) width 8: "7"
-        RenderMathMLOperator {mo} at (8,22) size 19x10
-          RenderMathMLBlock (anonymous, flex) at (3,0) size 12x10
-            RenderBlock (anonymous) at (0,0) size 11x10
-              RenderText at (0,-8) size 11x25
-                text run at (0,-8) width 11: "+"
-layer at (427,443) size 45x32
-  RenderMathMLRoot {mroot} at (26,0) size 45x32 [intrinsic padding: 20 0 0 33]
-    RenderMathMLRow (anonymous) at (33,20) size 12x12
-      RenderMathMLToken {mi} at (0,0) size 12x12 [padding: 0 2 0 0]
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 10x12
-          RenderBlock (anonymous) at (0,0) size 10x12
-            RenderText {#text} at (0,-6) size 10x25
-              text run at (0,-6) width 10: "A"
-layer at (428,443) size 33x27
-  RenderMathMLFraction {mfrac} at (1,0) size 33x27 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 27x13
-      RenderMathMLRow {mrow} at (0,0) size 26x10
-        RenderMathMLToken {mi} at (0,1) size 7x7 [padding: 0 1 0 0]
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-            RenderBlock (anonymous) at (0,0) size 5x7
-              RenderText {#text} at (0,-7) size 5x19
-                text run at (0,-7) width 5: "x"
-        RenderMathMLOperator {mo} at (6,0) size 14x8
-          RenderMathMLBlock (anonymous, flex) at (2,0) size 9x8
-            RenderBlock (anonymous) at (0,0) size 8x8
-              RenderText at (0,-6) size 8x19
-                text run at (0,-6) width 8: "+"
-        RenderMathMLToken {mi} at (19,1) size 7x9 [padding: 0 1 0 0]
-          RenderMathMLBlock (anonymous, flex) at (0,0) size 5x9
-            RenderBlock (anonymous) at (0,0) size 5x9
-              RenderText {#text} at (0,-7) size 5x19
-                text run at (0,-7) width 5: "y"
-    RenderMathMLBlock (anonymous, flex) at (2,12) size 27x11 [padding: 1 0 0 0]
-      RenderMathMLToken {mi} at (9,3) size 7x8 [padding: 0 1 0 0]
-        RenderMathMLBlock (anonymous, flex) at (0,0) size 5x7
-          RenderBlock (anonymous) at (0,0) size 5x7
-            RenderText {#text} at (0,-7) size 5x19
-              text run at (0,-7) width 5: "z"
-layer at (386,449) size 13x14
-  RenderMathMLToken {mn} at (0,9) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "9"
-layer at (343,450) size 13x14
-  RenderMathMLToken {mn} at (0,13) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "8"
-layer at (299,451) size 13x13
-  RenderMathMLToken {mn} at (0,17) size 14x14 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x9
-      RenderBlock (anonymous) at (0,0) size 6x9
-        RenderText {#text} at (0,-5) size 6x19
-          text run at (0,-5) width 6: "7"
-layer at (254,451) size 13x14
-  RenderMathMLToken {mn} at (0,20) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "6"
-layer at (209,452) size 13x14
-  RenderMathMLToken {mn} at (0,24) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "5"
-layer at (164,453) size 13x14
-  RenderMathMLToken {mn} at (0,28) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "4"
-layer at (119,453) size 13x14
-  RenderMathMLToken {mn} at (0,31) size 14x15 [padding: 0 5 4 2]
-    RenderMathMLBlock (anonymous, flex) at (2,0) size 7x10
-      RenderBlock (anonymous) at (0,0) size 6x10
-        RenderText {#text} at (0,-4) size 6x19
-          text run at (0,-4) width 6: "3"
index 6d568c9..641ea2f 100755 (executable)
@@ -1325,6 +1325,11 @@ webkit.org/b/130322 [ MountainLion Mavericks ] mathml/opentype/vertical-LatinMod
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/opentype-stretchy-horizontal.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern-munderover.html [ Failure ]
+webkit.org/b/119038 mathml/opentype/roots-LatinModern.html [ Failure ]
+
+# Missing references
+webkit.org/b/119038 mathml/presentation/mo-stretch.html [ Failure ]
+webkit.org/b/119038 mathml/presentation/roots.xhtml [ Failure ]
 
 # WebKitDataCue is supported, not DataCue
 media/track/track-datacue.html [ Skip ]
diff --git a/LayoutTests/platform/mac/mathml/opentype/roots-LatinModern-expected.txt b/LayoutTests/platform/mac/mathml/opentype/roots-LatinModern-expected.txt
new file mode 100644 (file)
index 0000000..ba958d5
--- /dev/null
@@ -0,0 +1,184 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x259
+  RenderBlock {HTML} at (0,0) size 800x260
+    RenderBody {BODY} at (8,8) size 784x236
+      RenderMathMLMath {math} at (0,0) size 784x53 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (232,0) size 320x53
+          RenderMathMLSquareRoot {msqrt} at (0,0) size 319x53
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x53
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x53
+                  RenderBlock (anonymous) at (0,0) size 13x53
+                    RenderText at (0,-56) size 13x106
+                      text run at (0,-56) width 13: "\x{221A}"
+            RenderMathMLRootWrapper at (17,2) size 302x51
+              RenderMathMLToken {mn} at (0,12) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-46) size 8x106
+                      text run at (0,-46) width 8: "1"
+              RenderMathMLOperator {mo} at (8,13) size 20x12
+                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                  RenderBlock (anonymous) at (0,0) size 12x12
+                    RenderText at (0,-47) size 12x106
+                      text run at (0,-47) width 12: "+"
+              RenderMathMLSquareRoot {msqrt} at (27,0) size 275x51
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x51
+                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x51
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x51
+                      RenderBlock (anonymous) at (0,0) size 13x51
+                        RenderText at (0,-56) size 13x106
+                          text run at (0,-56) width 13: "\x{221A}"
+                RenderMathMLRootWrapper at (17,2) size 258x49
+                  RenderMathMLToken {mn} at (0,10) size 8x12
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                      RenderBlock (anonymous) at (0,0) size 8x12
+                        RenderText {#text} at (0,-46) size 8x106
+                          text run at (0,-46) width 8: "1"
+                  RenderMathMLOperator {mo} at (8,11) size 20x12
+                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                      RenderBlock (anonymous) at (0,0) size 12x12
+                        RenderText at (0,-47) size 12x106
+                          text run at (0,-47) width 12: "+"
+                  RenderMathMLSquareRoot {msqrt} at (27,0) size 231x49
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x49
+                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x49
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x48
+                          RenderBlock (anonymous) at (0,0) size 13x48
+                            RenderText at (0,-56) size 13x106
+                              text run at (0,-56) width 13: "\x{221A}"
+                    RenderMathMLRootWrapper at (17,2) size 214x47
+                      RenderMathMLToken {mn} at (0,8) size 8x12
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                          RenderBlock (anonymous) at (0,0) size 8x12
+                            RenderText {#text} at (0,-46) size 8x106
+                              text run at (0,-46) width 8: "1"
+                      RenderMathMLOperator {mo} at (8,9) size 20x12
+                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                          RenderBlock (anonymous) at (0,0) size 12x12
+                            RenderText at (0,-47) size 12x106
+                              text run at (0,-47) width 12: "+"
+                      RenderMathMLSquareRoot {msqrt} at (27,0) size 187x41
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 17x41
+                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x41
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x40
+                              RenderBlock (anonymous) at (0,0) size 13x40
+                                RenderText at (0,-56) size 13x106
+                                  text run at (0,-56) width 13: "\x{221A}"
+                        RenderMathMLRootWrapper at (17,2) size 169x39
+                          RenderMathMLToken {mn} at (0,6) size 8x12
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                              RenderBlock (anonymous) at (0,0) size 8x12
+                                RenderText {#text} at (0,-46) size 8x106
+                                  text run at (0,-46) width 8: "1"
+                          RenderMathMLOperator {mo} at (8,7) size 20x12
+                            RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                              RenderBlock (anonymous) at (0,0) size 12x12
+                                RenderText at (0,-47) size 12x106
+                                  text run at (0,-47) width 12: "+"
+                          RenderMathMLSquareRoot {msqrt} at (27,0) size 142x31
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x31
+                              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                                  RenderBlock (anonymous) at (0,0) size 13x30
+                                    RenderText at (0,-56) size 13x106
+                                      text run at (0,-56) width 13: "\x{221A}"
+                            RenderMathMLRootWrapper at (17,2) size 125x29
+                              RenderMathMLToken {mn} at (0,4) size 8x12
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                  RenderBlock (anonymous) at (0,0) size 8x12
+                                    RenderText {#text} at (0,-46) size 8x106
+                                      text run at (0,-46) width 8: "1"
+                              RenderMathMLOperator {mo} at (8,5) size 20x12
+                                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                  RenderBlock (anonymous) at (0,0) size 12x12
+                                    RenderText at (0,-47) size 12x106
+                                      text run at (0,-47) width 12: "+"
+                              RenderMathMLSquareRoot {msqrt} at (27,0) size 98x21
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x21
+                                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x21
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x20
+                                      RenderBlock (anonymous) at (0,0) size 13x20
+                                        RenderText at (0,-56) size 13x106
+                                          text run at (0,-56) width 13: "\x{221A}"
+                                RenderMathMLRootWrapper at (17,2) size 81x19
+                                  RenderMathMLToken {mn} at (0,2) size 8x12
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                      RenderBlock (anonymous) at (0,0) size 8x12
+                                        RenderText {#text} at (0,-46) size 8x106
+                                          text run at (0,-46) width 8: "1"
+                                  RenderMathMLOperator {mo} at (8,3) size 20x12
+                                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                      RenderBlock (anonymous) at (0,0) size 12x12
+                                        RenderText at (0,-47) size 12x106
+                                          text run at (0,-47) width 12: "+"
+                                  RenderMathMLSquareRoot {msqrt} at (27,0) size 54x18
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x18
+                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x18
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x17
+                                          RenderBlock (anonymous) at (0,0) size 13x17
+                                            RenderText at (0,-56) size 13x106
+                                              text run at (0,-56) width 13: "\x{221A}"
+                                    RenderMathMLRootWrapper at (17,2) size 37x16
+                                      RenderMathMLToken {mn} at (0,0) size 8x12
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                          RenderBlock (anonymous) at (0,0) size 8x12
+                                            RenderText {#text} at (0,-46) size 8x106
+                                              text run at (0,-46) width 8: "1"
+                                      RenderMathMLOperator {mo} at (8,1) size 20x12
+                                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                          RenderBlock (anonymous) at (0,0) size 12x12
+                                            RenderText at (0,-47) size 12x106
+                                              text run at (0,-47) width 12: "+"
+                                      RenderMathMLToken {mi} at (27,4) size 10x8 [padding: 0 2 0 0]
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x8
+                                          RenderBlock (anonymous) at (0,0) size 8x8
+                                            RenderText {#text} at (0,-50) size 8x106
+                                              text run at (0,-50) width 8: "x"
+      RenderMathMLMath {math} at (0,68) size 784x62 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x53
+          RenderMathMLRootWrapper at (4,10) size 21x43
+            RenderMathMLSpace {mspace} at (0,0) size 20x10 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x53
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,30) size 53x31
+          RenderMathMLRootWrapper at (4,7) size 21x24
+            RenderMathMLSpace {mspace} at (0,0) size 20x5 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x31
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
+      RenderMathMLMath {math} at (0,145) size 784x91 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x82
+          RenderMathMLRootWrapper at (4,0) size 21x82
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x82
+            RenderMathMLRadicalOperator (anonymous) at (0,29) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,31) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,52) size 53x38
+          RenderMathMLRootWrapper at (4,0) size 21x38
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x38
+            RenderMathMLRadicalOperator (anonymous) at (0,8) size 17x30
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,9) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
index 1ecbb67..45d9e55 100644 (file)
@@ -2818,3 +2818,6 @@ webkit.org/b/130322 mathml/opentype/vertical-LatinModern.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/opentype-stretchy-horizontal.html [ Failure ]
 webkit.org/b/72828 mathml/opentype/horizontal-LatinModern-munderover.html [ Failure ]
+webkit.org/b/119038 mathml/opentype/roots-LatinModern.html [ Failure ]
+webkit.org/b/119038 mathml/presentation/mo-stretch.html [ Failure ]
+webkit.org/b/119038 mathml/presentation/roots.xhtml [ Failure ]
diff --git a/LayoutTests/platform/win/mathml/opentype/roots-LatinModern-expected.txt b/LayoutTests/platform/win/mathml/opentype/roots-LatinModern-expected.txt
new file mode 100644 (file)
index 0000000..ba958d5
--- /dev/null
@@ -0,0 +1,184 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x259
+  RenderBlock {HTML} at (0,0) size 800x260
+    RenderBody {BODY} at (8,8) size 784x236
+      RenderMathMLMath {math} at (0,0) size 784x53 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (232,0) size 320x53
+          RenderMathMLSquareRoot {msqrt} at (0,0) size 319x53
+            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x53
+              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x53
+                  RenderBlock (anonymous) at (0,0) size 13x53
+                    RenderText at (0,-56) size 13x106
+                      text run at (0,-56) width 13: "\x{221A}"
+            RenderMathMLRootWrapper at (17,2) size 302x51
+              RenderMathMLToken {mn} at (0,12) size 8x12
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                  RenderBlock (anonymous) at (0,0) size 8x12
+                    RenderText {#text} at (0,-46) size 8x106
+                      text run at (0,-46) width 8: "1"
+              RenderMathMLOperator {mo} at (8,13) size 20x12
+                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                  RenderBlock (anonymous) at (0,0) size 12x12
+                    RenderText at (0,-47) size 12x106
+                      text run at (0,-47) width 12: "+"
+              RenderMathMLSquareRoot {msqrt} at (27,0) size 275x51
+                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x51
+                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x51
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x51
+                      RenderBlock (anonymous) at (0,0) size 13x51
+                        RenderText at (0,-56) size 13x106
+                          text run at (0,-56) width 13: "\x{221A}"
+                RenderMathMLRootWrapper at (17,2) size 258x49
+                  RenderMathMLToken {mn} at (0,10) size 8x12
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                      RenderBlock (anonymous) at (0,0) size 8x12
+                        RenderText {#text} at (0,-46) size 8x106
+                          text run at (0,-46) width 8: "1"
+                  RenderMathMLOperator {mo} at (8,11) size 20x12
+                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                      RenderBlock (anonymous) at (0,0) size 12x12
+                        RenderText at (0,-47) size 12x106
+                          text run at (0,-47) width 12: "+"
+                  RenderMathMLSquareRoot {msqrt} at (27,0) size 231x49
+                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x49
+                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x49
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x48
+                          RenderBlock (anonymous) at (0,0) size 13x48
+                            RenderText at (0,-56) size 13x106
+                              text run at (0,-56) width 13: "\x{221A}"
+                    RenderMathMLRootWrapper at (17,2) size 214x47
+                      RenderMathMLToken {mn} at (0,8) size 8x12
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                          RenderBlock (anonymous) at (0,0) size 8x12
+                            RenderText {#text} at (0,-46) size 8x106
+                              text run at (0,-46) width 8: "1"
+                      RenderMathMLOperator {mo} at (8,9) size 20x12
+                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                          RenderBlock (anonymous) at (0,0) size 12x12
+                            RenderText at (0,-47) size 12x106
+                              text run at (0,-47) width 12: "+"
+                      RenderMathMLSquareRoot {msqrt} at (27,0) size 187x41
+                        RenderMathMLBlock (anonymous, flex) at (0,0) size 17x41
+                          RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x41
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 13x40
+                              RenderBlock (anonymous) at (0,0) size 13x40
+                                RenderText at (0,-56) size 13x106
+                                  text run at (0,-56) width 13: "\x{221A}"
+                        RenderMathMLRootWrapper at (17,2) size 169x39
+                          RenderMathMLToken {mn} at (0,6) size 8x12
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                              RenderBlock (anonymous) at (0,0) size 8x12
+                                RenderText {#text} at (0,-46) size 8x106
+                                  text run at (0,-46) width 8: "1"
+                          RenderMathMLOperator {mo} at (8,7) size 20x12
+                            RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                              RenderBlock (anonymous) at (0,0) size 12x12
+                                RenderText at (0,-47) size 12x106
+                                  text run at (0,-47) width 12: "+"
+                          RenderMathMLSquareRoot {msqrt} at (27,0) size 142x31
+                            RenderMathMLBlock (anonymous, flex) at (0,0) size 17x31
+                              RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                                  RenderBlock (anonymous) at (0,0) size 13x30
+                                    RenderText at (0,-56) size 13x106
+                                      text run at (0,-56) width 13: "\x{221A}"
+                            RenderMathMLRootWrapper at (17,2) size 125x29
+                              RenderMathMLToken {mn} at (0,4) size 8x12
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                  RenderBlock (anonymous) at (0,0) size 8x12
+                                    RenderText {#text} at (0,-46) size 8x106
+                                      text run at (0,-46) width 8: "1"
+                              RenderMathMLOperator {mo} at (8,5) size 20x12
+                                RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                  RenderBlock (anonymous) at (0,0) size 12x12
+                                    RenderText at (0,-47) size 12x106
+                                      text run at (0,-47) width 12: "+"
+                              RenderMathMLSquareRoot {msqrt} at (27,0) size 98x21
+                                RenderMathMLBlock (anonymous, flex) at (0,0) size 17x21
+                                  RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x21
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 13x20
+                                      RenderBlock (anonymous) at (0,0) size 13x20
+                                        RenderText at (0,-56) size 13x106
+                                          text run at (0,-56) width 13: "\x{221A}"
+                                RenderMathMLRootWrapper at (17,2) size 81x19
+                                  RenderMathMLToken {mn} at (0,2) size 8x12
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                      RenderBlock (anonymous) at (0,0) size 8x12
+                                        RenderText {#text} at (0,-46) size 8x106
+                                          text run at (0,-46) width 8: "1"
+                                  RenderMathMLOperator {mo} at (8,3) size 20x12
+                                    RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                      RenderBlock (anonymous) at (0,0) size 12x12
+                                        RenderText at (0,-47) size 12x106
+                                          text run at (0,-47) width 12: "+"
+                                  RenderMathMLSquareRoot {msqrt} at (27,0) size 54x18
+                                    RenderMathMLBlock (anonymous, flex) at (0,0) size 17x18
+                                      RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x18
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 13x17
+                                          RenderBlock (anonymous) at (0,0) size 13x17
+                                            RenderText at (0,-56) size 13x106
+                                              text run at (0,-56) width 13: "\x{221A}"
+                                    RenderMathMLRootWrapper at (17,2) size 37x16
+                                      RenderMathMLToken {mn} at (0,0) size 8x12
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x12
+                                          RenderBlock (anonymous) at (0,0) size 8x12
+                                            RenderText {#text} at (0,-46) size 8x106
+                                              text run at (0,-46) width 8: "1"
+                                      RenderMathMLOperator {mo} at (8,1) size 20x12
+                                        RenderMathMLBlock (anonymous, flex) at (3,0) size 13x12
+                                          RenderBlock (anonymous) at (0,0) size 12x12
+                                            RenderText at (0,-47) size 12x106
+                                              text run at (0,-47) width 12: "+"
+                                      RenderMathMLToken {mi} at (27,4) size 10x8 [padding: 0 2 0 0]
+                                        RenderMathMLBlock (anonymous, flex) at (0,0) size 8x8
+                                          RenderBlock (anonymous) at (0,0) size 8x8
+                                            RenderText {#text} at (0,-50) size 8x106
+                                              text run at (0,-50) width 8: "x"
+      RenderMathMLMath {math} at (0,68) size 784x62 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x53
+          RenderMathMLRootWrapper at (4,10) size 21x43
+            RenderMathMLSpace {mspace} at (0,0) size 20x10 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x53
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,30) size 53x31
+          RenderMathMLRootWrapper at (4,7) size 21x24
+            RenderMathMLSpace {mspace} at (0,0) size 20x5 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x31
+            RenderMathMLRadicalOperator (anonymous) at (0,0) size 17x31
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,2) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
+      RenderMathMLMath {math} at (0,145) size 784x91 [padding: 0 1 0 1]
+        RenderMathMLRoot {mroot} at (339,0) size 53x82
+          RenderMathMLRootWrapper at (4,0) size 21x82
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#008000]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x82
+            RenderMathMLRadicalOperator (anonymous) at (0,29) size 17x53
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x52
+                RenderBlock (anonymous) at (0,0) size 13x52
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,31) size 21x51
+            RenderMathMLSpace {mspace} at (0,0) size 20x50 [bgcolor=#FF0000]
+        RenderMathMLRoot {mroot} at (392,52) size 53x38
+          RenderMathMLRootWrapper at (4,0) size 21x38
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#0000FF]
+          RenderMathMLBlock (anonymous, flex) at (15,0) size 18x38
+            RenderMathMLRadicalOperator (anonymous) at (0,8) size 17x30
+              RenderMathMLBlock (anonymous, flex) at (0,0) size 13x30
+                RenderBlock (anonymous) at (0,0) size 13x30
+                  RenderText at (0,-56) size 13x106
+                    text run at (0,-56) width 13: "\x{221A}"
+          RenderMathMLRootWrapper at (32,9) size 21x29
+            RenderMathMLSpace {mspace} at (0,0) size 20x20 [bgcolor=#FF0000]
index 661de2f..eab426a 100644 (file)
@@ -2384,6 +2384,7 @@ set(WebCore_SOURCES
     rendering/mathml/RenderMathMLMath.cpp
     rendering/mathml/RenderMathMLMenclose.cpp
     rendering/mathml/RenderMathMLOperator.cpp
+    rendering/mathml/RenderMathMLRadicalOperator.cpp
     rendering/mathml/RenderMathMLRoot.cpp
     rendering/mathml/RenderMathMLRow.cpp
     rendering/mathml/RenderMathMLScripts.cpp
index 17577f3..793790b 100644 (file)
@@ -1,3 +1,77 @@
+2014-06-16  Frédéric Wang  <fred.wang@free.fr>
+
+        Draw radicals with glyphs for better rendering
+        https://bugs.webkit.org/show_bug.cgi?id=119038
+
+        Reviewed by Chris Fleizach.
+
+        We rewrite RenderMathMLRoot in order to fix bugs with SVG transforms and dynamic modification of children and allow drawing with an OpenType MATH table.
+        The drawing of the radical sign (without the top bar) is now moved to a RenderMathMLRadicalOperator class inheriting from RenderMathMLOperator.
+        This class fallbacks to the original drawing with graphic primitives if an OpenType MATH table is not available.
+
+        Tests: mathml/opentype/roots-LatinModern.html
+               mathml/presentation/mroot-transform.html
+
+        * CMakeLists.txt: add files to build system.
+        * WebCore.vcxproj/WebCore.vcxproj: ditto.
+        * WebCore.vcxproj/WebCore.vcxproj.filters: ditto.
+        * WebCore.xcodeproj/project.pbxproj: ditto
+        * css/mathml.css: remove rules for msqrt/mroot. The "script level" in mroot is not incremented by 2 as specified in the spec.
+        (math, mrow, mfenced, merror, mphantom, mstyle, menclose):
+        (mroot > *:last-child):
+        (math, mrow, mfenced, msqrt, mroot, merror, mphantom, mstyle, menclose): Deleted.
+        (msqrt > *): Deleted.
+        (mroot): Deleted. This rule was causing bug 126516.
+        (mroot > * + *): Deleted.
+        * rendering/RenderObject.h: Add two new isRenderMathML* functions for dynamic casting.
+        (WebCore::RenderObject::isRenderMathMLRadicalOperator):
+        (WebCore::RenderObject::isRenderMathMLRootWrapper):
+        * rendering/mathml/RenderMathMLOperator.cpp: Accept a set of operator dictionary flags, all disabled by default. This is to allow anonymous radicas, which don't have any flag.
+        isFencedOperator() is now replaced with the more general isAnonymous() since we allow anonymous radical operator fors msqrt/mroot.
+        (WebCore::RenderMathMLOperator::RenderMathMLOperator):
+        (WebCore::RenderMathMLOperator::setOperatorFlagFromAttribute):
+        (WebCore::RenderMathMLOperator::setOperatorPropertiesFromOpDictEntry):
+        (WebCore::RenderMathMLOperator::SetOperatorProperties):
+        (WebCore::RenderMathMLOperator::updateTokenContent):
+        * rendering/mathml/RenderMathMLOperator.h: Allow class to be overriden, redefine the anonymous constructor, remove isFencedOperator().
+        * rendering/mathml/RenderMathMLRadicalOperator.cpp: Added.
+        (WebCore::RenderMathMLRadicalOperator::RenderMathMLRadicalOperator):
+        (WebCore::RenderMathMLRadicalOperator::stretchTo):
+        (WebCore::RenderMathMLRadicalOperator::SetOperatorProperties):
+        (WebCore::RenderMathMLRadicalOperator::computePreferredLogicalWidths):
+        (WebCore::RenderMathMLRadicalOperator::computeLogicalHeight):
+        (WebCore::RenderMathMLRadicalOperator::paint):
+        (WebCore::RenderMathMLRadicalOperator::trailingSpaceError):
+        * rendering/mathml/RenderMathMLRadicalOperator.h: Added.
+        * rendering/mathml/RenderMathMLRoot.cpp: Rewritten. Some parts to use graphic primitives are moved to RenderMathMLRadicalOperator.cpp.
+        (WebCore::RenderMathMLRoot::RenderMathMLRoot):
+        (WebCore::RenderMathMLRoot::baseWrapper):
+        (WebCore::RenderMathMLRoot::radicalWrapper):
+        (WebCore::RenderMathMLRoot::indexWrapper):
+        (WebCore::RenderMathMLRoot::radicalOperator):
+        (WebCore::RenderMathMLRoot::restructureWrappers):
+        (WebCore::RenderMathMLRoot::addChild):
+        (WebCore::RenderMathMLRoot::styleDidChange):
+        (WebCore::RenderMathMLRoot::updateFromElement):
+        (WebCore::RenderMathMLRoot::updateStyle):
+        (WebCore::RenderMathMLRoot::firstLineBaseline):
+        (WebCore::RenderMathMLRoot::layout):
+        (WebCore::RenderMathMLRoot::paint):
+        (WebCore::RenderMathMLRootWrapper::createAnonymousWrapper):
+        (WebCore::RenderMathMLRootWrapper::removeChildWithoutRestructuring):
+        (WebCore::RenderMathMLRootWrapper::removeChild):
+        (WebCore::RenderMathMLRoot::paddingTop): Deleted.
+        (WebCore::RenderMathMLRoot::paddingBottom): Deleted.
+        (WebCore::RenderMathMLRoot::paddingLeft): Deleted.
+        (WebCore::RenderMathMLRoot::paddingRight): Deleted.
+        (WebCore::RenderMathMLRoot::paddingBefore): Deleted.
+        (WebCore::RenderMathMLRoot::paddingAfter): Deleted.
+        (WebCore::RenderMathMLRoot::paddingStart): Deleted.
+        (WebCore::RenderMathMLRoot::paddingEnd): Deleted.
+        (WebCore::RenderMathMLRoot::index): Deleted.
+        * rendering/mathml/RenderMathMLRoot.h: Rewritten.
+        (WebCore::RenderMathMLRootWrapper::RenderMathMLRootWrapper):
+
 2014-06-16  Krzysztof Czech  <k.czech@samsung.com>
 
         [EFL] Platform support for WebSpeech feature.
index 0cc2de1..ccf9590 100644 (file)
     <ClCompile Include="..\rendering\mathml\RenderMathMLMath.cpp" />
     <ClCompile Include="..\rendering\mathml\RenderMathMLMenclose.cpp" />
     <ClCompile Include="..\rendering\mathml\RenderMathMLOperator.cpp" />
+    <ClCompile Include="..\rendering\mathml\RenderMathMLRadicalOperator.cpp" />
     <ClCompile Include="..\rendering\mathml\RenderMathMLRoot.cpp" />
     <ClCompile Include="..\rendering\mathml\RenderMathMLRow.cpp" />
     <ClCompile Include="..\rendering\mathml\RenderMathMLSpace.cpp" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLMath.h" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLMenclose.h" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLOperator.h" />
+    <ClInclude Include="..\rendering\mathml\RenderMathMLRadicalOperator.h" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLRoot.h" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLRow.h" />
     <ClInclude Include="..\rendering\mathml\RenderMathMLSpace.h" />
index 7974d64..7a83880 100644 (file)
     <ClCompile Include="..\rendering\mathml\RenderMathMLOperator.cpp">
       <Filter>rendering\mathml</Filter>
     </ClCompile>
+    <ClCompile Include="..\rendering\mathml\RenderMathMLRadicalOperator.cpp">
+      <Filter>rendering\mathml</Filter>
+    </ClCompile>
     <ClCompile Include="..\rendering\mathml\RenderMathMLRoot.cpp">
       <Filter>rendering\mathml</Filter>
     </ClCompile>
     <ClInclude Include="..\rendering\mathml\RenderMathMLOperator.h">
       <Filter>rendering\mathml</Filter>
     </ClInclude>
+    <ClInclude Include="..\rendering\mathml\RenderMathMLRadicalOperator.h">
+      <Filter>rendering\mathml</Filter>
+    </ClInclude>
     <ClInclude Include="..\rendering\mathml\RenderMathMLRoot.h">
       <Filter>rendering\mathml</Filter>
     </ClInclude>
index c2a779a..bdddf1c 100644 (file)
                439046DE12DA25E800AF80A2 /* RenderMathMLMath.h in Headers */ = {isa = PBXBuildFile; fileRef = 439046CA12DA25E800AF80A2 /* RenderMathMLMath.h */; };
                439046DF12DA25E800AF80A2 /* RenderMathMLOperator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 439046CB12DA25E800AF80A2 /* RenderMathMLOperator.cpp */; };
                439046E012DA25E800AF80A2 /* RenderMathMLOperator.h in Headers */ = {isa = PBXBuildFile; fileRef = 439046CC12DA25E800AF80A2 /* RenderMathMLOperator.h */; };
+               439046DF12DA25E800BF80A3 /* RenderMathMLRadicalOperator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 439046CB12DA25E800BF80A3 /* RenderMathMLRadicalOperator.cpp */; };
+               439046E012DA25E800BF80A3 /* RenderMathMLRadicalOperator.h in Headers */ = {isa = PBXBuildFile; fileRef = 439046CC12DA25E800BF80A3 /* RenderMathMLRadicalOperator.h */; };
                439046E112DA25E800AF80A2 /* RenderMathMLRoot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 439046CD12DA25E800AF80A2 /* RenderMathMLRoot.cpp */; };
                439046E212DA25E800AF80A2 /* RenderMathMLRoot.h in Headers */ = {isa = PBXBuildFile; fileRef = 439046CE12DA25E800AF80A2 /* RenderMathMLRoot.h */; };
                439046E312DA25E800AF80A2 /* RenderMathMLRow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 439046CF12DA25E800AF80A2 /* RenderMathMLRow.cpp */; };
                439046CA12DA25E800AF80A2 /* RenderMathMLMath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RenderMathMLMath.h; path = mathml/RenderMathMLMath.h; sourceTree = "<group>"; };
                439046CB12DA25E800AF80A2 /* RenderMathMLOperator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RenderMathMLOperator.cpp; path = mathml/RenderMathMLOperator.cpp; sourceTree = "<group>"; };
                439046CC12DA25E800AF80A2 /* RenderMathMLOperator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RenderMathMLOperator.h; path = mathml/RenderMathMLOperator.h; sourceTree = "<group>"; };
+               439046CB12DA25E800BF80A3 /* RenderMathMLRadicalOperator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RenderMathMLRadicalOperator.cpp; path = mathml/RenderMathMLRadicalOperator.cpp; sourceTree = "<group>"; };
+               439046CC12DA25E800BF80A3 /* RenderMathMLRadicalOperator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RenderMathMLRadicalOperator.h; path = mathml/RenderMathMLRadicalOperator.h; sourceTree = "<group>"; };
                439046CD12DA25E800AF80A2 /* RenderMathMLRoot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RenderMathMLRoot.cpp; path = mathml/RenderMathMLRoot.cpp; sourceTree = "<group>"; };
                439046CE12DA25E800AF80A2 /* RenderMathMLRoot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RenderMathMLRoot.h; path = mathml/RenderMathMLRoot.h; sourceTree = "<group>"; };
                439046CF12DA25E800AF80A2 /* RenderMathMLRow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RenderMathMLRow.cpp; path = mathml/RenderMathMLRow.cpp; sourceTree = "<group>"; };
                                A208E222A56A0C7575F2A72E /* RenderMathMLMenclose.h */,
                                439046CB12DA25E800AF80A2 /* RenderMathMLOperator.cpp */,
                                439046CC12DA25E800AF80A2 /* RenderMathMLOperator.h */,
+                               439046CB12DA25E800BF80A3 /* RenderMathMLRadicalOperator.cpp */,
+                               439046CC12DA25E800BF80A3 /* RenderMathMLRadicalOperator.h */,
                                439046CD12DA25E800AF80A2 /* RenderMathMLRoot.cpp */,
                                439046CE12DA25E800AF80A2 /* RenderMathMLRoot.h */,
                                439046CF12DA25E800AF80A2 /* RenderMathMLRow.cpp */,
                                07AB996F18DA3C740018771E /* RTCConfigurationPrivate.h in Headers */,
                                439046DE12DA25E800AF80A2 /* RenderMathMLMath.h in Headers */,
                                439046E012DA25E800AF80A2 /* RenderMathMLOperator.h in Headers */,
+                               439046E012DA25E800BF80A3 /* RenderMathMLRadicalOperator.h in Headers */,
                                439046E212DA25E800AF80A2 /* RenderMathMLRoot.h in Headers */,
                                439046E412DA25E800AF80A2 /* RenderMathMLRow.h in Headers */,
                                439046E812DA25E800AF80A2 /* RenderMathMLScripts.h in Headers */,
                                439046DD12DA25E800AF80A2 /* RenderMathMLMath.cpp in Sources */,
                                3571883EEF618793751E4089 /* RenderMathMLMenclose.cpp in Sources */,
                                439046DF12DA25E800AF80A2 /* RenderMathMLOperator.cpp in Sources */,
+                               439046DF12DA25E800BF80A3 /* RenderMathMLRadicalOperator.cpp in Sources */,
                                439046E112DA25E800AF80A2 /* RenderMathMLRoot.cpp in Sources */,
                                439046E312DA25E800AF80A2 /* RenderMathMLRow.cpp in Sources */,
                                439046E712DA25E800AF80A2 /* RenderMathMLScripts.cpp in Sources */,
index 362c1c3..d9b4794 100644 (file)
@@ -37,12 +37,9 @@ mi, mo, mrow, mfenced, mfrac, msub, msup, msubsup, mmultiscripts, mprescripts, n
     display: -webkit-inline-flex !important;
 }
 
-math, mrow, mfenced, msqrt, mroot, merror, mphantom, mstyle, menclose {
+math, mrow, mfenced, merror, mphantom, mstyle, menclose {
     -webkit-align-items: baseline;
 }
-msqrt > * { /* This rule is needed because of <msqrt>'s anonymous <mrow>. */
-    -webkit-align-self: baseline;
-}
 
 mo, mfrac, munder, mover, munderover {
     -webkit-flex-direction: column;
@@ -85,6 +82,9 @@ mover > :last-child, munderover > :last-child {
 msub > * + *, msup > * + *, msubsup > * + *, mmultiscripts > * + *, munder > * + *, mover > * + *, munderover > * + * {
     font-size: 0.75em; /* FIXME: MathML standard is 0.71em */
 }
+mroot > *:last-child {
+    font-size: 0.5625em; /* This 0.75^2 since the scriptlevel is incremented by 2 in the index. */
+}
 
 mi {
     -webkit-padding-end: 0.1em;
@@ -96,19 +96,6 @@ msubsup > mi:first-child + * + * {
     -webkit-margin-start: 0.14em; /* This is larger than 0.1em because the child's font-size is smaller than the <msubsup>'s. */
 }
 
-mroot {
-    position: relative;
-}
-mroot > * + * {
-    font-size: 0.75em;
-    position: absolute;
-    left: 0;
-    top: 0;
-    padding-right: 0.4em;
-    padding-left: 0.2em;
-    padding-bottom: 0.35em;
-}
-
 math[mathvariant="normal"], mstyle[mathvariant="normal"], mo[mathvariant="normal"], mn[mathvariant="normal"], mi[mathvariant="normal"], mtext[mathvariant="normal"], mspace[mathvariant="normal"], ms[mathvariant="normal"] {
     font-style: normal;
     font-weight: normal;
index 6492a00..64b12ae 100644 (file)
@@ -410,11 +410,13 @@ public:
     virtual bool isRenderMathMLBlock() const { return false; }
     virtual bool isRenderMathMLTable() const { return false; }
     virtual bool isRenderMathMLOperator() const { return false; }
+    virtual bool isRenderMathMLRadicalOperator() const { return false; }
     virtual bool isRenderMathMLRow() const { return false; }
     virtual bool isRenderMathMLMath() const { return false; }
     virtual bool isRenderMathMLFenced() const { return false; }
     virtual bool isRenderMathMLFraction() const { return false; }
     virtual bool isRenderMathMLRoot() const { return false; }
+    virtual bool isRenderMathMLRootWrapper() const { return false; }
     virtual bool isRenderMathMLSpace() const { return false; }
     virtual bool isRenderMathMLSquareRoot() const { return false; }
     virtual bool isRenderMathMLScripts() const { return false; }
index 34788b0..2c68a8f 100644 (file)
@@ -1145,21 +1145,21 @@ RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, PassRef<Rende
     updateTokenContent();
 }
 
-RenderMathMLOperator::RenderMathMLOperator(Document& document, PassRef<RenderStyle> style, const String& operatorString, MathMLOperatorDictionary::Form form, MathMLOperatorDictionary::Flag flag)
+RenderMathMLOperator::RenderMathMLOperator(Document& document, PassRef<RenderStyle> style, const String& operatorString, MathMLOperatorDictionary::Form form, unsigned short flags)
     : RenderMathMLToken(document, std::move(style))
     , m_stretchHeightAboveBaseline(0)
     , m_stretchDepthBelowBaseline(0)
     , m_operator(0)
     , m_isVertical(true)
     , m_operatorForm(form)
-    , m_operatorFlags(flag)
+    , m_operatorFlags(flags)
 {
     updateTokenContent(operatorString);
 }
 
 void RenderMathMLOperator::setOperatorFlagFromAttribute(MathMLOperatorDictionary::Flag flag, const QualifiedName& name)
 {
-    ASSERT(!isFencedOperator());
+    ASSERT(!isAnonymous());
     const AtomicString& attributeValue = element().fastGetAttribute(name);
     if (attributeValue == "true")
         m_operatorFlags |= flag;
@@ -1170,8 +1170,8 @@ void RenderMathMLOperator::setOperatorFlagFromAttribute(MathMLOperatorDictionary
 
 void RenderMathMLOperator::setOperatorPropertiesFromOpDictEntry(const MathMLOperatorDictionary::Entry* entry)
 {
-    // If this operator has been created by RenderMathMLFenced, we preserve the Fence and Separator properties.
-    if (isFencedOperator())
+    // If this operator is anonymous, we preserve the Fence and Separator properties. This is to handle the case of RenderMathMLFenced.
+    if (isAnonymous())
         m_operatorFlags = (m_operatorFlags & (MathMLOperatorDictionary::Fence | MathMLOperatorDictionary::Separator)) | entry->flags;
     else
         m_operatorFlags = entry->flags;
@@ -1188,7 +1188,7 @@ void RenderMathMLOperator::SetOperatorProperties()
 
     // We determine the form of the operator.
     bool explicitForm = true;
-    if (!isFencedOperator()) {
+    if (!isAnonymous()) {
         const AtomicString& form = element().fastGetAttribute(MathMLNames::formAttr);
         if (form == "prefix")
             m_operatorForm = MathMLOperatorDictionary::Prefix;
@@ -1211,7 +1211,7 @@ void RenderMathMLOperator::SetOperatorProperties()
     // We determine the default values of the operator properties.
 
     // First we initialize with the default values for unknown operators.
-    if (isFencedOperator())
+    if (isAnonymous())
         m_operatorFlags &= MathMLOperatorDictionary::Fence | MathMLOperatorDictionary::Separator; // This resets all but the Fence and Separator properties.
     else
         m_operatorFlags = 0; // This resets all the operator properties.
@@ -1238,7 +1238,7 @@ void RenderMathMLOperator::SetOperatorProperties()
     }
 #undef MATHML_OPDICT_SIZE
 
-    if (!isFencedOperator()) {
+    if (!isAnonymous()) {
         // Finally, we make the attribute values override the default.
 
         setOperatorFlagFromAttribute(MathMLOperatorDictionary::Fence, MathMLNames::fenceAttr);
@@ -1386,13 +1386,13 @@ void RenderMathMLOperator::rebuildTokenContent(const String& operatorString)
 
 void RenderMathMLOperator::updateTokenContent(const String& operatorString)
 {
-    ASSERT(isFencedOperator());
+    ASSERT(isAnonymous());
     rebuildTokenContent(operatorString);
 }
 
 void RenderMathMLOperator::updateTokenContent()
 {
-    ASSERT(!isFencedOperator());
+    ASSERT(!isAnonymous());
     rebuildTokenContent(element().textContent());
 }
 
index fe19502..c209878 100644 (file)
@@ -58,12 +58,12 @@ struct Entry {
 
 }
 
-class RenderMathMLOperator final : public RenderMathMLToken {
+class RenderMathMLOperator : public RenderMathMLToken {
 public:
     RenderMathMLOperator(MathMLElement&, PassRef<RenderStyle>);
-    RenderMathMLOperator(Document&, PassRef<RenderStyle>, const String& operatorString, MathMLOperatorDictionary::Form, MathMLOperatorDictionary::Flag);
+    RenderMathMLOperator(Document&, PassRef<RenderStyle>, const String& operatorString, MathMLOperatorDictionary::Form, unsigned short flags = 0);
 
-    void stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline);
+    virtual void stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline);
     void stretchTo(LayoutUnit width);
     LayoutUnit stretchSize() const { return m_isVertical ? m_stretchHeightAboveBaseline + m_stretchDepthBelowBaseline : m_stretchWidth; }
     
@@ -73,17 +73,16 @@ public:
 
     void updateStyle() override final;
 
-    void paint(PaintInfo&, const LayoutPoint&);
+    virtual void paint(PaintInfo&, const LayoutPoint&);
 
     void updateTokenContent(const String& operatorString);
     void updateTokenContent() override final;
     void updateOperatorProperties();
 
-private:
+protected:
     virtual const char* renderName() const override { return isAnonymous() ? "RenderMathMLOperator (anonymous)" : "RenderMathMLOperator"; }
     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect) override;
     virtual bool isRenderMathMLOperator() const override { return true; }
-    bool isFencedOperator() { return isAnonymous(); }
     // The following operators are invisible: U+2061 FUNCTION APPLICATION, U+2062 INVISIBLE TIMES, U+2063 INVISIBLE SEPARATOR, U+2064 INVISIBLE PLUS.
     bool isInvisibleOperator() const { return 0x2061 <= m_operator && m_operator <= 0x2064; }
     virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const override;
@@ -187,7 +186,7 @@ private:
 
     void setOperatorFlagFromAttribute(MathMLOperatorDictionary::Flag, const QualifiedName&);
     void setOperatorPropertiesFromOpDictEntry(const MathMLOperatorDictionary::Entry*);
-    void SetOperatorProperties();
+    virtual void SetOperatorProperties();
 };
 
 RENDER_OBJECT_TYPE_CASTS(RenderMathMLOperator, isRenderMathMLOperator())
diff --git a/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.cpp b/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.cpp
new file mode 100644 (file)
index 0000000..1309cfe
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2014 Frédéric Wang (fred.wang@free.fr). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(MATHML)
+#include "RenderMathMLRadicalOperator.h"
+
+namespace WebCore {
+
+using namespace MathMLNames;
+
+static const UChar gRadicalCharacter = 0x221A;
+
+// This class relies on the RenderMathMLOperator class to draw a radical symbol.
+// This does not work well when an OpenType MATH font is not available.
+// In that case, we fallback to the old implementation of RenderMathMLRoot.cpp with graphic primitives.
+
+// Normal width of the front of the radical sign, before the base & overbar (em)
+const float gFrontWidthEms = 0.75f;
+// Horizontal position of the bottom point of the radical (* frontWidth)
+const float gRadicalBottomPointXFront = 0.5f;
+// Lower the radical sign's bottom point (px)
+const int gRadicalBottomPointLower = 3;
+// Horizontal position of the top left point of the radical "dip" (* frontWidth)
+const float gRadicalDipLeftPointXFront = 0.8f;
+// Vertical position of the top left point of a sqrt radical "dip" (* baseHeight)
+const float gSqrtRadicalDipLeftPointYPos = 0.5f;
+// Vertical shift of the left end point of the radical (em)
+const float gRadicalLeftEndYShiftEms = 0.05f;
+
+// Radical line thickness (em)
+const float gRadicalLineThicknessEms = 0.02f;
+// Radical thick line thickness (em)
+const float gRadicalThickLineThicknessEms = 0.1f;
+
+RenderMathMLRadicalOperator::RenderMathMLRadicalOperator(Document& document, PassRef<RenderStyle> style)
+    : RenderMathMLOperator(document, std::move(style), String(&gRadicalCharacter, 1), MathMLOperatorDictionary::Prefix)
+{
+}
+
+void RenderMathMLRadicalOperator::stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline)
+{
+    const auto& primaryFontData = style().font().primaryFont();
+    if (!primaryFontData || !primaryFontData->mathData()) {
+        // If we do not have an OpenType MATH font, we always make the radical depth a bit larger than the target.
+        depthBelowBaseline += gRadicalBottomPointLower;
+    }
+
+    RenderMathMLOperator::stretchTo(heightAboveBaseline, depthBelowBaseline);
+}
+
+void RenderMathMLRadicalOperator::SetOperatorProperties()
+{
+    RenderMathMLOperator::SetOperatorProperties();
+    // We remove spacing around the radical symbol.
+    m_leadingSpace = 0;
+    m_trailingSpace = 0;
+}
+
+void RenderMathMLRadicalOperator::computePreferredLogicalWidths()
+{
+    ASSERT(preferredLogicalWidthsDirty());
+
+    const auto& primaryFontData = style().font().primaryFont();
+    if (primaryFontData && primaryFontData->mathData()) {
+        RenderMathMLOperator::computePreferredLogicalWidths();
+        return;
+    }
+
+    // If we do not have an OpenType MATH font, the front width is just given by the gFrontWidthEms constant.
+    int frontWidth = lroundf(gFrontWidthEms * style().fontSize());
+    m_minPreferredLogicalWidth = frontWidth;
+    m_maxPreferredLogicalWidth = frontWidth;
+}
+
+void RenderMathMLRadicalOperator::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
+{
+    const auto& primaryFontData = style().font().primaryFont();
+    if (primaryFontData && primaryFontData->mathData()) {
+        RenderMathMLOperator::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
+        return;
+    }
+
+    // If we do not have an OpenType MATH font, the logical height is always the stretch size.
+    logicalHeight = stretchSize();
+    RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
+}
+
+void RenderMathMLRadicalOperator::paint(PaintInfo& info, const LayoutPoint& paintOffset)
+{
+    if (info.context->paintingDisabled() || info.phase != PaintPhaseForeground || style().visibility() != VISIBLE)
+        return;
+
+    const auto& primaryFontData = style().font().primaryFont();
+    if (primaryFontData && primaryFontData->mathData()) {
+        RenderMathMLOperator::paint(info, paintOffset);
+        return;
+    }
+
+    // If we do not have an OpenType MATH font, we paint the radical sign with graphic primitives.
+    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + contentBoxRect().location());
+    int frontWidth = lroundf(gFrontWidthEms * style().fontSize());
+    int startX = adjustedPaintOffset.x() + frontWidth;
+    int baseHeight = stretchSize() - gRadicalBottomPointLower;
+
+    float radicalDipLeftPointYPos = gSqrtRadicalDipLeftPointYPos * baseHeight;
+
+    FloatPoint overbarLeftPoint(startX, adjustedPaintOffset.y());
+    FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);
+    FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + radicalDipLeftPointYPos);
+    FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style().fontSize());
+
+    GraphicsContextStateSaver stateSaver(*info.context);
+
+    info.context->setStrokeThickness(gRadicalLineThicknessEms * style().fontSize());
+    info.context->setStrokeStyle(SolidStroke);
+    info.context->setStrokeColor(style().visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
+    info.context->setLineJoin(MiterJoin);
+    info.context->setMiterLimit(style().fontSize());
+
+    Path root;
+
+    root.moveTo(FloatPoint(overbarLeftPoint.x(), adjustedPaintOffset.y()));
+    // draw from top left corner to bottom point of radical
+    root.addLineTo(bottomPoint);
+    // draw from bottom point to top of left part of radical base "dip"
+    root.addLineTo(dipLeftPoint);
+    // draw to end
+    root.addLineTo(leftEnd);
+
+    info.context->strokePath(root);
+
+    GraphicsContextStateSaver maskStateSaver(*info.context);
+
+    // Build a mask to draw the thick part of the root.
+    Path mask;
+
+    mask.moveTo(overbarLeftPoint);
+    mask.addLineTo(bottomPoint);
+    mask.addLineTo(dipLeftPoint);
+    mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));
+
+    info.context->clip(mask);
+
+    // Draw the thick part of the root.
+    info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style().fontSize());
+    info.context->setLineCap(SquareCap);
+
+    Path line;
+    line.moveTo(bottomPoint);
+    line.addLineTo(dipLeftPoint);
+
+    info.context->strokePath(line);
+}
+
+LayoutUnit RenderMathMLRadicalOperator::trailingSpaceError()
+{
+    const auto& primaryFontData = style().font().primaryFont();
+    if (!primaryFontData || !primaryFontData->mathData())
+        return 0;
+
+    // For OpenType MATH font, the layout is based on RenderMathOperator for which the preferred width is sometimes overestimated (bug https://bugs.webkit.org/show_bug.cgi?id=130326).
+    // Hence we determine the error in the logical width with respect to the actual width of the glyph(s) used to paint the radical.
+    LayoutUnit width = logicalWidth();
+
+    if (m_stretchyData.mode() == DrawNormal) {
+        GlyphData data = style().font().glyphDataForCharacter(m_operator, !style().isLeftToRightDirection());
+        return width - advanceForGlyph(data);
+    }
+
+    if (m_stretchyData.mode() == DrawSizeVariant)
+        return width - advanceForGlyph(m_stretchyData.variant());
+
+    float assemblyWidth = advanceForGlyph(m_stretchyData.top());
+    assemblyWidth = std::max(assemblyWidth, advanceForGlyph(m_stretchyData.bottom()));
+    assemblyWidth = std::max(assemblyWidth, advanceForGlyph(m_stretchyData.extension()));
+    if (m_stretchyData.middle().glyph)
+        assemblyWidth = std::max(assemblyWidth, advanceForGlyph(m_stretchyData.middle()));
+    return width - assemblyWidth;
+}
+
+}
+
+#endif
diff --git a/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.h b/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.h
new file mode 100644 (file)
index 0000000..40aa9f8
--- /dev/null
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2014 Frédéric Wang (fred.wang@free.fr). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RenderMathMLOperator_h
+#define RenderMathMLRadicalOperator_h
+
+#if ENABLE(MATHML)
+
+#include "PaintInfo.h"
+#include "RenderMathMLOperator.h"
+
+namespace WebCore {
+
+class RenderMathMLRadicalOperator final : public RenderMathMLOperator {
+public:
+    RenderMathMLRadicalOperator(Document&, PassRef<RenderStyle>);
+    virtual void stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline);
+    virtual void computePreferredLogicalWidths() override;
+    virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const override;
+    virtual void paint(PaintInfo&, const LayoutPoint& paintOffset) override;
+    LayoutUnit trailingSpaceError();
+
+private:
+    virtual bool isRenderMathMLRadicalOperator() const override { return true; }
+    virtual const char* renderName() const override { return isAnonymous() ? "RenderMathMLRadicalOperator (anonymous)" : "RenderMathMLRadicalOperator"; }
+    void SetOperatorProperties() override;
+};
+
+RENDER_OBJECT_TYPE_CASTS(RenderMathMLRadicalOperator, isRenderMathMLRadicalOperator())
+
+}
+
+#endif // ENABLE(MATHML)
+#endif // RenderMathMLRadicalOperator_h
index 0e975c7..d07ce23 100644 (file)
 
 #include "RenderMathMLRoot.h"
 
+#include "FontCache.h"
 #include "GraphicsContext.h"
 #include "PaintInfo.h"
 #include "RenderIterator.h"
-#include "RenderMathMLRow.h"
+#include "RenderMathMLRadicalOperator.h"
 
 namespace WebCore {
     
-// FIXME: This whole file should be changed to work with various writing modes. See https://bugs.webkit.org/show_bug.cgi?id=48951.
-
-// Threshold above which the radical shape is modified to look nice with big bases (em)
-const float gThresholdBaseHeightEms = 1.5f;
-// Normal width of the front of the radical sign, before the base & overbar (em)
-const float gFrontWidthEms = 0.75f;
-// Gap between the base and overbar (em)
-const float gSpaceAboveEms = 0.2f;
-// Horizontal position of the bottom point of the radical (* frontWidth)
-const float gRadicalBottomPointXFront = 0.5f;
-// Lower the radical sign's bottom point (px)
-const int gRadicalBottomPointLower = 3;
-// Horizontal position of the top left point of the radical "dip" (* frontWidth)
-const float gRadicalDipLeftPointXFront = 0.8f;
-// Vertical position of the top left point of a sqrt radical "dip" (* baseHeight)
-const float gSqrtRadicalDipLeftPointYPos = 0.5f;
-// Vertical position of the top left point of an nth root radical "dip" (* baseHeight)
-const float gRootRadicalDipLeftPointYPos = 0.625f;
-// Vertical shift of the left end point of the radical (em)
-const float gRadicalLeftEndYShiftEms = 0.05f;
-// Additional bottom root padding if baseHeight > threshold (em)
-const float gBigRootBottomPaddingEms = 0.2f;
-
-// Radical line thickness (em)
-const float gRadicalLineThicknessEms = 0.02f;
-// Radical thick line thickness (em)
-const float gRadicalThickLineThicknessEms = 0.1f;
-    
+// RenderMathMLRoot implements drawing of radicals via the <mroot> and <msqrt> elements. For valid MathML elements, the DOM is
+//
+// <mroot> Base Index </mroot>
+// <msqrt> Child1 Child2 ... ChildN </msqrt>
+//
+// and the structure of the render tree will be
+//
+// IndexWrapper RadicalWrapper BaseWrapper
+//
+// where RadicalWrapper contains an <mo>&#x221A;</mo>.
+// For <mroot>, the IndexWrapper and BaseWrapper should contain exactly one child (Index and Base respectively).
+// For <msqrt>, the IndexWrapper should be empty and the BaseWrapper can contain any number of children (Child1, ... ChildN).
+//
+// In order to accept invalid markup and to handle <mroot> and <msqrt> consistently, we will allow any number of children in the BaseWrapper of <mroot> too.
+// We will allow the IndexWrapper to be empty and it will always contain the last child of the <mroot> if there are at least 2 elements.
+
 RenderMathMLRoot::RenderMathMLRoot(Element& element, PassRef<RenderStyle> style)
     : RenderMathMLBlock(element, std::move(style))
-    , m_intrinsicPaddingBefore(0)
-    , m_intrinsicPaddingAfter(0)
-    , m_intrinsicPaddingStart(0)
-    , m_intrinsicPaddingEnd(0)
 {
 }
 
 RenderMathMLRoot::RenderMathMLRoot(Document& document, PassRef<RenderStyle> style)
     : RenderMathMLBlock(document, std::move(style))
-    , m_intrinsicPaddingBefore(0)
-    , m_intrinsicPaddingAfter(0)
-    , m_intrinsicPaddingStart(0)
-    , m_intrinsicPaddingEnd(0)
 {
 }
-LayoutUnit RenderMathMLRoot::paddingTop() const
+
+RenderMathMLRootWrapper* RenderMathMLRoot::baseWrapper() const
 {
-    LayoutUnit result = computedCSSPaddingTop();
-    switch (style().writingMode()) {
-    case TopToBottomWritingMode:
-        return result + m_intrinsicPaddingBefore;
-    case BottomToTopWritingMode:
-        return result + m_intrinsicPaddingAfter;
-    case LeftToRightWritingMode:
-    case RightToLeftWritingMode:
-        return result + (style().isLeftToRightDirection() ? m_intrinsicPaddingStart : m_intrinsicPaddingEnd);
-    }
-    ASSERT_NOT_REACHED();
-    return result;
+    ASSERT(!isEmpty());
+    return toRenderMathMLRootWrapper(lastChild());
 }
 
-LayoutUnit RenderMathMLRoot::paddingBottom() const
+RenderMathMLBlock* RenderMathMLRoot::radicalWrapper() const
 {
-    LayoutUnit result = computedCSSPaddingBottom();
-    switch (style().writingMode()) {
-    case TopToBottomWritingMode:
-        return result + m_intrinsicPaddingAfter;
-    case BottomToTopWritingMode:
-        return result + m_intrinsicPaddingBefore;
-    case LeftToRightWritingMode:
-    case RightToLeftWritingMode:
-        return result + (style().isLeftToRightDirection() ? m_intrinsicPaddingEnd : m_intrinsicPaddingStart);
-    }
-    ASSERT_NOT_REACHED();
-    return result;
+    ASSERT(!isEmpty());
+    return toRenderMathMLBlock(lastChild()->previousSibling());
 }
 
-LayoutUnit RenderMathMLRoot::paddingLeft() const
+RenderMathMLRootWrapper* RenderMathMLRoot::indexWrapper() const
 {
-    LayoutUnit result = computedCSSPaddingLeft();
-    switch (style().writingMode()) {
-    case LeftToRightWritingMode:
-        return result + m_intrinsicPaddingBefore;
-    case RightToLeftWritingMode:
-        return result + m_intrinsicPaddingAfter;
-    case TopToBottomWritingMode:
-    case BottomToTopWritingMode:
-        return result + (style().isLeftToRightDirection() ? m_intrinsicPaddingStart : m_intrinsicPaddingEnd);
-    }
-    ASSERT_NOT_REACHED();
-    return result;
+    ASSERT(!isEmpty());
+    return isRenderMathMLSquareRoot() ? nullptr : toRenderMathMLRootWrapper(firstChild());
 }
 
-LayoutUnit RenderMathMLRoot::paddingRight() const
+RenderMathMLRadicalOperator* RenderMathMLRoot::radicalOperator() const
 {
-    LayoutUnit result = computedCSSPaddingRight();
-    switch (style().writingMode()) {
-    case RightToLeftWritingMode:
-        return result + m_intrinsicPaddingBefore;
-    case LeftToRightWritingMode:
-        return result + m_intrinsicPaddingAfter;
-    case TopToBottomWritingMode:
-    case BottomToTopWritingMode:
-        return result + (style().isLeftToRightDirection() ? m_intrinsicPaddingEnd : m_intrinsicPaddingStart);
-    }
-    ASSERT_NOT_REACHED();
-    return result;
+    ASSERT(!isEmpty());
+    return toRenderMathMLRadicalOperator(radicalWrapper()->firstChild());
 }
 
-LayoutUnit RenderMathMLRoot::paddingBefore() const
+void RenderMathMLRoot::restructureWrappers()
 {
-    return computedCSSPaddingBefore() + m_intrinsicPaddingBefore;
+    ASSERT(!isEmpty());
+
+    auto base = baseWrapper();
+    auto index = indexWrapper();
+    auto radical = radicalWrapper();
+
+    // For visual consistency with the initial state, we remove the radical when the base/index wrappers become empty.
+    if (base->isEmpty() && (!index || index->isEmpty())) {
+        if (!radical->isEmpty()) {
+            auto child = radicalOperator();
+            radical->removeChild(*child);
+            child->destroy();
+        }
+        // FIXME: early return!!!
+    }
+
+    if (radical->isEmpty()) {
+        // We create the radical operator.
+        RenderPtr<RenderMathMLRadicalOperator> radicalOperator = createRenderer<RenderMathMLRadicalOperator>(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX));
+        radicalOperator->initializeStyle();
+        radical->addChild(radicalOperator.leakPtr());
+    }
+
+    if (isRenderMathMLSquareRoot())
+        return;
+
+    if (auto childToMove = base->lastChild()) {
+        // We move the last child of the base wrapper into the index wrapper if the index wrapper is empty and the base wrapper has at least two children.
+        if (childToMove->previousSibling() && index->isEmpty()) {
+            base->removeChildWithoutRestructuring(*childToMove);
+            index->addChild(childToMove);
+        }
+    }
+
+    if (auto childToMove = index->firstChild()) {
+        // We move the first child of the index wrapper into the base wrapper if:
+        // - either the index wrapper has at least two children.
+        // - or the base wrapper is empty but the index wrapper is not.
+        if (childToMove->nextSibling() || base->isEmpty()) {
+            index->removeChildWithoutRestructuring(*childToMove);
+            base->addChild(childToMove);
+        }
+    }
 }
 
-LayoutUnit RenderMathMLRoot::paddingAfter() const
+void RenderMathMLRoot::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
-    return computedCSSPaddingAfter() + m_intrinsicPaddingAfter;
+    if (isEmpty()) {
+        if (!isRenderMathMLSquareRoot()) {
+            // We add the IndexWrapper.
+            RenderMathMLBlock::addChild(RenderMathMLRootWrapper::createAnonymousWrapper(this).leakPtr());
+        }
+
+        // We create the radicalWrapper
+        RenderMathMLBlock::addChild(RenderMathMLBlock::createAnonymousMathMLBlock().leakPtr());
+
+        // We create the BaseWrapper.
+        RenderMathMLBlock::addChild(RenderMathMLRootWrapper::createAnonymousWrapper(this).leakPtr());
+
+        updateStyle();
+    }
+
+    // We insert the child.
+    auto base = baseWrapper();
+    auto index = indexWrapper();
+    RenderElement* actualParent;
+    RenderElement* actualBeforeChild;
+    if (isRenderMathMLSquareRoot()) {
+        // For square root, we always insert the child into the base wrapper.
+        actualParent = base;
+        if (beforeChild && beforeChild->parent() == base)
+            actualBeforeChild = toRenderElement(beforeChild);
+        else
+            actualBeforeChild = nullptr;
+    } else {
+        // For mroot, we insert the child into the parent of beforeChild, or at the end of the index. The wrapper structure is reorganize below.
+        actualParent = beforeChild ? beforeChild->parent() : nullptr;
+        if (actualParent == base || actualParent == index)
+            actualBeforeChild = toRenderElement(beforeChild);
+        else {
+            actualParent = index;
+            actualBeforeChild = nullptr;
+        }
+    }
+    actualParent->addChild(newChild, actualBeforeChild);
+    restructureWrappers();
 }
 
-LayoutUnit RenderMathMLRoot::paddingStart() const
+void RenderMathMLRoot::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
-    return computedCSSPaddingStart() + m_intrinsicPaddingStart;
+    RenderMathMLBlock::styleDidChange(diff, oldStyle);
+    if (!isEmpty())
+        updateStyle();
 }
 
-LayoutUnit RenderMathMLRoot::paddingEnd() const
+void RenderMathMLRoot::updateFromElement()
 {
-    return computedCSSPaddingEnd() + m_intrinsicPaddingEnd;
+    RenderMathMLBlock::updateFromElement();
+    if (!isEmpty())
+        updateStyle();
 }
 
-void RenderMathMLRoot::addChild(RenderObject* newChild, RenderObject* beforeChild)
+void RenderMathMLRoot::updateStyle()
 {
-    // Insert an implicit <mrow> for <mroot> as well as <msqrt>, to ensure firstChild() will have a box
-    // to measure and store a glyph-based height for preferredLogicalHeightAfterSizing.
-    if (!firstChild())
-        RenderMathMLBlock::addChild(RenderMathMLRow::createAnonymousWithParentRenderer(*this).leakPtr());
-    
-    // An <mroot>'s index has { position: absolute }.
-    if (newChild->style().position() == AbsolutePosition)
-        RenderMathMLBlock::addChild(newChild);
-    else
-        toRenderElement(firstChild())->addChild(newChild, beforeChild && beforeChild->parent() == firstChild() ? beforeChild : 0);
+    ASSERT(!isEmpty());
+
+    // We set some constants to draw the radical, as defined in the OpenType MATH tables.
+
+    m_ruleThickness = 0.05f * style().font().size();
+
+    // FIXME: The recommended default for m_verticalGap in displaystyle is rule thickness + 1/4 x-height (https://bugs.webkit.org/show_bug.cgi?id=118737).
+    m_verticalGap = 11 * m_ruleThickness / 4;
+    m_extraAscender = m_ruleThickness;
+    LayoutUnit kernBeforeDegree = 5 * style().font().size() / 18;
+    LayoutUnit kernAfterDegree = -10 * style().font().size() / 18;
+    m_degreeBottomRaisePercent = 0.6f;
+
+    const auto& primaryFontData = style().font().primaryFont();
+    if (primaryFontData && primaryFontData->mathData()) {
+        // FIXME: m_verticalGap should use RadicalDisplayStyleVertical in display mode (https://bugs.webkit.org/show_bug.cgi?id=118737).
+        m_verticalGap = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalVerticalGap);
+        m_ruleThickness = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalRuleThickness);
+        m_extraAscender = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalExtraAscender);
+
+        if (!isRenderMathMLSquareRoot()) {
+            kernBeforeDegree = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalKernBeforeDegree);
+            kernAfterDegree = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalKernAfterDegree);
+            m_degreeBottomRaisePercent = primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::RadicalDegreeBottomRaisePercent);
+        }
+    }
+
+    // We set the style of the anonymous wrappers.
+
+    auto radical = radicalWrapper();
+    auto radicalStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
+    radicalStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
+    radical->setStyle(std::move(radicalStyle));
+    radical->setNeedsLayoutAndPrefWidthsRecalc();
+
+    auto base = baseWrapper();
+    auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
+    baseStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
+    baseStyle.get().setAlignItems(AlignBaseline);
+    base->setStyle(std::move(baseStyle));
+    base->setNeedsLayoutAndPrefWidthsRecalc();
+
+    if (!isRenderMathMLSquareRoot()) {
+        // For mroot, we also set the style of the index wrapper.
+        auto index = indexWrapper();
+        auto indexStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
+        indexStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
+        indexStyle.get().setMarginStart(Length(kernBeforeDegree, Fixed));
+        indexStyle.get().setMarginEnd(Length(kernAfterDegree, Fixed));
+        indexStyle.get().setAlignItems(AlignBaseline);
+        index->setStyle(std::move(indexStyle));
+        index->setNeedsLayoutAndPrefWidthsRecalc();
+    }
 }
 
-RenderBox* RenderMathMLRoot::index() const
+int RenderMathMLRoot::firstLineBaseline() const
 {
-    if (!firstChild())
-        return 0;
-    RenderObject* index = firstChild()->nextSibling();
-    if (!index || !index->isBox())
-        return 0;
-    return toRenderBox(index);
+    if (!isEmpty()) {
+        auto base = baseWrapper();
+        return static_cast<int>(lroundf(base->firstLineBaseline() + base->marginTop()));
+    }
+
+    return RenderMathMLBlock::firstLineBaseline();
 }
 
 void RenderMathMLRoot::layout()
 {
-    for (auto& box : childrenOfType<RenderBox>(*this))
-        box.layoutIfNeeded();
+    if (isEmpty()) {
+        RenderMathMLBlock::layout();
+        return;
+    }
 
-    int baseHeight = firstChild() && firstChild()->isBox() ? roundToInt(toRenderBox(firstChild())->logicalHeight()) : style().fontSize();
-    int frontWidth = lroundf(gFrontWidthEms * style().fontSize());
-    
-    // Base height above which the shape of the root changes
-    float thresholdHeight = gThresholdBaseHeightEms * style().fontSize();
-    if (baseHeight > thresholdHeight && thresholdHeight) {
-        float shift = std::min<float>((baseHeight - thresholdHeight) / thresholdHeight, 1.0f);
-        m_overbarLeftPointShift = static_cast<int>(shift * gRadicalBottomPointXFront * frontWidth);
-        m_intrinsicPaddingAfter = lroundf(gBigRootBottomPaddingEms * style().fontSize());
-    } else {
-        m_overbarLeftPointShift = 0;
-        m_intrinsicPaddingAfter = 0;
+    // FIXME: It seems that changing the top margin of the base below modifies its logical height and leads to reftest failures.
+    // For now, we workaround that by avoiding to recompute the child margins if they were not reset in updateStyle().
+    auto base = baseWrapper();
+    if (base->marginTop() > 0) {
+        RenderMathMLBlock::layout();
+        return;
     }
-    
-    int rootPad = lroundf(gSpaceAboveEms * style().fontSize());
-    m_intrinsicPaddingBefore = rootPad;
-    m_indexTop = 0;
-    if (RenderBox* index = this->index()) {
-        m_intrinsicPaddingStart = roundToInt(index->maxPreferredLogicalWidth()) + m_overbarLeftPointShift;
-
-        int indexHeight = roundToInt(index->logicalHeight());
-        int partDipHeight = lroundf((1 - gRootRadicalDipLeftPointYPos) * baseHeight);
-        int rootExtraTop = partDipHeight + indexHeight - (baseHeight + rootPad);
-        if (rootExtraTop > 0)
-            m_intrinsicPaddingBefore += rootExtraTop;
-        else
-            m_indexTop = - rootExtraTop;
-    } else
-        m_intrinsicPaddingStart = frontWidth;
 
-    // FIXME: We should rewrite RenderMathMLRoot to rewrite -webkit-flex-order to get rid of the need
-    // for intrinsic padding. See https://bugs.webkit.org/show_bug.cgi?id=107151#c2.
-    // FIXME: We should make it so that the preferred width of RenderMathMLRoots doesn't change during layout.
-    // Technically, we currently only need to set the dirty bit here if one of the member variables above changes.
-    setPreferredLogicalWidthsDirty(true);
+    // We layout the children.
+    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+        if (child->needsLayout())
+            toRenderElement(child)->layout();
+    }
 
-    RenderMathMLBlock::layout();
+    auto radical = radicalOperator();
+    if (radical) {
+        // We stretch the radical sign to cover the height of the base wrapper.
+        float baseHeight = base->logicalHeight();
+        float baseHeightAboveBaseline = base->firstLineBaseline();
+        if (baseHeightAboveBaseline == -1)
+            baseHeightAboveBaseline = baseHeight;
+        float baseDepthBelowBaseline = baseHeight - baseHeightAboveBaseline;
+        baseHeightAboveBaseline += m_verticalGap;
+        radical->stretchTo(baseHeightAboveBaseline, baseDepthBelowBaseline);
+
+        // We modify the top margins to adjust the vertical positions of wrappers.
+        float radicalTopMargin = m_extraAscender;
+        float baseTopMargin = m_verticalGap + m_ruleThickness + m_extraAscender;
+        if (!isRenderMathMLSquareRoot()) {
+            // For mroot, we try to place the index so the space below its baseline is m_degreeBottomRaisePercent times the height of the radical.
+            auto index = indexWrapper();
+            float indexHeight = 0;
+            if (!index->isEmpty())
+                indexHeight = toRenderBlock(index->firstChild())->logicalHeight();
+            float indexTopMargin = (1.0 - m_degreeBottomRaisePercent) * radical->stretchSize() + radicalTopMargin - indexHeight;
+            if (indexTopMargin < 0) {
+                // If the index is too tall, we must add space at the top of renderer.
+                radicalTopMargin -= indexTopMargin;
+                baseTopMargin -= indexTopMargin;
+                indexTopMargin = 0;
+            }
+            index->style().setMarginTop(Length(indexTopMargin, Fixed));
+        }
+        radical->style().setMarginTop(Length(radicalTopMargin, Fixed));
+        base->style().setMarginTop(Length(baseTopMargin, Fixed));
+    }
 
-    if (RenderBox* index = this->index())
-        index->setLogicalTop(m_indexTop);
+    RenderMathMLBlock::layout();
 }
 
 void RenderMathMLRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
 {
     RenderMathMLBlock::paint(info, paintOffset);
     
-    if (info.context->paintingDisabled() || style().visibility() != VISIBLE)
+    if (isEmpty() || info.context->paintingDisabled() || style().visibility() != VISIBLE)
         return;
-    
-    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + contentBoxRect().location());
-    
-    int startX = adjustedPaintOffset.x();
-    int frontWidth = lroundf(gFrontWidthEms * style().fontSize());
-    int overbarWidth = roundToInt(contentLogicalWidth()) + m_overbarLeftPointShift;
-    
-    int baseHeight = roundToInt(contentLogicalHeight());
-    int rootPad = lroundf(gSpaceAboveEms * style().fontSize());
-    adjustedPaintOffset.setY(adjustedPaintOffset.y() - rootPad);
-    
-    float radicalDipLeftPointYPos = (index() ? gRootRadicalDipLeftPointYPos : gSqrtRadicalDipLeftPointYPos) * baseHeight;
-    
-    FloatPoint overbarLeftPoint(startX - m_overbarLeftPointShift, adjustedPaintOffset.y());
-    FloatPoint bottomPoint(startX - gRadicalBottomPointXFront * frontWidth, adjustedPaintOffset.y() + baseHeight + gRadicalBottomPointLower);
-    FloatPoint dipLeftPoint(startX - gRadicalDipLeftPointXFront * frontWidth, adjustedPaintOffset.y() + radicalDipLeftPointYPos);
-    FloatPoint leftEnd(startX - frontWidth, dipLeftPoint.y() + gRadicalLeftEndYShiftEms * style().fontSize());
-    
+
+    auto base = baseWrapper();
+    auto radical = radicalOperator();
+    if (!base || !radical || !m_ruleThickness)
+        return;
+
+    // We draw the radical line.
     GraphicsContextStateSaver stateSaver(*info.context);
-    
-    info.context->setStrokeThickness(gRadicalLineThicknessEms * style().fontSize());
+
+    info.context->setStrokeThickness(m_ruleThickness);
     info.context->setStrokeStyle(SolidStroke);
     info.context->setStrokeColor(style().visitedDependentColor(CSSPropertyColor), ColorSpaceDeviceRGB);
-    info.context->setLineJoin(MiterJoin);
-    info.context->setMiterLimit(style().fontSize());
-    
-    Path root;
-    
-    root.moveTo(FloatPoint(overbarLeftPoint.x() + overbarWidth, adjustedPaintOffset.y()));
-    // draw top
-    root.addLineTo(overbarLeftPoint);
-    // draw from top left corner to bottom point of radical
-    root.addLineTo(bottomPoint);
-    // draw from bottom point to top of left part of radical base "dip"
-    root.addLineTo(dipLeftPoint);
-    // draw to end
-    root.addLineTo(leftEnd);
-    
-    info.context->strokePath(root);
-    
-    GraphicsContextStateSaver maskStateSaver(*info.context);
-    
-    // Build a mask to draw the thick part of the root.
-    Path mask;
-    
-    mask.moveTo(overbarLeftPoint);
-    mask.addLineTo(bottomPoint);
-    mask.addLineTo(dipLeftPoint);
-    mask.addLineTo(FloatPoint(2 * dipLeftPoint.x() - leftEnd.x(), 2 * dipLeftPoint.y() - leftEnd.y()));
-    
-    info.context->clip(mask);
-    
-    // Draw the thick part of the root.
-    info.context->setStrokeThickness(gRadicalThickLineThicknessEms * style().fontSize());
-    info.context->setLineCap(SquareCap);
-    
-    Path line;
-    line.moveTo(bottomPoint);
-    line.addLineTo(dipLeftPoint);
-    
-    info.context->strokePath(line);
+
+    // The preferred width of the radical is sometimes incorrect, so we draw a slightly longer line to ensure it touches the radical symbol (https://bugs.webkit.org/show_bug.cgi?id=130326).
+    LayoutUnit sizeError = radical->trailingSpaceError();
+    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + base->location() + LayoutPoint(-sizeError, -(m_verticalGap + m_ruleThickness / 2)));
+    info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x() + base->pixelSnappedOffsetWidth() + sizeError, adjustedPaintOffset.y()));
+}
+
+RenderPtr<RenderMathMLRootWrapper> RenderMathMLRootWrapper::createAnonymousWrapper(RenderMathMLRoot* renderObject)
+{
+    RenderPtr<RenderMathMLRootWrapper> newBlock = createRenderer<RenderMathMLRootWrapper>(renderObject->document(), RenderStyle::createAnonymousStyleWithDisplay(&renderObject->style(), FLEX));
+    newBlock->initializeStyle();
+    return newBlock;
+}
+
+RenderObject* RenderMathMLRootWrapper::removeChildWithoutRestructuring(RenderObject& child)
+{
+    return RenderMathMLBlock::removeChild(child);
+}
+
+RenderObject* RenderMathMLRootWrapper::removeChild(RenderObject& child)
+{
+    RenderObject* next = RenderMathMLBlock::removeChild(child);
+
+    if (!(beingDestroyed() || documentBeingDestroyed()))
+        toRenderMathMLRoot(parent())->restructureWrappers();
+
+    return next;
 }
 
 }
index 4d5d731..c849200 100644 (file)
 #if ENABLE(MATHML)
 
 #include "RenderMathMLBlock.h"
+#include "RenderMathMLRow.h"
 
 namespace WebCore {
+
+class RenderMathMLRadicalOperator;
+class RenderMathMLRootWrapper;
     
 // Render base^(1/index), or sqrt(base) via the derived class RenderMathMLSquareRoot, using radical notation.
 class RenderMathMLRoot : public RenderMathMLBlock {
+
+friend class RenderMathMLRootWrapper;
+
 public:
     RenderMathMLRoot(Element&, PassRef<RenderStyle>);
     RenderMathMLRoot(Document&, PassRef<RenderStyle>);
 
-    virtual LayoutUnit paddingTop() const override;
-    virtual LayoutUnit paddingBottom() const override;
-    virtual LayoutUnit paddingLeft() const override;
-    virtual LayoutUnit paddingRight() const override;
-    virtual LayoutUnit paddingBefore() const override;
-    virtual LayoutUnit paddingAfter() const override;
-    virtual LayoutUnit paddingStart() const override;
-    virtual LayoutUnit paddingEnd() const override;
-
     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;
+    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
+    virtual void updateFromElement() override;
     
 protected:
     virtual void layout() override;
@@ -57,18 +57,42 @@ protected:
 private:
     virtual bool isRenderMathMLRoot() const override final { return true; }
     virtual const char* renderName() const override { return "RenderMathMLRoot"; }
-    
-    // This may return 0 for a non-MathML index (which won't occur in valid MathML).
-    RenderBox* index() const;
-
-    int m_intrinsicPaddingBefore;
-    int m_intrinsicPaddingAfter;
-    int m_intrinsicPaddingStart;
-    int m_intrinsicPaddingEnd;
-    int m_overbarLeftPointShift;
-    int m_indexTop;
+    virtual int firstLineBaseline() const override;
+    void updateStyle();
+    void restructureWrappers();
+
+    RenderMathMLRootWrapper* baseWrapper() const;
+    RenderMathMLBlock* radicalWrapper() const;
+    RenderMathMLRootWrapper* indexWrapper() const;
+    RenderMathMLRadicalOperator* radicalOperator() const;
+
+    LayoutUnit m_verticalGap;
+    LayoutUnit m_ruleThickness;
+    LayoutUnit m_extraAscender;
+    float m_degreeBottomRaisePercent;
 };
     
+RENDER_OBJECT_TYPE_CASTS(RenderMathMLRoot, isRenderMathMLRoot())
+
+// These are specific wrappers for the index and base, that ask the parent to restructure the renderers after child removal.
+class RenderMathMLRootWrapper : public RenderMathMLRow {
+
+friend class RenderMathMLRoot;
+
+public:
+    RenderMathMLRootWrapper(Document& document, PassRef<RenderStyle> style)
+        : RenderMathMLRow(document, std::move(style)) { }
+
+private:
+    RenderObject* removeChildWithoutRestructuring(RenderObject&);
+    RenderObject* removeChild(RenderObject&) override;
+    static RenderPtr<RenderMathMLRootWrapper> createAnonymousWrapper(RenderMathMLRoot* renderObject);
+    virtual bool isRenderMathMLRoot() const override final { return true; }
+    virtual const char* renderName() const override { return "RenderMathMLRootWrapper"; }
+};
+
+RENDER_OBJECT_TYPE_CASTS(RenderMathMLRootWrapper, isRenderMathMLRootWrapper())
+
 }
 
 #endif // ENABLE(MATHML)