Bug 119043 - Large stretch size error for MathML operators.
authorfred.wang@free.fr <fred.wang@free.fr@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 22 Feb 2014 09:50:47 +0000 (09:50 +0000)
committerfred.wang@free.fr <fred.wang@free.fr@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 22 Feb 2014 09:50:47 +0000 (09:50 +0000)
https://bugs.webkit.org/show_bug.cgi?id=119043

Reviewed by Chris Fleizach.

Source/WebCore:

The MathML code used some arbitrary gOperatorExpansion factor for the
stretch size and 2/3 1/2 constants for the baseline. This change tries
to consider height/depth of siblings of the stretchy operator so that
the stretchy operator now matches its target.

Test: mathml/presentation/stretchy-depth-height.html

* rendering/RenderObject.h:
(WebCore::RenderObject::isRenderMathMLTable):
* rendering/mathml/RenderMathMLBlock.h:
* rendering/mathml/RenderMathMLOperator.cpp:
(WebCore::RenderMathMLOperator::RenderMathMLOperator):
(WebCore::RenderMathMLOperator::stretchTo):
(WebCore::RenderMathMLOperator::findAcceptableStretchyCharacter):
(WebCore::RenderMathMLOperator::updateStyle):
(WebCore::RenderMathMLOperator::firstLineBaseline):
(WebCore::RenderMathMLOperator::computeLogicalHeight):
* rendering/mathml/RenderMathMLOperator.h:
* rendering/mathml/RenderMathMLRow.cpp:
(WebCore::RenderMathMLRow::layout):

LayoutTests:

This adds a test to check that the depth/height of stretchy operators match the maximum of their siblings. This also fixes the reference of mo-stretch.html to ignore the stretch error.

* mathml/presentation/stretchy-depth-height-expected.txt: Added.
* mathml/presentation/stretchy-depth-height.html: Added.
* platform/mac/mathml/presentation/mo-stretch-expected.txt:

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

LayoutTests/ChangeLog
LayoutTests/mathml/presentation/stretchy-depth-height-expected.txt [new file with mode: 0644]
LayoutTests/mathml/presentation/stretchy-depth-height.html [new file with mode: 0644]
LayoutTests/platform/mac/mathml/presentation/mo-stretch-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/rendering/RenderObject.h
Source/WebCore/rendering/mathml/RenderMathMLBlock.h
Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp
Source/WebCore/rendering/mathml/RenderMathMLOperator.h
Source/WebCore/rendering/mathml/RenderMathMLRow.cpp

index d096231..2890e89 100644 (file)
@@ -1,3 +1,16 @@
+2014-02-22  Frédéric Wang  <fred.wang@free.fr>
+
+        Bug 119043 - Large stretch size error for MathML operators.
+        https://bugs.webkit.org/show_bug.cgi?id=119043
+
+        Reviewed by Chris Fleizach.
+
+        This adds a test to check that the depth/height of stretchy operators match the maximum of their siblings. This also fixes the reference of mo-stretch.html to ignore the stretch error.
+
+        * mathml/presentation/stretchy-depth-height-expected.txt: Added.
+        * mathml/presentation/stretchy-depth-height.html: Added.
+        * platform/mac/mathml/presentation/mo-stretch-expected.txt:
+
 2014-02-22  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
 
         Unreviewed, EFL WK2 gardening. Skip a webgl test because of crashing.
diff --git a/LayoutTests/mathml/presentation/stretchy-depth-height-expected.txt b/LayoutTests/mathml/presentation/stretchy-depth-height-expected.txt
new file mode 100644 (file)
index 0000000..5a03dda
--- /dev/null
@@ -0,0 +1,52 @@
+This test passes if the depth and height of braces match the maximum depth and height of its siblings.
+
+x      y       z
+x      y       z
+x      y       z
+x      y       z
+x      y       z
+1
+2
+3
+4
+5
+6
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+7
+8
+9
+10
+1
+2
+1
+2
+3
+4
+5
+5
+6
+
+symmetric stretching: PASS
+large depth: PASS
+large height: PASS
+mtable: PASS
+several siblings with different heights/depths: PASS
+testing several operators in one mrow (operator 1): PASS
+testing several operators in one mrow (operator 2): PASS
+testing several operators in one mrow (operator 3): PASS
+
diff --git a/LayoutTests/mathml/presentation/stretchy-depth-height.html b/LayoutTests/mathml/presentation/stretchy-depth-height.html
new file mode 100644 (file)
index 0000000..db257fb
--- /dev/null
@@ -0,0 +1,207 @@
+<html>
+  <head>
+    <title>stretch depth/height</title>
+    <meta charset="utf-8">
+    <script type="text/javascript">
+      var result;
+      var epsilon = 1;
+
+      function almostEqual(x, y) {
+          return Math.abs(x - y) < epsilon;
+      }
+
+      function assert(text, condition) {
+          result += text + ": " + (condition ? "PASS" : "FAIL") + "\n";
+      }
+
+      function test() {
+          result = "";
+
+          var s1 = document.getElementById("s1").getBoundingClientRect();
+          var c1 = document.getElementById("c1").getBoundingClientRect();
+          assert("symmetric stretching", almostEqual(s1.top, c1.top) && almostEqual(s1.bottom, c1.bottom));
+
+          var s2 = document.getElementById("s2").getBoundingClientRect();
+          var c2 = document.getElementById("c2").getBoundingClientRect();
+          assert("large depth", almostEqual(s2.top, c2.top) && almostEqual(s2.bottom, c2.bottom));
+
+          var s3 = document.getElementById("s3").getBoundingClientRect();
+          var c3 = document.getElementById("c3").getBoundingClientRect();
+          assert("large height", almostEqual(s3.top, c3.top) && almostEqual(s3.bottom, c3.bottom));
+
+          var s4 = document.getElementById("s4").getBoundingClientRect();
+          var c4 = document.getElementById("c4").getBoundingClientRect();
+          assert("mtable", almostEqual(s4.top, c4.top) && almostEqual(s4.bottom, c4.bottom));
+
+          var s5 = document.getElementById("s5").getBoundingClientRect();
+          var c5maxheight = document.getElementById("c5maxheight").getBoundingClientRect();
+          var c5maxdepth = document.getElementById("c5maxdepth").getBoundingClientRect();
+          assert("several siblings with different heights/depths", almostEqual(s5.top, c5maxheight.top) && almostEqual(s5.bottom, c5maxdepth.bottom));
+
+
+          var c6maxheight = document.getElementById("c6maxheight").getBoundingClientRect();
+          var c6maxdepth = document.getElementById("c6maxdepth").getBoundingClientRect();
+          for (var i = 1; i <= 3; i++) {
+              var s6 = document.getElementById("s6_" + i).getBoundingClientRect();
+              assert("testing several operators in one mrow (operator " + i + ")", almostEqual(s6.top, c6maxheight.top) && almostEqual(s6.bottom, c6maxdepth.bottom));
+          }
+
+          document.getElementById("result").innerText = result;
+  
+          if (window.testRunner)
+              testRunner.dumpAsText();
+      }
+    </script>
+  </head>
+  <body onload="test()">
+
+    <p>This test passes if the depth and height of braces match the maximum depth and height of its siblings.</p>
+
+    <p>
+      <!-- This tests symmetric stretching. -->
+      <math>
+        <mrow>
+          <mo id="s1" symmetric="false">{</mo>
+          <mspace id="c1" width="10px" height="150px" depth="150px" mathbackground="blue"/>
+        </mrow>
+      </math>
+      <!-- This tests a large depth. -->
+      <math>
+        <mrow>
+          <mo id="s2" symmetric="false">{</mo>
+          <mspace id="c2" width="10px" height="50px" depth="250px" mathbackground="blue"/>
+        </mrow>
+      </math>
+      <!-- This tests a large height. -->
+      <math>
+        <mrow>
+          <mo id="s3" symmetric="false">{</mo>
+          <mspace id="c3" width="10px" height="250px" depth="50px" mathbackground="blue"/>
+        </mrow>
+      </math>
+      <!-- This tests an mtable sibling. -->
+      <math>
+        <mrow>
+          <mo id="s4" symmetric="false">{</mo>
+          <mtable id="c4">
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd><mtd><mi>z</mi></mtd></mtr>
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd><mtd><mi>z</mi></mtd></mtr>
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd><mtd><mi>z</mi></mtd></mtr>
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd><mtd><mi>z</mi></mtd></mtr>
+            <mtr><mtd><mi>x</mi></mtd><mtd><mi>y</mi></mtd><mtd><mi>z</mi></mtd></mtr>
+          </mtable>
+        </mrow>
+      </math>
+      <!-- This tests several siblings with different heights/depths. -->
+      <math>
+        <mrow>
+          <mo id="s5" symmetric="false">{</mo>
+          <mfrac>
+            <mfrac>
+              <mn>1</mn>
+              <mn>2</mn>
+            </mfrac>
+            <msup>
+              <mn>3</mn>
+              <mn>4</mn>
+            </msup>
+          </mfrac>
+          <mo>-</mo>
+          <msqrt>
+            <mfrac>
+              <mn>5</mn>
+              <mn>6</mn>
+            </mfrac>
+          </msqrt>
+          <mo>*</mo>
+          <mfrac id="c5maxheight">
+            <mfrac>
+              <mfrac>
+                <mfrac>
+                  <mn>1</mn>
+                  <mn>2</mn>
+                </mfrac>
+                <msup>
+                  <mn>3</mn>
+                  <mn>4</mn>
+                </msup>
+              </mfrac>
+              <msqrt>
+                <mfrac>
+                  <mn>5</mn>
+                  <mn>6</mn>
+                </mfrac>
+              </msqrt>
+            </mfrac>
+            <mfrac>
+              <mfrac>
+                <msub>
+                  <mn>7</mn>
+                  <mn>8</mn>
+                </msub>
+                <munder>
+                  <mn>9</mn>
+                  <mn>10</mn>
+                </munder>
+              </mfrac>
+              <mn>11</mn>
+            </mfrac>
+          </mfrac>
+          <mo>+</mo>
+          <mfrac>
+            <msub>
+              <mn>7</mn>
+              <mn>8</mn>
+            </msub>
+            <munder>
+              <mn>9</mn>
+              <mn>10</mn>
+            </munder>
+          </mfrac>
+          <mo>/</mo>
+          <mfrac id="c5maxdepth">
+            <mfrac>
+              <mn>1</mn>
+              <mn>2</mn>
+            </mfrac>
+            <mfrac>
+              <mfrac>
+                <mfrac>
+                  <mn>1</mn>
+                  <mn>2</mn>
+                </mfrac>
+                <msup>
+                  <mn>3</mn>
+                  <mn>4</mn>
+                </msup>
+              </mfrac>
+              <msqrt>
+                <mfrac>
+                  <mn>5</mn>
+                  <mfrac>
+                    <mn>5</mn>
+                    <mn>6</mn>
+                  </mfrac>
+                </mfrac>
+              </msqrt>
+            </mfrac>
+          </mfrac>
+        </mrow>
+      </math>
+      <!-- This tests several operators in the same mrow. -->
+      <math>
+        <mrow>
+          <mo id="s6_1" symmetric="false">{</mo>
+          <mspace id="c6maxdepth" width="10px" height="50px" depth="150px" mathbackground="red"/>
+          <mo id="s6_2" symmetric="false">|</mo>
+          <mspace id="c6maxheight" width="10px" height="150px" depth="50px" mathbackground="red"/>
+          <mo id="s6_3" symmetric="false">}</mo>
+        </mrow>
+      </math>
+
+    </p>
+
+    <div id="result"></div>
+
+  </body>
+</html>
index 1401da7..ed4b5b1 100644 (file)
@@ -1,8 +1,8 @@
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
-layer at (0,0) size 800x216
-  RenderBlock {HTML} at (0,0) size 800x216
-    RenderBody {BODY} at (8,8) size 784x200
+layer at (0,0) size 800x166
+  RenderBlock {HTML} at (0,0) size 800x166
+    RenderBody {BODY} at (8,8) size 784x150
       RenderMathMLMath {math} at (0,0) size 195x20 [padding: 0 1 0 1]
         RenderMathMLRow {mrow} at (1,0) size 193x20
           RenderMathMLOperator {mo} at (1,3) size 8x14
@@ -78,74 +78,74 @@ layer at (0,0) size 800x216
       RenderText {#text} at (194,0) size 5x18
         text run at (194,0) width 5: " "
       RenderBR {BR} at (0,0) size 0x0
-      RenderMathMLMath {math} at (0,20) size 199x114 [padding: 0 1 0 1]
-        RenderMathMLRow {mrow} at (1,0) size 197x114
-          RenderMathMLOperator {mo} at (1,22) size 8x92
+      RenderMathMLMath {math} at (0,20) size 199x76 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (1,0) size 197x76
+          RenderMathMLOperator {mo} at (1,0) size 8x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "("
-          RenderMathMLOperator {mo} at (13,22) size 8x92
+          RenderMathMLOperator {mo} at (13,0) size 8x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: ")"
-          RenderMathMLOperator {mo} at (26,22) size 11x92
+          RenderMathMLOperator {mo} at (26,0) size 11x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
               RenderBlock (anonymous) at (0,0) size 8x14
                 RenderText at (0,-6) size 8x24
                   text run at (0,-6) width 8: "{"
-          RenderMathMLOperator {mo} at (43,22) size 11x92
+          RenderMathMLOperator {mo} at (43,0) size 11x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
               RenderBlock (anonymous) at (0,0) size 8x14
                 RenderText at (0,-6) size 8x24
                   text run at (0,-6) width 8: "}"
-          RenderMathMLOperator {mo} at (59,22) size 8x92
+          RenderMathMLOperator {mo} at (59,0) size 8x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "["
-          RenderMathMLOperator {mo} at (72,22) size 8x92
+          RenderMathMLOperator {mo} at (72,0) size 8x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "]"
-          RenderMathMLOperator {mo} at (86,22) size 9x92
+          RenderMathMLOperator {mo} at (86,0) size 9x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2308}"
-          RenderMathMLOperator {mo} at (100,22) size 9x92
+          RenderMathMLOperator {mo} at (100,0) size 9x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2309}"
-          RenderMathMLOperator {mo} at (115,22) size 8x92
+          RenderMathMLOperator {mo} at (115,0) size 8x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{230A}"
-          RenderMathMLOperator {mo} at (129,22) size 9x92
+          RenderMathMLOperator {mo} at (129,0) size 9x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{230B}"
-          RenderMathMLOperator {mo} at (143,22) size 12x92
+          RenderMathMLOperator {mo} at (143,0) size 12x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 11x20
               RenderBlock (anonymous) at (0,0) size 7x20
                 RenderText at (0,-3) size 7x24
                   text run at (0,-3) width 7: "\x{222B}"
-          RenderMathMLOperator {mo} at (161,22) size 4x92
+          RenderMathMLOperator {mo} at (161,0) size 4x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 3x12
               RenderBlock (anonymous) at (0,0) size 3x12
                 RenderText at (0,-6) size 3x24
                   text run at (0,-6) width 3: "|"
-          RenderMathMLOperator {mo} at (170,22) size 9x92
+          RenderMathMLOperator {mo} at (170,0) size 9x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2016}"
-          RenderMathMLOperator {mo} at (184,22) size 9x92
+          RenderMathMLOperator {mo} at (184,0) size 9x76
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
@@ -153,74 +153,74 @@ layer at (0,0) size 800x216
           RenderMathMLSpace {mspace} at (196,0) size 1x76
       RenderText {#text} at (198,81) size 5x18
         text run at (198,81) width 5: " "
-      RenderMathMLMath {math} at (202,45) size 199x77 [padding: 0 1 0 1]
-        RenderMathMLRow {mrow} at (1,0) size 197x77
-          RenderMathMLOperator {mo} at (1,15) size 8x62
+      RenderMathMLMath {math} at (202,45) size 199x51 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (1,0) size 197x51
+          RenderMathMLOperator {mo} at (1,0) size 8x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "("
-          RenderMathMLOperator {mo} at (13,15) size 8x62
+          RenderMathMLOperator {mo} at (13,0) size 8x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: ")"
-          RenderMathMLOperator {mo} at (26,15) size 11x62
+          RenderMathMLOperator {mo} at (26,0) size 11x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
               RenderBlock (anonymous) at (0,0) size 8x14
                 RenderText at (0,-6) size 8x24
                   text run at (0,-6) width 8: "{"
-          RenderMathMLOperator {mo} at (43,15) size 11x62
+          RenderMathMLOperator {mo} at (43,0) size 11x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
               RenderBlock (anonymous) at (0,0) size 8x14
                 RenderText at (0,-6) size 8x24
                   text run at (0,-6) width 8: "}"
-          RenderMathMLOperator {mo} at (59,15) size 8x62
+          RenderMathMLOperator {mo} at (59,0) size 8x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "["
-          RenderMathMLOperator {mo} at (72,15) size 8x62
+          RenderMathMLOperator {mo} at (72,0) size 8x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
                 RenderText at (0,-6) size 5x24
                   text run at (0,-6) width 5: "]"
-          RenderMathMLOperator {mo} at (86,15) size 9x62
+          RenderMathMLOperator {mo} at (86,0) size 9x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2308}"
-          RenderMathMLOperator {mo} at (100,15) size 9x62
+          RenderMathMLOperator {mo} at (100,0) size 9x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2309}"
-          RenderMathMLOperator {mo} at (115,15) size 8x62
+          RenderMathMLOperator {mo} at (115,0) size 8x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{230A}"
-          RenderMathMLOperator {mo} at (129,15) size 9x62
+          RenderMathMLOperator {mo} at (129,0) size 9x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{230B}"
-          RenderMathMLOperator {mo} at (143,15) size 12x62
+          RenderMathMLOperator {mo} at (143,0) size 12x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 11x20
               RenderBlock (anonymous) at (0,0) size 7x20
                 RenderText at (0,-3) size 7x24
                   text run at (0,-3) width 7: "\x{222B}"
-          RenderMathMLOperator {mo} at (161,15) size 4x62
+          RenderMathMLOperator {mo} at (161,0) size 4x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 3x12
               RenderBlock (anonymous) at (0,0) size 3x12
                 RenderText at (0,-6) size 3x24
                   text run at (0,-6) width 3: "|"
-          RenderMathMLOperator {mo} at (170,15) size 9x62
+          RenderMathMLOperator {mo} at (170,0) size 9x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
                   text run at (0,-5) width 8: "\x{2016}"
-          RenderMathMLOperator {mo} at (184,15) size 9x62
+          RenderMathMLOperator {mo} at (184,0) size 9x51
             RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
               RenderBlock (anonymous) at (0,0) size 8x16
                 RenderText at (0,-5) size 8x24
@@ -228,8 +228,8 @@ layer at (0,0) size 800x216
           RenderMathMLSpace {mspace} at (196,0) size 1x51
       RenderText {#text} at (400,81) size 5x18
         text run at (400,81) width 5: " "
-      RenderMathMLMath {math} at (404,75) size 199x32 [padding: 0 1 0 1]
-        RenderMathMLRow {mrow} at (1,0) size 197x32
+      RenderMathMLMath {math} at (404,75) size 199x26 [padding: 0 1 0 1]
+        RenderMathMLRow {mrow} at (1,0) size 197x26
           RenderMathMLOperator {mo} at (1,9) size 8x14
             RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
               RenderBlock (anonymous) at (0,0) size 5x14
@@ -285,7 +285,7 @@ layer at (0,0) size 800x216
               RenderBlock (anonymous) at (0,0) size 7x20
                 RenderText at (0,-3) size 7x24
                   text run at (0,-3) width 7: "\x{222B}"
-          RenderMathMLOperator {mo} at (161,6) size 4x26
+          RenderMathMLOperator {mo} at (161,9) size 4x12
             RenderMathMLBlock (flex) {mo} at (0,0) size 3x12
               RenderBlock (anonymous) at (0,0) size 3x12
                 RenderText at (0,-6) size 3x24
@@ -304,75 +304,75 @@ layer at (0,0) size 800x216
       RenderText {#text} at (602,81) size 5x18
         text run at (602,81) width 5: " "
       RenderBR {BR} at (0,0) size 0x0
-      RenderMathMLMath {math} at (0,133) size 211x68 [padding: 0 1 0 1]
-        RenderMathMLSquareRoot {msqrt} at (1,0) size 209x68 [intrinsic padding: 3 0 3 12]
-          RenderMathMLRow (anonymous) at (12,3) size 197x62
-            RenderMathMLOperator {mo} at (1,12) size 8x50
+      RenderMathMLMath {math} at (0,101) size 211x49 [padding: 0 1 0 1]
+        RenderMathMLSquareRoot {msqrt} at (1,0) size 209x49 [intrinsic padding: 3 0 3 12]
+          RenderMathMLRow (anonymous) at (12,3) size 197x43
+            RenderMathMLOperator {mo} at (1,0) size 8x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
                 RenderBlock (anonymous) at (0,0) size 5x14
                   RenderText at (0,-6) size 5x24
                     text run at (0,-6) width 5: "("
-            RenderMathMLOperator {mo} at (13,12) size 8x50
+            RenderMathMLOperator {mo} at (13,0) size 8x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
                 RenderBlock (anonymous) at (0,0) size 5x14
                   RenderText at (0,-6) size 5x24
                     text run at (0,-6) width 5: ")"
-            RenderMathMLOperator {mo} at (26,12) size 11x50
+            RenderMathMLOperator {mo} at (26,29) size 11x14
               RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
                 RenderBlock (anonymous) at (0,0) size 8x14
                   RenderText at (0,-6) size 8x24
                     text run at (0,-6) width 8: "{"
-            RenderMathMLOperator {mo} at (43,12) size 11x50
+            RenderMathMLOperator {mo} at (43,29) size 11x14
               RenderMathMLBlock (flex) {mo} at (0,0) size 10x14
                 RenderBlock (anonymous) at (0,0) size 8x14
                   RenderText at (0,-6) size 8x24
                     text run at (0,-6) width 8: "}"
-            RenderMathMLOperator {mo} at (59,12) size 8x50
+            RenderMathMLOperator {mo} at (59,0) size 8x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
                 RenderBlock (anonymous) at (0,0) size 5x14
                   RenderText at (0,-6) size 5x24
                     text run at (0,-6) width 5: "["
-            RenderMathMLOperator {mo} at (72,12) size 8x50
+            RenderMathMLOperator {mo} at (72,0) size 8x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 7x14
                 RenderBlock (anonymous) at (0,0) size 5x14
                   RenderText at (0,-6) size 5x24
                     text run at (0,-6) width 5: "]"
-            RenderMathMLOperator {mo} at (86,12) size 9x50
+            RenderMathMLOperator {mo} at (86,0) size 9x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
                     text run at (0,-5) width 8: "\x{2308}"
-            RenderMathMLOperator {mo} at (100,12) size 9x50
+            RenderMathMLOperator {mo} at (100,0) size 9x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
                     text run at (0,-5) width 8: "\x{2309}"
-            RenderMathMLOperator {mo} at (115,12) size 8x50
+            RenderMathMLOperator {mo} at (115,0) size 8x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
                     text run at (0,-5) width 8: "\x{230A}"
-            RenderMathMLOperator {mo} at (129,12) size 9x50
+            RenderMathMLOperator {mo} at (129,0) size 9x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
                     text run at (0,-5) width 8: "\x{230B}"
-            RenderMathMLOperator {mo} at (143,12) size 12x50
+            RenderMathMLOperator {mo} at (143,0) size 12x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 11x20
                 RenderBlock (anonymous) at (0,0) size 7x20
                   RenderText at (0,-3) size 7x24
                     text run at (0,-3) width 7: "\x{222B}"
-            RenderMathMLOperator {mo} at (161,12) size 4x50
+            RenderMathMLOperator {mo} at (161,0) size 4x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 3x12
                 RenderBlock (anonymous) at (0,0) size 3x12
                   RenderText at (0,-6) size 3x24
                     text run at (0,-6) width 3: "|"
-            RenderMathMLOperator {mo} at (170,12) size 9x50
+            RenderMathMLOperator {mo} at (170,0) size 9x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
                     text run at (0,-5) width 8: "\x{2016}"
-            RenderMathMLOperator {mo} at (184,12) size 9x50
+            RenderMathMLOperator {mo} at (184,0) size 9x41
               RenderMathMLBlock (flex) {mo} at (0,0) size 8x16
                 RenderBlock (anonymous) at (0,0) size 8x16
                   RenderText at (0,-5) size 8x24
index ed74002..f9c1c7b 100644 (file)
@@ -1,3 +1,31 @@
+2014-02-22  Frédéric Wang  <fred.wang@free.fr>
+
+        Bug 119043 - Large stretch size error for MathML operators.
+        https://bugs.webkit.org/show_bug.cgi?id=119043
+
+        Reviewed by Chris Fleizach.
+
+        The MathML code used some arbitrary gOperatorExpansion factor for the
+        stretch size and 2/3 1/2 constants for the baseline. This change tries
+        to consider height/depth of siblings of the stretchy operator so that
+        the stretchy operator now matches its target.
+
+        Test: mathml/presentation/stretchy-depth-height.html
+
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::isRenderMathMLTable):
+        * rendering/mathml/RenderMathMLBlock.h:
+        * rendering/mathml/RenderMathMLOperator.cpp:
+        (WebCore::RenderMathMLOperator::RenderMathMLOperator):
+        (WebCore::RenderMathMLOperator::stretchTo):
+        (WebCore::RenderMathMLOperator::findAcceptableStretchyCharacter):
+        (WebCore::RenderMathMLOperator::updateStyle):
+        (WebCore::RenderMathMLOperator::firstLineBaseline):
+        (WebCore::RenderMathMLOperator::computeLogicalHeight):
+        * rendering/mathml/RenderMathMLOperator.h:
+        * rendering/mathml/RenderMathMLRow.cpp:
+        (WebCore::RenderMathMLRow::layout):
+
 2014-02-21  Zalan Bujtas  <zalan@apple.com>
 
         REGRESSION(r164412): Pixel cracks when zooming in to any web content.
index 0df1051..7708a4c 100644 (file)
@@ -403,6 +403,7 @@ public:
 
 #if ENABLE(MATHML)
     virtual bool isRenderMathMLBlock() const { return false; }
+    virtual bool isRenderMathMLTable() const { return false; }
     virtual bool isRenderMathMLOperator() const { return false; }
     virtual bool isRenderMathMLRow() const { return false; }
     virtual bool isRenderMathMLMath() const { return false; }
index 0115b0e..c1de4ad 100644 (file)
@@ -86,9 +86,12 @@ public:
     virtual int firstLineBaseline() const override;
     
 private:
+    virtual bool isRenderMathMLTable() const override final { return true; }
     virtual const char* renderName() const override { return "RenderMathMLTable"; }
 };
 
+RENDER_OBJECT_TYPE_CASTS(RenderMathMLTable, isRenderMathMLTable())
+
 // Parsing functions for MathML Length values
 bool parseMathMLLength(const String&, LayoutUnit&, const RenderStyle*, bool allowNegative = true);
 bool parseMathMLNamedSpace(const String&, LayoutUnit&, const RenderStyle*, bool allowNegative = true);
index a4008b8..d0097f0 100644 (file)
@@ -1120,7 +1120,8 @@ static const Entry dictionary[MATHML_OPDICT_SIZE] = {
 
 RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, PassRef<RenderStyle> style)
     : RenderMathMLBlock(element, std::move(style))
-    , m_stretchHeight(0)
+    , m_stretchHeightAboveBaseline(0)
+    , m_stretchDepthBelowBaseline(0)
     , m_operator(0)
     , m_stretchyCharacter(nullptr)
     , m_isFencedOperator(false)
@@ -1130,7 +1131,8 @@ RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, PassRef<Rende
 
 RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, PassRef<RenderStyle> style, UChar operatorChar, MathMLOperatorDictionary::Form form, MathMLOperatorDictionary::Flag flag)
     : RenderMathMLBlock(element, std::move(style))
-    , m_stretchHeight(0)
+    , m_stretchHeightAboveBaseline(0)
+    , m_stretchDepthBelowBaseline(0)
     , m_operator(operatorChar == hyphenMinus ? minusSign : operatorChar)
     , m_stretchyCharacter(nullptr)
     , m_isFencedOperator(true)
@@ -1250,19 +1252,13 @@ bool RenderMathMLOperator::isChildAllowed(const RenderObject&, const RenderStyle
     return false;
 }
 
-static const float gOperatorExpansion = 1.2f;
-
-float RenderMathMLOperator::expandedStretchHeight() const
-{
-    return m_stretchHeight * gOperatorExpansion;
-}
-
-void RenderMathMLOperator::stretchToHeight(int height)
+void RenderMathMLOperator::stretchTo(int heightAboveBaseline, int depthBelowBaseline)
 {
-    if (m_stretchHeight == height)
+    if (heightAboveBaseline <= m_stretchHeightAboveBaseline && depthBelowBaseline <= m_stretchDepthBelowBaseline)
         return;
 
-    m_stretchHeight = height;
+    m_stretchHeightAboveBaseline = heightAboveBaseline;
+    m_stretchDepthBelowBaseline = depthBelowBaseline;
     updateStyle();
 }
 
@@ -1384,7 +1380,7 @@ RenderMathMLOperator::StretchyCharacter* RenderMathMLOperator::findAcceptableStr
     if (stretchyCharacter->middleGlyph)
         height += glyphHeightForCharacter(stretchyCharacter->middleGlyph);
 
-    if (height > expandedStretchHeight())
+    if (height > stretchSize())
         return 0;
 
     return stretchyCharacter;
@@ -1401,7 +1397,7 @@ void RenderMathMLOperator::updateStyle()
     bool allowStretching = shouldAllowStretching(stretchedCharacter);
 
     float stretchedCharacterHeight = style().fontMetrics().floatHeight();
-    m_isStretched = allowStretching && expandedStretchHeight() > stretchedCharacterHeight;
+    m_isStretched = allowStretching && stretchSize() > stretchedCharacterHeight;
 
     // Sometimes we cannot stretch an operator properly, so in that case, we should just use the original size.
     m_stretchyCharacter = m_isStretched ? findAcceptableStretchyCharacter(stretchedCharacter) : 0;
@@ -1412,14 +1408,14 @@ void RenderMathMLOperator::updateStyle()
 int RenderMathMLOperator::firstLineBaseline() const
 {
     if (m_isStretched)
-        return expandedStretchHeight() * 2 / 3 - (expandedStretchHeight() - m_stretchHeight) / 2;
+        return m_stretchHeightAboveBaseline;
     return RenderMathMLBlock::firstLineBaseline();
 }
 
 void RenderMathMLOperator::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     if (m_isStretched)
-        logicalHeight = expandedStretchHeight();
+        logicalHeight = stretchSize();
     RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
 }
 
index 9f764c1..12335a3 100644 (file)
@@ -64,9 +64,8 @@ public:
 
     MathMLElement& element() { return toMathMLElement(nodeForNonAnonymous()); }
 
-    void stretchToHeight(int pixelHeight);
-    int stretchHeight() { return m_stretchHeight; }
-    float expandedStretchHeight() const;
+    void stretchTo(int heightAboveBaseline, int depthBelowBaseline);
+    int stretchSize() const { return m_stretchHeightAboveBaseline + m_stretchDepthBelowBaseline; }
     
     bool hasOperatorFlag(MathMLOperatorDictionary::Flag flag) const { return m_operatorFlags & flag; }
 
@@ -111,7 +110,8 @@ private:
     LayoutRect paintCharacter(PaintInfo&, UChar, const LayoutPoint& origin, CharacterPaintTrimming);
     void fillWithExtensionGlyph(PaintInfo&, const LayoutPoint& from, const LayoutPoint& to);
 
-    int m_stretchHeight;
+    int m_stretchHeightAboveBaseline;
+    int m_stretchDepthBelowBaseline;
     bool m_isStretched;
 
     UChar m_operator;
index 02ef296..3e0eecf 100644 (file)
@@ -57,25 +57,38 @@ RenderPtr<RenderMathMLRow> RenderMathMLRow::createAnonymousWithParentRenderer(Re
 
 void RenderMathMLRow::layout()
 {
-    int stretchLogicalHeight = 0;
+    int stretchHeightAboveBaseline = 0, stretchDepthBelowBaseline = 0;
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->needsLayout())
             toRenderElement(child)->layout();
         // FIXME: Only skip renderMo if it is stretchy.
         if (child->isRenderMathMLBlock() && toRenderMathMLBlock(child)->unembellishedOperator())
             continue;
-        if (child->isBox())
-            stretchLogicalHeight = std::max<int>(stretchLogicalHeight, roundToInt(toRenderBox(child)->logicalHeight()));
+        int childHeightAboveBaseline = 0, childDepthBelowBaseline = 0;
+        if (child->isRenderMathMLBlock()) {
+            RenderMathMLBlock* mathmlChild = toRenderMathMLBlock(child);
+            childHeightAboveBaseline = mathmlChild->firstLineBaseline();
+            if (childHeightAboveBaseline == -1)
+                childHeightAboveBaseline = mathmlChild->logicalHeight();
+            childDepthBelowBaseline = mathmlChild->logicalHeight() - childHeightAboveBaseline;
+        } else if (child->isRenderMathMLTable()) {
+            RenderMathMLTable* tableChild = toRenderMathMLTable(child);
+            childHeightAboveBaseline = tableChild->firstLineBaseline();
+            childDepthBelowBaseline = tableChild->logicalHeight() - childHeightAboveBaseline;
+        } else if (child->isBox()) {
+            childHeightAboveBaseline = toRenderBox(child)->logicalHeight();
+            childDepthBelowBaseline = 0;
+        }
+        stretchHeightAboveBaseline = std::max<int>(stretchHeightAboveBaseline, roundToInt(childHeightAboveBaseline));
+        stretchDepthBelowBaseline = std::max<int>(stretchDepthBelowBaseline, roundToInt(childDepthBelowBaseline));
     }
-    if (!stretchLogicalHeight)
-        stretchLogicalHeight = style().fontSize();
+    if (stretchHeightAboveBaseline + stretchDepthBelowBaseline <= 0)
+        stretchHeightAboveBaseline = style().fontSize();
     
     // Set the sizes of (possibly embellished) stretchy operator children.
     for (auto& child : childrenOfType<RenderMathMLBlock>(*this)) {
-        if (auto renderMo = child.unembellishedOperator()) {
-            if (renderMo->stretchHeight() != stretchLogicalHeight)
-                renderMo->stretchToHeight(stretchLogicalHeight);
-        }
+        if (auto renderOperator = child.unembellishedOperator())
+            renderOperator->stretchTo(stretchHeightAboveBaseline, stretchDepthBelowBaseline);
     }
 
     RenderMathMLBlock::layout();