2010-07-23 fsamuel@chromium.org <fsamuel@chromium.org>
authorjamesr@google.com <jamesr@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 23 Jul 2010 20:22:29 +0000 (20:22 +0000)
committerjamesr@google.com <jamesr@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 23 Jul 2010 20:22:29 +0000 (20:22 +0000)
        Reviewed by David Hyatt.

        Updated table painting to draw cell layers in the correct order.

        Table Cell Layering
        https://bugs.webkit.org/show_bug.cgi?id=40775

        Tests: tables/layering/paint-test-layering-1.html
               tables/layering/paint-test-layering-2.html

        * accessibility/AccessibilityTable.cpp:
        (WebCore::AccessibilityTable::isTableExposableThroughAccessibility):
        (WebCore::AccessibilityTable::addChildren):
        (WebCore::AccessibilityTable::cellForColumnAndRow):
        * accessibility/AccessibilityTableCell.cpp:
        (WebCore::AccessibilityTableCell::titleUIElement):
        * accessibility/AccessibilityTableColumn.cpp:
        (WebCore::AccessibilityTableColumn::headerObjectForSection):
        * rendering/AutoTableLayout.cpp:
        (WebCore::AutoTableLayout::recalcColumn):
        * rendering/RenderTable.cpp:
        (WebCore::RenderTable::splitColumn):
        (WebCore::RenderTable::calcBorderLeft):
        (WebCore::RenderTable::calcBorderRight):
        (WebCore::RenderTable::cellAbove):
        (WebCore::RenderTable::cellBelow):
        (WebCore::RenderTable::cellBefore):
        (WebCore::RenderTable::cellAfter):
        * rendering/RenderTableSection.cpp:
        (WebCore::RenderTableSection::RenderTableSection):
        (WebCore::RenderTableSection::ensureRows):
        (WebCore::RenderTableSection::addCell):
        (WebCore::RenderTableSection::setCellWidths):
        (WebCore::RenderTableSection::calcRowHeight):
        (WebCore::RenderTableSection::layoutRows):
        (WebCore::RenderTableSection::calcOuterBorderTop):
        (WebCore::RenderTableSection::calcOuterBorderBottom):
        (WebCore::RenderTableSection::calcOuterBorderLeft):
        (WebCore::RenderTableSection::calcOuterBorderRight):
        (WebCore::RenderTableSection::firstLineBoxBaseline):
        (WebCore::compareCellPositions):
        (WebCore::RenderTableSection::paintCell):
        (WebCore::RenderTableSection::paintObject):
        (WebCore::RenderTableSection::numColumns):
        (WebCore::RenderTableSection::appendColumn):
        (WebCore::RenderTableSection::splitColumn):
        (WebCore::RenderTableSection::nodeAtPoint):
        * rendering/RenderTableSection.h:
        (WebCore::RenderTableSection::CellStruct::CellStruct):
        (WebCore::RenderTableSection::CellStruct::primaryCell):
        (WebCore::RenderTableSection::CellStruct::hasCells):
        (WebCore::RenderTableSection::primaryCellAt):
2010-07-23  fsamuel@chromium.org  <fsamuel@chromium.org>

        Reviewed by David Hyatt.

        Updated table painting to draw cell layers in the correct order.

        Table Cell Layering
        https://bugs.webkit.org/show_bug.cgi?id=40775

        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.checksum: Added.
        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png: Added.
        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.txt: Added.
        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.checksum: Added.
        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png: Added.
        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.txt: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.checksum: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.txt: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.checksum: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png: Added.
        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.txt: Added.
        * platform/gtk/tables/layering/paint-test-layering-1-expected.checksum: Added.
        * platform/gtk/tables/layering/paint-test-layering-1-expected.png: Added.
        * platform/gtk/tables/layering/paint-test-layering-1-expected.txt: Added.
        * platform/gtk/tables/layering/paint-test-layering-2-expected.checksum: Added.
        * platform/gtk/tables/layering/paint-test-layering-2-expected.png: Added.
        * platform/gtk/tables/layering/paint-test-layering-2-expected.txt: Added.
        * platform/mac/tables/layering/paint-test-layering-1-expected.checksum: Added.
        * platform/mac/tables/layering/paint-test-layering-1-expected.png: Added.
        * platform/mac/tables/layering/paint-test-layering-1-expected.txt: Added.
        * platform/mac/tables/layering/paint-test-layering-2-expected.checksum: Added.
        * platform/mac/tables/layering/paint-test-layering-2-expected.png: Added.
        * platform/mac/tables/layering/paint-test-layering-2-expected.txt: Added.
        * tables/layering/paint-test-layering-1.html: Added.
        * tables/layering/paint-test-layering-2.html: Added.

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

35 files changed:
LayoutTests/ChangeLog
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.checksum [new file with mode: 0644]
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png [new file with mode: 0644]
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.txt [new file with mode: 0644]
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.checksum [new file with mode: 0644]
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png [new file with mode: 0644]
LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.txt [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.checksum [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.txt [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.checksum [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png [new file with mode: 0644]
LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.txt [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.checksum [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.png [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.txt [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.checksum [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.png [new file with mode: 0644]
LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.txt [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.checksum [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.png [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.txt [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.checksum [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.png [new file with mode: 0644]
LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.txt [new file with mode: 0644]
LayoutTests/tables/layering/paint-test-layering-1.html [new file with mode: 0644]
LayoutTests/tables/layering/paint-test-layering-2.html [new file with mode: 0644]
WebCore/ChangeLog
WebCore/accessibility/AccessibilityTable.cpp
WebCore/accessibility/AccessibilityTableCell.cpp
WebCore/accessibility/AccessibilityTableColumn.cpp
WebCore/rendering/AutoTableLayout.cpp
WebCore/rendering/RenderTable.cpp
WebCore/rendering/RenderTableSection.cpp
WebCore/rendering/RenderTableSection.h

index 001a9a1..26c7e55 100644 (file)
@@ -1,3 +1,39 @@
+2010-07-23  fsamuel@chromium.org  <fsamuel@chromium.org>
+
+        Reviewed by David Hyatt.
+
+        Updated table painting to draw cell layers in the correct order.
+
+        Table Cell Layering
+        https://bugs.webkit.org/show_bug.cgi?id=40775
+
+        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.checksum: Added.
+        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png: Added.
+        * platform/chromium-linux/tables/layering/paint-test-layering-1-expected.txt: Added.
+        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.checksum: Added.
+        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png: Added.
+        * platform/chromium-linux/tables/layering/paint-test-layering-2-expected.txt: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.checksum: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-1-expected.txt: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.checksum: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png: Added.
+        * platform/chromium-mac/tables/layering/paint-test-layering-2-expected.txt: Added.
+        * platform/gtk/tables/layering/paint-test-layering-1-expected.checksum: Added.
+        * platform/gtk/tables/layering/paint-test-layering-1-expected.png: Added.
+        * platform/gtk/tables/layering/paint-test-layering-1-expected.txt: Added.
+        * platform/gtk/tables/layering/paint-test-layering-2-expected.checksum: Added.
+        * platform/gtk/tables/layering/paint-test-layering-2-expected.png: Added.
+        * platform/gtk/tables/layering/paint-test-layering-2-expected.txt: Added.
+        * platform/mac/tables/layering/paint-test-layering-1-expected.checksum: Added.
+        * platform/mac/tables/layering/paint-test-layering-1-expected.png: Added.
+        * platform/mac/tables/layering/paint-test-layering-1-expected.txt: Added.
+        * platform/mac/tables/layering/paint-test-layering-2-expected.checksum: Added.
+        * platform/mac/tables/layering/paint-test-layering-2-expected.png: Added.
+        * platform/mac/tables/layering/paint-test-layering-2-expected.txt: Added.
+        * tables/layering/paint-test-layering-1.html: Added.
+        * tables/layering/paint-test-layering-2.html: Added.
+
 2010-07-23  Stephen White  <senorblanco@chromium.org>
 
         Unreviewed; chromium test expectations fix.
 2010-07-23  Stephen White  <senorblanco@chromium.org>
 
         Unreviewed; chromium test expectations fix.
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.checksum b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.checksum
new file mode 100644 (file)
index 0000000..8546b26
--- /dev/null
@@ -0,0 +1 @@
+1c6d20ec57caf2d7b6a4ae1885715e3e
\ No newline at end of file
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png
new file mode 100644 (file)
index 0000000..7b4123c
Binary files /dev/null and b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.png differ
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.txt b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-1-expected.txt
new file mode 100644 (file)
index 0000000..fb3626b
--- /dev/null
@@ -0,0 +1,54 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x60
+        RenderText {#text} at (0,0) size 746x39
+          text run at (0,0) width 746: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,20) width 172: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 22x19 [color=#FF0000]
+          RenderText {#text} at (172,20) size 22x19
+            text run at (172,20) width 22: "red"
+        RenderText {#text} at (194,20) size 367x19
+          text run at (194,20) width 367: " cell starts at row 1 and column 3 and spans three rows. The "
+        RenderInline {SPAN} at (0,0) size 28x19 [color=#0000FF]
+          RenderText {#text} at (561,20) size 28x19
+            text run at (561,20) width 28: "blue"
+        RenderText {#text} at (589,20) size 781x39
+          text run at (589,20) width 192: " cell starts at row 2, and column"
+          text run at (0,40) width 278: "2, and spans two columns and two rows. The "
+        RenderInline {SPAN} at (0,0) size 38x19 [color=#008000]
+          RenderText {#text} at (278,40) size 38x19
+            text run at (278,40) width 38: "green"
+        RenderText {#text} at (316,40) size 187x19
+          text run at (316,40) width 187: " cell spans 4 columns of row 3."
+      RenderBlock {P} at (0,76) size 784x20
+        RenderText {#text} at (0,0) size 771x19
+          text run at (0,0) width 771: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has failed."
+      RenderTable {TABLE} at (0,112) size 102x82 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 100x80
+          RenderTableRow {TR} at (0,2) size 100x24
+            RenderTableCell {TD} at (2,2) size 20x24 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,2) size 20x24 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (46,54) size 52x24 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=2 rs=3 cs=1]
+              RenderBlock {DIV} at (2,2) size 48x20
+                RenderText {#text} at (0,0) size 48x19
+                  text run at (0,0) width 48: "            "
+          RenderTableRow {TR} at (0,28) size 100x24
+            RenderTableCell {TD} at (2,28) size 20x24 [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,54) size 74x24 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=1 rs=2 cs=2]
+              RenderBlock {DIV} at (2,2) size 70x20 [color=#008000]
+                RenderText {#text} at (16,0) size 54x19
+                  text run at (16,0) width 54: "   FAIL  "
+          RenderTableRow {TR} at (0,54) size 100x24
+            RenderTableCell {TD} at (2,54) size 96x24 [bgcolor=#008000] [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=3]
+              RenderBlock {DIV} at (2,2) size 92x20
+                RenderText {#text} at (84,0) size 8x19
+                  text run at (84,0) width 8: "  "
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.checksum b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.checksum
new file mode 100644 (file)
index 0000000..4e916a7
--- /dev/null
@@ -0,0 +1 @@
+0acf4a6bdbd8bc0e2182e19cf6a21763
\ No newline at end of file
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png
new file mode 100644 (file)
index 0000000..de16244
Binary files /dev/null and b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.png differ
diff --git a/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.txt b/LayoutTests/platform/chromium-linux/tables/layering/paint-test-layering-2-expected.txt
new file mode 100644 (file)
index 0000000..fa23112
--- /dev/null
@@ -0,0 +1,64 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x60
+        RenderText {#text} at (0,0) size 746x39
+          text run at (0,0) width 746: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,20) width 172: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 22x19 [color=#FF0000]
+          RenderText {#text} at (172,20) size 22x19
+            text run at (172,20) width 22: "red"
+        RenderText {#text} at (194,20) size 361x19
+          text run at (194,20) width 361: " cell starts at row 1 and column 4 and spans four rows. The "
+        RenderInline {SPAN} at (0,0) size 28x19 [color=#0000FF]
+          RenderText {#text} at (555,20) size 28x19
+            text run at (555,20) width 28: "blue"
+        RenderText {#text} at (583,20) size 775x39
+          text run at (583,20) width 192: " cell starts at row 2, and column"
+          text run at (0,40) width 192: "1, and spans four columns. The "
+        RenderInline {SPAN} at (0,0) size 38x19 [color=#008000]
+          RenderText {#text} at (192,40) size 38x19
+            text run at (192,40) width 38: "green"
+        RenderText {#text} at (230,40) size 187x19
+          text run at (230,40) width 187: " cell spans 4 columns of row 4."
+      RenderBlock {P} at (0,76) size 784x20
+        RenderText {#text} at (0,0) size 771x19
+          text run at (0,0) width 771: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has failed."
+      RenderTable {TABLE} at (0,112) size 188x108 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 186x106
+          RenderTableRow {TR} at (0,2) size 186x24
+            RenderTableCell {TD} at (2,2) size 44x24 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (48,2) size 44x24 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (94,2) size 44x24 [border: (1px inset #808080)] [r=0 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x19
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (140,41) size 44x24 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=3 rs=4 cs=1]
+              RenderBlock {DIV} at (2,2) size 40x20
+                RenderText {#text} at (0,0) size 40x19
+                  text run at (0,0) width 40: "          "
+          RenderTableRow {TR} at (0,28) size 186x24
+            RenderTableCell {TD} at (2,28) size 182x24 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x20
+                RenderText {#text} at (138,0) size 40x19
+                  text run at (138,0) width 40: "          "
+          RenderTableRow {TR} at (0,54) size 186x24
+            RenderTableCell {TD} at (2,54) size 44x24 [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x19
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (48,54) size 44x24 [border: (1px inset #808080)] [r=2 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x19
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (94,54) size 44x24 [border: (1px inset #808080)] [r=2 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x19
+                text run at (2,2) width 40: "          "
+          RenderTableRow {TR} at (0,80) size 186x24
+            RenderTableCell {TD} at (2,80) size 182x24 [bgcolor=#008000] [border: (1px inset #808080)] [r=3 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x20 [color=#008000]
+                RenderText {#text} at (140,0) size 38x19
+                  text run at (140,0) width 38: "FAIL "
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.checksum b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.checksum
new file mode 100644 (file)
index 0000000..663a3d4
--- /dev/null
@@ -0,0 +1 @@
+74f85aff0ca32f568d65d23112496aef
\ No newline at end of file
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png
new file mode 100644 (file)
index 0000000..a590c92
Binary files /dev/null and b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.png differ
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.txt b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-1-expected.txt
new file mode 100644 (file)
index 0000000..daa9896
--- /dev/null
@@ -0,0 +1,55 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x54
+        RenderText {#text} at (0,0) size 782x36
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,18) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x18 [color=#FF0000]
+          RenderText {#text} at (183,18) size 23x18
+            text run at (183,18) width 23: "red"
+        RenderText {#text} at (206,18) size 381x18
+          text run at (206,18) width 381: " cell starts at row 1 and column 3 and spans three rows. The "
+        RenderInline {SPAN} at (0,0) size 29x18 [color=#0000FF]
+          RenderText {#text} at (587,18) size 29x18
+            text run at (587,18) width 29: "blue"
+        RenderText {#text} at (616,18) size 765x36
+          text run at (616,18) width 149: " cell starts at row 2, and"
+          text run at (0,36) width 341: "column 2, and spans two columns and two rows. The "
+        RenderInline {SPAN} at (0,0) size 38x18 [color=#008000]
+          RenderText {#text} at (341,36) size 38x18
+            text run at (341,36) width 38: "green"
+        RenderText {#text} at (379,36) size 196x18
+          text run at (379,36) width 196: " cell spans 4 columns of row 3."
+      RenderBlock {P} at (0,70) size 784x36
+        RenderText {#text} at (0,0) size 764x36
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,18) width 39: "failed."
+      RenderTable {TABLE} at (0,122) size 102x76 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 100x74
+          RenderTableRow {TR} at (0,2) size 100x22
+            RenderTableCell {TD} at (2,2) size 20x22 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,2) size 20x22 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (46,50) size 52x22 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=2 rs=3 cs=1]
+              RenderBlock {DIV} at (2,2) size 48x18
+                RenderText {#text} at (0,0) size 48x18
+                  text run at (0,0) width 48: "            "
+          RenderTableRow {TR} at (0,26) size 100x22
+            RenderTableCell {TD} at (2,26) size 20x22 [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,50) size 74x22 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=1 rs=2 cs=2]
+              RenderBlock {DIV} at (2,2) size 70x18 [color=#008000]
+                RenderText {#text} at (14,0) size 56x18
+                  text run at (14,0) width 56: "   FAIL  "
+          RenderTableRow {TR} at (0,50) size 100x22
+            RenderTableCell {TD} at (2,50) size 96x22 [bgcolor=#008000] [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=3]
+              RenderBlock {DIV} at (2,2) size 92x18
+                RenderText {#text} at (84,0) size 8x18
+                  text run at (84,0) width 8: "  "
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.checksum b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.checksum
new file mode 100644 (file)
index 0000000..bc3ff1e
--- /dev/null
@@ -0,0 +1 @@
+d3aa1e78efe6c6e3063272d385ee0134
\ No newline at end of file
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png
new file mode 100644 (file)
index 0000000..d0e126e
Binary files /dev/null and b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.png differ
diff --git a/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.txt b/LayoutTests/platform/chromium-mac/tables/layering/paint-test-layering-2-expected.txt
new file mode 100644 (file)
index 0000000..96434f3
--- /dev/null
@@ -0,0 +1,65 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x54
+        RenderText {#text} at (0,0) size 782x36
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,18) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x18 [color=#FF0000]
+          RenderText {#text} at (183,18) size 23x18
+            text run at (183,18) width 23: "red"
+        RenderText {#text} at (206,18) size 376x18
+          text run at (206,18) width 376: " cell starts at row 1 and column 4 and spans four rows. The "
+        RenderInline {SPAN} at (0,0) size 29x18 [color=#0000FF]
+          RenderText {#text} at (582,18) size 29x18
+            text run at (582,18) width 29: "blue"
+        RenderText {#text} at (611,18) size 760x36
+          text run at (611,18) width 149: " cell starts at row 2, and"
+          text run at (0,36) width 253: "column 1, and spans four columns. The "
+        RenderInline {SPAN} at (0,0) size 38x18 [color=#008000]
+          RenderText {#text} at (253,36) size 38x18
+            text run at (253,36) width 38: "green"
+        RenderText {#text} at (291,36) size 196x18
+          text run at (291,36) width 196: " cell spans 4 columns of row 4."
+      RenderBlock {P} at (0,70) size 784x36
+        RenderText {#text} at (0,0) size 764x36
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,18) width 39: "failed."
+      RenderTable {TABLE} at (0,122) size 188x100 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 186x98
+          RenderTableRow {TR} at (0,2) size 186x22
+            RenderTableCell {TD} at (2,2) size 44x22 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (48,2) size 44x22 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (94,2) size 44x22 [border: (1px inset #808080)] [r=0 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (140,38) size 44x22 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=3 rs=4 cs=1]
+              RenderBlock {DIV} at (2,2) size 40x18
+                RenderText {#text} at (0,0) size 40x18
+                  text run at (0,0) width 40: "          "
+          RenderTableRow {TR} at (0,26) size 186x22
+            RenderTableCell {TD} at (2,26) size 182x22 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x18
+                RenderText {#text} at (138,0) size 40x18
+                  text run at (138,0) width 40: "          "
+          RenderTableRow {TR} at (0,50) size 186x22
+            RenderTableCell {TD} at (2,50) size 44x22 [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (48,50) size 44x22 [border: (1px inset #808080)] [r=2 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (94,50) size 44x22 [border: (1px inset #808080)] [r=2 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+          RenderTableRow {TR} at (0,74) size 186x22
+            RenderTableCell {TD} at (2,74) size 182x22 [bgcolor=#008000] [border: (1px inset #808080)] [r=3 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x18 [color=#008000]
+                RenderText {#text} at (138,0) size 40x18
+                  text run at (138,0) width 40: "FAIL "
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.checksum b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.checksum
new file mode 100644 (file)
index 0000000..2a319f2
--- /dev/null
@@ -0,0 +1 @@
+b87f0dd73bcdd145e6dca9443f4da910
\ No newline at end of file
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.png b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.png
new file mode 100644 (file)
index 0000000..df7ca39
Binary files /dev/null and b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.png differ
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.txt b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-1-expected.txt
new file mode 100644 (file)
index 0000000..a0f56a2
--- /dev/null
@@ -0,0 +1,55 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x64
+        RenderText {#text} at (0,0) size 782x41
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,21) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x22 [color=#FF0000]
+          RenderText {#text} at (183,20) size 23x22
+            text run at (183,20) width 23: "red"
+        RenderText {#text} at (206,21) size 381x20
+          text run at (206,21) width 381: " cell starts at row 1 and column 3 and spans three rows. The "
+        RenderInline {SPAN} at (0,0) size 29x22 [color=#0000FF]
+          RenderText {#text} at (587,20) size 29x22
+            text run at (587,20) width 29: "blue"
+        RenderText {#text} at (616,21) size 765x42
+          text run at (616,21) width 149: " cell starts at row 2, and"
+          text run at (0,43) width 341: "column 2, and spans two columns and two rows. The "
+        RenderInline {SPAN} at (0,0) size 38x22 [color=#008000]
+          RenderText {#text} at (341,42) size 38x22
+            text run at (341,42) width 38: "green"
+        RenderText {#text} at (379,43) size 196x20
+          text run at (379,43) width 196: " cell spans 4 columns of row 3."
+      RenderBlock {P} at (0,80) size 784x40
+        RenderText {#text} at (0,0) size 764x40
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,20) width 39: "failed."
+      RenderTable {TABLE} at (0,136) size 102x82 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 100x80
+          RenderTableRow {TR} at (0,2) size 100x24
+            RenderTableCell {TD} at (2,2) size 20x24 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,2) size 20x24 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (46,54) size 52x24 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=2 rs=3 cs=1]
+              RenderBlock {DIV} at (2,2) size 48x20
+                RenderText {#text} at (0,0) size 48x20
+                  text run at (0,0) width 48: "            "
+          RenderTableRow {TR} at (0,28) size 100x24
+            RenderTableCell {TD} at (2,28) size 20x24 [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,54) size 74x24 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=1 rs=2 cs=2]
+              RenderBlock {DIV} at (2,2) size 70x20 [color=#008000]
+                RenderText {#text} at (14,0) size 56x20
+                  text run at (14,0) width 56: "   FAIL  "
+          RenderTableRow {TR} at (0,54) size 100x24
+            RenderTableCell {TD} at (2,54) size 96x24 [bgcolor=#008000] [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=3]
+              RenderBlock {DIV} at (2,2) size 92x20
+                RenderText {#text} at (84,0) size 8x20
+                  text run at (84,0) width 8: "  "
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.checksum b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.checksum
new file mode 100644 (file)
index 0000000..4c0497c
--- /dev/null
@@ -0,0 +1 @@
+7ab3158057c5f13dc77965e312b2549f
\ No newline at end of file
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.png b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.png
new file mode 100644 (file)
index 0000000..92e9f73
Binary files /dev/null and b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.png differ
diff --git a/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.txt b/LayoutTests/platform/gtk/tables/layering/paint-test-layering-2-expected.txt
new file mode 100644 (file)
index 0000000..aced1e8
--- /dev/null
@@ -0,0 +1,65 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x64
+        RenderText {#text} at (0,0) size 782x41
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,21) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x22 [color=#FF0000]
+          RenderText {#text} at (183,20) size 23x22
+            text run at (183,20) width 23: "red"
+        RenderText {#text} at (206,21) size 376x20
+          text run at (206,21) width 376: " cell starts at row 1 and column 4 and spans four rows. The "
+        RenderInline {SPAN} at (0,0) size 29x22 [color=#0000FF]
+          RenderText {#text} at (582,20) size 29x22
+            text run at (582,20) width 29: "blue"
+        RenderText {#text} at (611,21) size 760x42
+          text run at (611,21) width 149: " cell starts at row 2, and"
+          text run at (0,43) width 253: "column 1, and spans four columns. The "
+        RenderInline {SPAN} at (0,0) size 38x22 [color=#008000]
+          RenderText {#text} at (253,42) size 38x22
+            text run at (253,42) width 38: "green"
+        RenderText {#text} at (291,43) size 196x20
+          text run at (291,43) width 196: " cell spans 4 columns of row 4."
+      RenderBlock {P} at (0,80) size 784x40
+        RenderText {#text} at (0,0) size 764x40
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,20) width 39: "failed."
+      RenderTable {TABLE} at (0,136) size 188x108 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 186x106
+          RenderTableRow {TR} at (0,2) size 186x24
+            RenderTableCell {TD} at (2,2) size 44x24 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (48,2) size 44x24 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (94,2) size 44x24 [border: (1px inset #808080)] [r=0 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x20
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (140,41) size 44x24 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=3 rs=4 cs=1]
+              RenderBlock {DIV} at (2,2) size 40x20
+                RenderText {#text} at (0,0) size 40x20
+                  text run at (0,0) width 40: "          "
+          RenderTableRow {TR} at (0,28) size 186x24
+            RenderTableCell {TD} at (2,28) size 182x24 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x20
+                RenderText {#text} at (138,0) size 40x20
+                  text run at (138,0) width 40: "          "
+          RenderTableRow {TR} at (0,54) size 186x24
+            RenderTableCell {TD} at (2,54) size 44x24 [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x20
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (48,54) size 44x24 [border: (1px inset #808080)] [r=2 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x20
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (94,54) size 44x24 [border: (1px inset #808080)] [r=2 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x20
+                text run at (2,2) width 40: "          "
+          RenderTableRow {TR} at (0,80) size 186x24
+            RenderTableCell {TD} at (2,80) size 182x24 [bgcolor=#008000] [border: (1px inset #808080)] [r=3 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x20 [color=#008000]
+                RenderText {#text} at (138,0) size 40x20
+                  text run at (138,0) width 40: "FAIL "
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.checksum b/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.checksum
new file mode 100644 (file)
index 0000000..663a3d4
--- /dev/null
@@ -0,0 +1 @@
+74f85aff0ca32f568d65d23112496aef
\ No newline at end of file
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.png b/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.png
new file mode 100644 (file)
index 0000000..3488cfc
Binary files /dev/null and b/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.png differ
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.txt b/LayoutTests/platform/mac/tables/layering/paint-test-layering-1-expected.txt
new file mode 100644 (file)
index 0000000..daa9896
--- /dev/null
@@ -0,0 +1,55 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x54
+        RenderText {#text} at (0,0) size 782x36
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,18) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x18 [color=#FF0000]
+          RenderText {#text} at (183,18) size 23x18
+            text run at (183,18) width 23: "red"
+        RenderText {#text} at (206,18) size 381x18
+          text run at (206,18) width 381: " cell starts at row 1 and column 3 and spans three rows. The "
+        RenderInline {SPAN} at (0,0) size 29x18 [color=#0000FF]
+          RenderText {#text} at (587,18) size 29x18
+            text run at (587,18) width 29: "blue"
+        RenderText {#text} at (616,18) size 765x36
+          text run at (616,18) width 149: " cell starts at row 2, and"
+          text run at (0,36) width 341: "column 2, and spans two columns and two rows. The "
+        RenderInline {SPAN} at (0,0) size 38x18 [color=#008000]
+          RenderText {#text} at (341,36) size 38x18
+            text run at (341,36) width 38: "green"
+        RenderText {#text} at (379,36) size 196x18
+          text run at (379,36) width 196: " cell spans 4 columns of row 3."
+      RenderBlock {P} at (0,70) size 784x36
+        RenderText {#text} at (0,0) size 764x36
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,18) width 39: "failed."
+      RenderTable {TABLE} at (0,122) size 102x76 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 100x74
+          RenderTableRow {TR} at (0,2) size 100x22
+            RenderTableCell {TD} at (2,2) size 20x22 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,2) size 20x22 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (46,50) size 52x22 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=2 rs=3 cs=1]
+              RenderBlock {DIV} at (2,2) size 48x18
+                RenderText {#text} at (0,0) size 48x18
+                  text run at (0,0) width 48: "            "
+          RenderTableRow {TR} at (0,26) size 100x22
+            RenderTableCell {TD} at (2,26) size 20x22 [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (24,50) size 74x22 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=1 rs=2 cs=2]
+              RenderBlock {DIV} at (2,2) size 70x18 [color=#008000]
+                RenderText {#text} at (14,0) size 56x18
+                  text run at (14,0) width 56: "   FAIL  "
+          RenderTableRow {TR} at (0,50) size 100x22
+            RenderTableCell {TD} at (2,50) size 96x22 [bgcolor=#008000] [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=3]
+              RenderBlock {DIV} at (2,2) size 92x18
+                RenderText {#text} at (84,0) size 8x18
+                  text run at (84,0) width 8: "  "
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.checksum b/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.checksum
new file mode 100644 (file)
index 0000000..bc3ff1e
--- /dev/null
@@ -0,0 +1 @@
+d3aa1e78efe6c6e3063272d385ee0134
\ No newline at end of file
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.png b/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.png
new file mode 100644 (file)
index 0000000..046e3d3
Binary files /dev/null and b/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.png differ
diff --git a/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.txt b/LayoutTests/platform/mac/tables/layering/paint-test-layering-2-expected.txt
new file mode 100644 (file)
index 0000000..96434f3
--- /dev/null
@@ -0,0 +1,65 @@
+layer at (0,0) size 800x600
+  RenderView at (0,0) size 800x600
+layer at (0,0) size 800x600
+  RenderBlock {HTML} at (0,0) size 800x600
+    RenderBody {BODY} at (8,8) size 784x584
+      RenderBlock {P} at (0,0) size 784x54
+        RenderText {#text} at (0,0) size 782x36
+          text run at (0,0) width 782: "This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span"
+          text run at (0,18) width 183: "multiple table grid slots. The "
+        RenderInline {SPAN} at (0,0) size 23x18 [color=#FF0000]
+          RenderText {#text} at (183,18) size 23x18
+            text run at (183,18) width 23: "red"
+        RenderText {#text} at (206,18) size 376x18
+          text run at (206,18) width 376: " cell starts at row 1 and column 4 and spans four rows. The "
+        RenderInline {SPAN} at (0,0) size 29x18 [color=#0000FF]
+          RenderText {#text} at (582,18) size 29x18
+            text run at (582,18) width 29: "blue"
+        RenderText {#text} at (611,18) size 760x36
+          text run at (611,18) width 149: " cell starts at row 2, and"
+          text run at (0,36) width 253: "column 1, and spans four columns. The "
+        RenderInline {SPAN} at (0,0) size 38x18 [color=#008000]
+          RenderText {#text} at (253,36) size 38x18
+            text run at (253,36) width 38: "green"
+        RenderText {#text} at (291,36) size 196x18
+          text run at (291,36) width 196: " cell spans 4 columns of row 4."
+      RenderBlock {P} at (0,70) size 784x36
+        RenderText {#text} at (0,0) size 764x36
+          text run at (0,0) width 764: "If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has"
+          text run at (0,18) width 39: "failed."
+      RenderTable {TABLE} at (0,122) size 188x100 [border: (1px outset #808080)]
+        RenderTableSection {TBODY} at (1,1) size 186x98
+          RenderTableRow {TR} at (0,2) size 186x22
+            RenderTableCell {TD} at (2,2) size 44x22 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (48,2) size 44x22 [border: (1px inset #808080)] [r=0 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (94,2) size 44x22 [border: (1px inset #808080)] [r=0 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 16x18
+                text run at (2,2) width 16: "    "
+            RenderTableCell {TD} at (140,38) size 44x22 [bgcolor=#FF0000] [border: (1px inset #808080)] [r=0 c=3 rs=4 cs=1]
+              RenderBlock {DIV} at (2,2) size 40x18
+                RenderText {#text} at (0,0) size 40x18
+                  text run at (0,0) width 40: "          "
+          RenderTableRow {TR} at (0,26) size 186x22
+            RenderTableCell {TD} at (2,26) size 182x22 [bgcolor=#0000FF] [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x18
+                RenderText {#text} at (138,0) size 40x18
+                  text run at (138,0) width 40: "          "
+          RenderTableRow {TR} at (0,50) size 186x22
+            RenderTableCell {TD} at (2,50) size 44x22 [border: (1px inset #808080)] [r=2 c=0 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (48,50) size 44x22 [border: (1px inset #808080)] [r=2 c=1 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+            RenderTableCell {TD} at (94,50) size 44x22 [border: (1px inset #808080)] [r=2 c=2 rs=1 cs=1]
+              RenderText {#text} at (2,2) size 40x18
+                text run at (2,2) width 40: "          "
+          RenderTableRow {TR} at (0,74) size 186x22
+            RenderTableCell {TD} at (2,74) size 182x22 [bgcolor=#008000] [border: (1px inset #808080)] [r=3 c=0 rs=1 cs=4]
+              RenderBlock {DIV} at (2,2) size 178x18 [color=#008000]
+                RenderText {#text} at (138,0) size 40x18
+                  text run at (138,0) width 40: "FAIL "
diff --git a/LayoutTests/tables/layering/paint-test-layering-1.html b/LayoutTests/tables/layering/paint-test-layering-1.html
new file mode 100644 (file)
index 0000000..b20a8c4
--- /dev/null
@@ -0,0 +1,45 @@
+<html>
+<head>
+<title>Table Repaint Test</title>
+
+</head>
+<script type="text/javascript">\r
+<!--\r
+    function Setup() { 
+        setTimeout('RepaintBug()', 10);
+        if (window.layoutTestController)
+            layoutTestController.waitUntilDone();
+    }
+    function RepaintBug() {\r
+        var div1 = document.getElementById("bug2");\r
+        div1.style.color = 'green';\r
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }
+//-->
+</script>
+  <body onLoad="Setup()">
+    <p>
+        This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span multiple table grid slots. The <span style="color: red; font-weight: bold;">red</span> cell starts at row 1 and column 3 and spans three rows. The <span style="color: blue; font-weight: bold;">blue</span> cell starts at row 2, and column 2, and spans two columns and two rows. The <span style="color: green; font-weight: bold;">green</span> cell spans 4 columns of row 3.
+    </p>
+    <p>
+        If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has failed.
+    </p>
+  <table border="1">
+    <tbody>
+    <tr>
+      <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
+      <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
+      <td rowspan="3" valign="bottom" style="background-color:red;"><div id="bug1">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</div></td>
+    </tr>
+    <tr>
+      <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
+      <td rowspan="2" colspan="2" align="right" valign="bottom" style="background-color:blue;"><div id="bug2">&nbsp;&nbsp;&nbsp;FAIL&nbsp;&nbsp;</div></td>
+    </tr>
+    <tr>
+      <td colspan="3" align="right" style="background-color:green;"><div id="bug3">&nbsp;&nbsp;</div></td>
+    </tr>
+    </tbody>
+  </table>
+  </body>
+</html>
diff --git a/LayoutTests/tables/layering/paint-test-layering-2.html b/LayoutTests/tables/layering/paint-test-layering-2.html
new file mode 100644 (file)
index 0000000..938d489
--- /dev/null
@@ -0,0 +1,67 @@
+<html>\r
+<head>\r
+<title>Table Repaint Test</title>\r
+</head>\r
+<script type="text/javascript">\r
+<!--\r
+    function Setup() { 
+        setTimeout('RepaintBug()', 10);
+        if (window.layoutTestController)
+            layoutTestController.waitUntilDone();
+    }
+    function RepaintBug() {\r
+        var div2 = document.getElementById("bug2");
+        div2.style.color = 'green';\r
+        if (window.layoutTestController)
+            layoutTestController.notifyDone();
+    }\r
+//-->\r
+</script>\r
+<body onLoad="Setup()">
+    <p>
+        This test checks the renderer's ability to layer multiple cells in a table on top of one another. This test has three cells that span multiple table grid slots. The <span style="color: red; font-weight: bold;">red</span> cell starts at row 1 and column 4 and spans four rows. The <span style="color: blue; font-weight: bold;">blue</span> cell starts at row 2, and column 1, and spans four columns. The <span style="color: green; font-weight: bold;">green</span> cell spans 4 columns of row 4.
+    </p>
+    <p>
+        If the test succeeds then you should see no text inside the table. If you see the text 'FAIL' inside the table, then the test has failed.
+    </p>
+    <table border="1">\r
+        <tr>\r
+            <td>\r
+                &nbsp;&nbsp;&nbsp;&nbsp;\r
+            </td>\r
+            <td> \r
+                &nbsp;&nbsp;&nbsp;&nbsp;\r
+            </td>\r
+            <td>\r
+                &nbsp;&nbsp;&nbsp;&nbsp;\r
+            </td>\r
+            <td rowspan="4" style="background-color: red;">\r
+                <div>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</div>\r
+            </td>\r
+        </tr>\r
+        <tr>\r
+            <td colspan="4" style="background-color: blue;" align="right">\r
+                <div>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</div>\r
+            </td>\r
+        </tr>\r
+        <tr>\r
+            <td>\r
+                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+            </td>\r
+            <td>\r
+                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+            </td>\r
+            <td>\r
+                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+            </td>                \r
+        </tr>\r
+        <tr>\r
+            <td colspan="4" align="right" style="background-color: green;">\r
+                <div id="bug2">
+                    FAIL&nbsp;
+                </div>\r
+            </td>\r
+        </tr>\r
+    </table>\r
+</body>\r
+</html>\r
index c952ccc..6d24e14 100644 (file)
@@ -1,3 +1,58 @@
+2010-07-23  fsamuel@chromium.org  <fsamuel@chromium.org>
+
+        Reviewed by David Hyatt.
+
+        Updated table painting to draw cell layers in the correct order.
+
+        Table Cell Layering
+        https://bugs.webkit.org/show_bug.cgi?id=40775
+
+        Tests: tables/layering/paint-test-layering-1.html
+               tables/layering/paint-test-layering-2.html
+
+        * accessibility/AccessibilityTable.cpp:
+        (WebCore::AccessibilityTable::isTableExposableThroughAccessibility):
+        (WebCore::AccessibilityTable::addChildren):
+        (WebCore::AccessibilityTable::cellForColumnAndRow):
+        * accessibility/AccessibilityTableCell.cpp:
+        (WebCore::AccessibilityTableCell::titleUIElement):
+        * accessibility/AccessibilityTableColumn.cpp:
+        (WebCore::AccessibilityTableColumn::headerObjectForSection):
+        * rendering/AutoTableLayout.cpp:
+        (WebCore::AutoTableLayout::recalcColumn):
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::splitColumn):
+        (WebCore::RenderTable::calcBorderLeft):
+        (WebCore::RenderTable::calcBorderRight):
+        (WebCore::RenderTable::cellAbove):
+        (WebCore::RenderTable::cellBelow):
+        (WebCore::RenderTable::cellBefore):
+        (WebCore::RenderTable::cellAfter):
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::RenderTableSection):
+        (WebCore::RenderTableSection::ensureRows):
+        (WebCore::RenderTableSection::addCell):
+        (WebCore::RenderTableSection::setCellWidths):
+        (WebCore::RenderTableSection::calcRowHeight):
+        (WebCore::RenderTableSection::layoutRows):
+        (WebCore::RenderTableSection::calcOuterBorderTop):
+        (WebCore::RenderTableSection::calcOuterBorderBottom):
+        (WebCore::RenderTableSection::calcOuterBorderLeft):
+        (WebCore::RenderTableSection::calcOuterBorderRight):
+        (WebCore::RenderTableSection::firstLineBoxBaseline):
+        (WebCore::compareCellPositions):
+        (WebCore::RenderTableSection::paintCell):
+        (WebCore::RenderTableSection::paintObject):
+        (WebCore::RenderTableSection::numColumns):
+        (WebCore::RenderTableSection::appendColumn):
+        (WebCore::RenderTableSection::splitColumn):
+        (WebCore::RenderTableSection::nodeAtPoint):
+        * rendering/RenderTableSection.h:
+        (WebCore::RenderTableSection::CellStruct::CellStruct):
+        (WebCore::RenderTableSection::CellStruct::primaryCell):
+        (WebCore::RenderTableSection::CellStruct::hasCells):
+        (WebCore::RenderTableSection::primaryCellAt):
+
 2010-07-23  Patrick Gansterer  <paroga@paroga.com>
 
         Reviewed by Adam Roben.
 2010-07-23  Patrick Gansterer  <paroga@paroga.com>
 
         Reviewed by Adam Roben.
index a0bb655..04ecac3 100644 (file)
@@ -145,7 +145,7 @@ bool AccessibilityTable::isTableExposableThroughAccessibility()
     
         int headersInFirstRowCount = 0;
         for (int col = 0; col < numCols; ++col) {    
     
         int headersInFirstRowCount = 0;
         for (int col = 0; col < numCols; ++col) {    
-            RenderTableCell* cell = firstBody->cellAt(row, col).cell;
+            RenderTableCell* cell = firstBody->primaryCellAt(row, col);
             if (!cell)
                 continue;
             Node* cellNode = cell->node();
             if (!cell)
                 continue;
             Node* cellNode = cell->node();
@@ -287,7 +287,7 @@ void AccessibilityTable::addChildren()
         for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
             for (unsigned colIndex = 0; colIndex < numCols; ++colIndex) {
                 
         for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
             for (unsigned colIndex = 0; colIndex < numCols; ++colIndex) {
                 
-                RenderTableCell* cell = tableSection->cellAt(rowIndex, colIndex).cell;
+                RenderTableCell* cell = tableSection->primaryCellAt(rowIndex, colIndex);
                 if (!cell)
                     continue;
                 
                 if (!cell)
                     continue;
                 
@@ -441,7 +441,7 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
         
         unsigned sectionSpecificRow = row - rowOffset;            
         if (row < rowCount && column < numCols && sectionSpecificRow < numRows) {
         
         unsigned sectionSpecificRow = row - rowOffset;            
         if (row < rowCount && column < numCols && sectionSpecificRow < numRows) {
-            cell = tableSection->cellAt(sectionSpecificRow, column).cell;
+            cell = tableSection->primaryCellAt(sectionSpecificRow, column);
             
             // we didn't find the cell, which means there's spanning happening
             // search backwards to find the spanning cell
             
             // we didn't find the cell, which means there's spanning happening
             // search backwards to find the spanning cell
@@ -449,7 +449,7 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
                 
                 // first try rows
                 for (int testRow = sectionSpecificRow-1; testRow >= 0; --testRow) {
                 
                 // first try rows
                 for (int testRow = sectionSpecificRow-1; testRow >= 0; --testRow) {
-                    cell = tableSection->cellAt(testRow, column).cell;
+                    cell = tableSection->primaryCellAt(testRow, column);
                     // cell overlapped. use this one
                     if (cell && ((cell->row() + (cell->rowSpan()-1)) >= (int)sectionSpecificRow))
                         break;
                     // cell overlapped. use this one
                     if (cell && ((cell->row() + (cell->rowSpan()-1)) >= (int)sectionSpecificRow))
                         break;
@@ -459,7 +459,7 @@ AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column,
                 if (!cell) {
                     // try cols
                     for (int testCol = column-1; testCol >= 0; --testCol) {
                 if (!cell) {
                     // try cols
                     for (int testCol = column-1; testCol >= 0; --testCol) {
-                        cell = tableSection->cellAt(sectionSpecificRow, testCol).cell;
+                        cell = tableSection->primaryCellAt(sectionSpecificRow, testCol);
                         // cell overlapped. use this one
                         if (cell && ((cell->col() + (cell->colSpan()-1)) >= (int)column))
                             break;
                         // cell overlapped. use this one
                         if (cell && ((cell->col() + (cell->colSpan()-1)) >= (int)column))
                             break;
index 28e66ad..e2efb5e 100644 (file)
@@ -165,7 +165,7 @@ AccessibilityObject* AccessibilityTableCell::titleUIElement() const
     if (!section)
         return 0;
     
     if (!section)
         return 0;
     
-    RenderTableCell* headerCell = section->cellAt(row, 0).cell;
+    RenderTableCell* headerCell = section->primaryCellAt(row, 0);
     if (!headerCell || headerCell == renderCell)
         return 0;
 
     if (!headerCell || headerCell == renderCell)
         return 0;
 
index 45137ff..f776e40 100644 (file)
@@ -136,7 +136,7 @@ AccessibilityObject* AccessibilityTableColumn::headerObjectForSection(RenderTabl
     RenderTableCell* cell = 0;
     // also account for cells that have a span
     for (int testCol = m_columnIndex; testCol >= 0; --testCol) {
     RenderTableCell* cell = 0;
     // also account for cells that have a span
     for (int testCol = m_columnIndex; testCol >= 0; --testCol) {
-        RenderTableCell* testCell = section->cellAt(0, testCol).cell;
+        RenderTableCell* testCell = section->primaryCellAt(0, testCol);
         if (!testCell)
             continue;
         
         if (!testCell)
             continue;
         
index e6a1cc0..0715caa 100644 (file)
@@ -66,9 +66,9 @@ void AutoTableLayout::recalcColumn(int effCol)
             int numRows = section->numRows();
             for (int i = 0; i < numRows; i++) {
                 RenderTableSection::CellStruct current = section->cellAt(i, effCol);
             int numRows = section->numRows();
             for (int i = 0; i < numRows; i++) {
                 RenderTableSection::CellStruct current = section->cellAt(i, effCol);
-                RenderTableCell* cell = current.cell;
+                RenderTableCell* cell = current.primaryCell();
                 
                 
-                bool cellHasContent = cell && (cell->firstChild() || cell->style()->hasBorder() || cell->style()->hasPadding());
+                bool cellHasContent = cell && !current.inColSpan && (cell->firstChild() || cell->style()->hasBorder() || cell->style()->hasPadding());
                 if (cellHasContent)
                     l.emptyCellsOnly = false;
                     
                 if (cellHasContent)
                     l.emptyCellsOnly = false;
                     
@@ -125,7 +125,7 @@ void AutoTableLayout::recalcColumn(int effCol)
                         break;
                     }
                 } else {
                         break;
                     }
                 } else {
-                    if (cell && (!effCol || section->cellAt(i, effCol-1).cell != cell)) {
+                    if (cell && (!effCol || cell->section()->primaryCellAt(i, effCol-1) != cell)) {
                         // This spanning cell originates in this column.  Ensure we have
                         // a min/max width of at least 1px for this column now.
                         l.minWidth = max(l.minWidth, cellHasContent ? 1 : 0);
                         // This spanning cell originates in this column.  Ensure we have
                         // a min/max width of at least 1px for this column now.
                         l.minWidth = max(l.minWidth, cellHasContent ? 1 : 0);
index fd90990..658fd9c 100644 (file)
@@ -556,7 +556,7 @@ void RenderTable::splitColumn(int pos, int firstSpan)
     // change width of all rows.
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isTableSection())
     // change width of all rows.
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isTableSection())
-            toRenderTableSection(child)->splitColumn(pos, oldSize + 1);
+            toRenderTableSection(child)->splitColumn(pos, firstSpan);
     }
 
     m_columnPos.grow(numEffCols() + 1);
     }
 
     m_columnPos.grow(numEffCols() + 1);
@@ -750,12 +750,12 @@ int RenderTable::calcBorderLeft() const
 
             const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, leftmostColumn);
             
 
             const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, leftmostColumn);
             
-            if (cs.cell) {
-                const BorderValue& cb = cs.cell->style()->borderLeft();
+            if (cs.hasCells()) {
+                const BorderValue& cb = cs.primaryCell()->style()->borderLeft();
                 if (cb.style() == BHIDDEN)
                     return 0;
 
                 if (cb.style() == BHIDDEN)
                     return 0;
 
-                const BorderValue& rb = cs.cell->parent()->style()->borderLeft();
+                const BorderValue& rb = cs.primaryCell()->parent()->style()->borderLeft();
                 if (rb.style() == BHIDDEN)
                     return 0;
 
                 if (rb.style() == BHIDDEN)
                     return 0;
 
@@ -809,12 +809,12 @@ int RenderTable::calcBorderRight() const
 
             const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, rightmostColumn);
             
 
             const RenderTableSection::CellStruct& cs = firstNonEmptySection->cellAt(0, rightmostColumn);
             
-            if (cs.cell) {
-                const BorderValue& cb = cs.cell->style()->borderRight();
+            if (cs.hasCells()) {
+                const BorderValue& cb = cs.primaryCell()->style()->borderRight();
                 if (cb.style() == BHIDDEN)
                     return 0;
 
                 if (cb.style() == BHIDDEN)
                     return 0;
 
-                const BorderValue& rb = cs.cell->parent()->style()->borderRight();
+                const BorderValue& rb = cs.primaryCell()->parent()->style()->borderRight();
                 if (rb.style() == BHIDDEN)
                     return 0;
 
                 if (rb.style() == BHIDDEN)
                     return 0;
 
@@ -1024,8 +1024,8 @@ RenderTableCell* RenderTable::cellAbove(const RenderTableCell* cell) const
         do {
             aboveCell = section->cellAt(rAbove, effCol);
             effCol--;
         do {
             aboveCell = section->cellAt(rAbove, effCol);
             effCol--;
-        } while (!aboveCell.cell && aboveCell.inColSpan && effCol >= 0);
-        return aboveCell.cell;
+        } while (!aboveCell.hasCells() && aboveCell.inColSpan && effCol >= 0);
+        return aboveCell.primaryCell();
     } else
         return 0;
 }
     } else
         return 0;
 }
@@ -1056,8 +1056,8 @@ RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const
         do {
             belowCell = section->cellAt(rBelow, effCol);
             effCol--;
         do {
             belowCell = section->cellAt(rBelow, effCol);
             effCol--;
-        } while (!belowCell.cell && belowCell.inColSpan && effCol >= 0);
-        return belowCell.cell;
+        } while (!belowCell.hasCells() && belowCell.inColSpan && effCol >= 0);
+        return belowCell.primaryCell();
     } else
         return 0;
 }
     } else
         return 0;
 }
@@ -1076,8 +1076,8 @@ RenderTableCell* RenderTable::cellBefore(const RenderTableCell* cell) const
     do {
         prevCell = section->cellAt(cell->row(), effCol - 1);
         effCol--;
     do {
         prevCell = section->cellAt(cell->row(), effCol - 1);
         effCol--;
-    } while (!prevCell.cell && prevCell.inColSpan && effCol >= 0);
-    return prevCell.cell;
+    } while (!prevCell.hasCells() && prevCell.inColSpan && effCol >= 0);
+    return prevCell.primaryCell();
 }
 
 RenderTableCell* RenderTable::cellAfter(const RenderTableCell* cell) const
 }
 
 RenderTableCell* RenderTable::cellAfter(const RenderTableCell* cell) const
@@ -1087,7 +1087,7 @@ RenderTableCell* RenderTable::cellAfter(const RenderTableCell* cell) const
     int effCol = colToEffCol(cell->col() + cell->colSpan());
     if (effCol >= numEffCols())
         return 0;
     int effCol = colToEffCol(cell->col() + cell->colSpan());
     if (effCol >= numEffCols())
         return 0;
-    return cell->section()->cellAt(cell->row(), effCol).cell;
+    return cell->section()->primaryCellAt(cell->row(), effCol);
 }
 
 RenderBlock* RenderTable::firstLineBlock() const
 }
 
 RenderBlock* RenderTable::firstLineBlock() const
index b25d3e6..8c8d130 100644 (file)
@@ -34,6 +34,7 @@
 #include "RenderTableRow.h"
 #include "RenderView.h"
 #include <limits>
 #include "RenderTableRow.h"
 #include "RenderView.h"
 #include <limits>
+#include <wtf/HashSet.h>
 #include <wtf/Vector.h>
 
 using namespace std;
 #include <wtf/Vector.h>
 
 using namespace std;
@@ -61,9 +62,10 @@ RenderTableSection::RenderTableSection(Node* node)
     , m_outerBorderBottom(0)
     , m_needsCellRecalc(false)
     , m_hasOverflowingCell(false)
     , m_outerBorderBottom(0)
     , m_needsCellRecalc(false)
     , m_hasOverflowingCell(false)
+    , m_hasMultipleCellLevels(false)
 {
     // init RenderObject attributes
 {
     // init RenderObject attributes
-    setInline(false);   // our object is not Inline
+    setInline(false); // our object is not Inline
 }
 
 RenderTableSection::~RenderTableSection()
 }
 
 RenderTableSection::~RenderTableSection()
@@ -160,8 +162,8 @@ bool RenderTableSection::ensureRows(int numRows)
         m_gridRows = numRows;
         int nCols = max(1, table()->numEffCols());
         CellStruct emptyCellStruct;
         m_gridRows = numRows;
         int nCols = max(1, table()->numEffCols());
         CellStruct emptyCellStruct;
-        emptyCellStruct.cell = 0;
         emptyCellStruct.inColSpan = false;
         emptyCellStruct.inColSpan = false;
+        emptyCellStruct.empty = false;
         for (int r = nRows; r < numRows; r++) {
             m_grid[r].row = new Row(nCols);
             m_grid[r].row->fill(emptyCellStruct);
         for (int r = nRows; r < numRows; r++) {
             m_grid[r].row = new Row(nCols);
             m_grid[r].row->fill(emptyCellStruct);
@@ -187,10 +189,8 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
     // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
     // <TR><TD colspan="2">5
     // </TABLE>
     // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
     // <TR><TD colspan="2">5
     // </TABLE>
-
-    while (m_cCol < nCols && (cellAt(m_cRow, m_cCol).cell || cellAt(m_cRow, m_cCol).inColSpan))
+    while (m_cCol < nCols && (cellAt(m_cRow, m_cCol).hasCells() || cellAt(m_cRow, m_cCol).inColSpan))
         m_cCol++;
         m_cCol++;
-
     if (rSpan == 1) {
         // we ignore height settings on rowspan cells
         Length height = cell->style()->height();
     if (rSpan == 1) {
         // we ignore height settings on rowspan cells
         Length height = cell->style()->height();
@@ -222,31 +222,30 @@ void RenderTableSection::addCell(RenderTableCell* cell, RenderTableRow* row)
 
     int col = m_cCol;
     // tell the cell where it is
 
     int col = m_cCol;
     // tell the cell where it is
-    CellStruct currentCell;
-    currentCell.cell = cell;
-    currentCell.inColSpan = false;
+    bool inColSpan = false;
     while (cSpan) {
     while (cSpan) {
-        int currentSpan;
-        if (m_cCol >= nCols) {
-            table()->appendColumn(cSpan);
-            currentSpan = cSpan;
-        } else {
-            if (cSpan < static_cast<int>(columns[m_cCol].span))
-                table()->splitColumn(m_cCol, cSpan);
-            currentSpan = columns[m_cCol].span;
-        }
-
-        for (int r = 0; r < rSpan; r++) {
-            CellStruct& c = cellAt(m_cRow + r, m_cCol);
-            if (!c.cell)
-                c.cell = currentCell.cell;
-            if (currentCell.inColSpan)
-                c.inColSpan = true;
-        }
-        m_cCol++;
-        cSpan -= currentSpan;
-        currentCell.cell = 0;
-        currentCell.inColSpan = true;
+      int currentSpan;
+      if (m_cCol >= nCols) {
+          table()->appendColumn(cSpan);
+          currentSpan = cSpan;
+      } else {
+          if (cSpan < (int)columns[m_cCol].span)
+              table()->splitColumn(m_cCol, cSpan);
+          currentSpan = columns[m_cCol].span;
+      }
+      for (int r = 0; r < rSpan; r++) {
+          CellStruct& c = cellAt(m_cRow + r, m_cCol);
+          ASSERT(cell);
+          c.cells.append(cell);
+          // If cells overlap then we take the slow path for painting.
+          if (c.cells.size() > 1)
+              m_hasMultipleCellLevels = true;
+          if (inColSpan)
+              c.inColSpan = true;
+      }
+      m_cCol++;
+      cSpan -= currentSpan;
+      inColSpan = true;
     }
     cell->setRow(m_cRow);
     cell->setCol(table()->effColToCol(col));
     }
     cell->setRow(m_cRow);
     cell->setCol(table()->effColToCol(col));
@@ -261,15 +260,25 @@ void RenderTableSection::setCellWidths()
     for (int i = 0; i < m_gridRows; i++) {
         Row& row = *m_grid[i].row;
         int cols = row.size();
     for (int i = 0; i < m_gridRows; i++) {
         Row& row = *m_grid[i].row;
         int cols = row.size();
+        RenderTableCell* lastCell = 0;
         for (int j = 0; j < cols; j++) {
         for (int j = 0; j < cols; j++) {
-            CellStruct current = row[j];
-            RenderTableCell* cell = current.cell;
-
-            if (!cell)
-                continue;
+            CellStruct& current = row[j];
+            RenderTableCell* cell = current.primaryCell();
+            if (!cell) {
+              ASSERT(lastCell || !current.inColSpan);
+              if (lastCell)
+                current.cells.append(lastCell);
+              if (!current.inColSpan)
+                current.empty = true;
+              continue;
+            }
+            if (current.inColSpan || current.empty)
+              continue;
+            lastCell = cell;
             int endCol = j;
             int cspan = cell->colSpan();
             while (cspan && endCol < cols) {
             int endCol = j;
             int cspan = cell->colSpan();
             while (cspan && endCol < cols) {
+                ASSERT(endCol < (int)table()->columns().size());
                 cspan -= table()->columns()[endCol].span;
                 endCol++;
             }
                 cspan -= table()->columns()[endCol].span;
                 endCol++;
             }
@@ -290,7 +299,7 @@ void RenderTableSection::setCellWidths()
         }
     }
     
         }
     }
     
-    statePusher.pop();  // only pops if we pushed
+    statePusher.pop(); // only pops if we pushed
 }
 
 int RenderTableSection::calcRowHeight()
 }
 
 int RenderTableSection::calcRowHeight()
@@ -324,11 +333,13 @@ int RenderTableSection::calcRowHeight()
         int totalCols = row->size();
 
         for (int c = 0; c < totalCols; c++) {
         int totalCols = row->size();
 
         for (int c = 0; c < totalCols; c++) {
-            CellStruct current = cellAt(r, c);
-            cell = current.cell;
-            if (!cell || current.inColSpan)
+            CellStruct& current = cellAt(r, c);
+            cell = current.primaryCell();
+            ASSERT(cell || current.empty);
+            if (!cell || current.empty || current.inColSpan)
                 continue;
                 continue;
-            if (r < m_gridRows - 1 && cellAt(r + 1, c).cell == cell)
+
+            if ((cell->row() + cell->rowSpan() - 1) > r)
                 continue;
 
             int indx = max(r - cell->rowSpan() + 1, 0);
                 continue;
 
             int indx = max(r - cell->rowSpan() + 1, 0);
@@ -370,7 +381,7 @@ int RenderTableSection::calcRowHeight()
             }
         }
 
             }
         }
 
-        //do we have baseline aligned elements?
+        // do we have baseline aligned elements?
         if (baseline) {
             // increase rowheight if baseline requires
             m_rowPos[r + 1] = max(m_rowPos[r + 1], baseline + bdesc + (m_grid[r].rowRenderer ? spacing : 0));
         if (baseline) {
             // increase rowheight if baseline requires
             m_rowPos[r + 1] = max(m_rowPos[r + 1], baseline + bdesc + (m_grid[r].rowRenderer ? spacing : 0));
@@ -474,7 +485,7 @@ int RenderTableSection::layoutRows(int toAdd)
             int add = 0;
             int prev = m_rowPos[0];
             for (int r = 0; r < totalRows; r++) {
             int add = 0;
             int prev = m_rowPos[0];
             for (int r = 0; r < totalRows; r++) {
-                //weight with the original height
+                // weight with the original height
                 add += dh * (m_rowPos[r + 1] - prev) / tot;
                 prev = m_rowPos[r + 1];
                 m_rowPos[r + 1] += add;
                 add += dh * (m_rowPos[r + 1] - prev) / tot;
                 prev = m_rowPos[r + 1];
                 m_rowPos[r + 1] += add;
@@ -497,16 +508,14 @@ int RenderTableSection::layoutRows(int toAdd)
         }
 
         for (int c = 0; c < nEffCols; c++) {
         }
 
         for (int c = 0; c < nEffCols; c++) {
-            RenderTableCell* cell = cellAt(r, c).cell;
-            
-            if (!cell)
-                continue;
-            if (r < totalRows - 1 && cell == cellAt(r + 1, c).cell)
-                continue;
+            CellStruct& cs = cellAt(r, c);
+            RenderTableCell* cell = cs.primaryCell();
 
 
-            rindx = max(0, r - cell->rowSpan() + 1);
+            if (!cell || cs.empty || cs.inColSpan)
+                continue;
 
 
-            rHeight = m_rowPos[r + 1] - m_rowPos[rindx] - vspacing;
+            rindx = cell->row();
+            rHeight = m_rowPos[rindx + cell->rowSpan()] - m_rowPos[rindx] - vspacing;
             
             // Force percent height children to lay themselves out again.
             // This will cause these children to grow to fill the cell.
             
             // Force percent height children to lay themselves out again.
             // This will cause these children to grow to fill the cell.
@@ -522,8 +531,8 @@ int RenderTableSection::layoutRows(int toAdd)
             // match the behavior perfectly, but we'll continue to refine it as we discover new
             // bugs. :)
             bool cellChildrenFlex = false;
             // match the behavior perfectly, but we'll continue to refine it as we discover new
             // bugs. :)
             bool cellChildrenFlex = false;
-            bool flexAllChildren = cell->style()->height().isFixed() || 
-                (!table()->style()->height().isAuto() && rHeight != cell->height());
+            bool flexAllChildren = cell->style()->height().isFixed()
+                || (!table()->style()->height().isAuto() && rHeight != cell->height());
 
             for (RenderObject* o = cell->firstChild(); o; o = o->nextSibling()) {
                 if (!o->isText() && o->style()->height().isPercent() && (flexAllChildren || o->isReplaced() || (o->isBox() && toRenderBox(o)->scrollsOverflow()))) {
 
             for (RenderObject* o = cell->firstChild(); o; o = o->nextSibling()) {
                 if (!o->isText() && o->style()->height().isPercent() && (flexAllChildren || o->isReplaced() || (o->isBox() && toRenderBox(o)->scrollsOverflow()))) {
@@ -616,9 +625,9 @@ int RenderTableSection::layoutRows(int toAdd)
             
             IntRect oldCellRect(cell->x(), cell->y() , cell->width(), cell->height());
         
             
             IntRect oldCellRect(cell->x(), cell->y() , cell->width(), cell->height());
         
-            if (style()->direction() == RTL) {
+            if (style()->direction() == RTL)
                 cell->setLocation(table()->columnPositions()[nEffCols] - table()->columnPositions()[table()->colToEffCol(cell->col() + cell->colSpan())] + hspacing, m_rowPos[rindx]);
                 cell->setLocation(table()->columnPositions()[nEffCols] - table()->columnPositions()[table()->colToEffCol(cell->col() + cell->colSpan())] + hspacing, m_rowPos[rindx]);
-            else
+            else
                 cell->setLocation(table()->columnPositions()[c] + hspacing, m_rowPos[rindx]);
 
             // If the cell moved, we have to repaint it as well as any floating/positioned
                 cell->setLocation(table()->columnPositions()[c] + hspacing, m_rowPos[rindx]);
 
             // If the cell moved, we have to repaint it as well as any floating/positioned
@@ -640,10 +649,11 @@ int RenderTableSection::layoutRows(int toAdd)
     // Now that our height has been determined, add in overflow from cells.
     for (int r = 0; r < totalRows; r++) {
         for (int c = 0; c < nEffCols; c++) {
     // Now that our height has been determined, add in overflow from cells.
     for (int r = 0; r < totalRows; r++) {
         for (int c = 0; c < nEffCols; c++) {
-            RenderTableCell* cell = cellAt(r, c).cell;
-            if (!cell)
+            CellStruct& cs = cellAt(r, c);
+            RenderTableCell* cell = cs.primaryCell();
+            if (!cell || cs.empty || cs.inColSpan)
                 continue;
                 continue;
-            if (r < totalRows - 1 && cell == cellAt(r + 1, c).cell)
+            if (r < totalRows - 1 && cell == primaryCellAt(r + 1, c))
                 continue;
             addOverflowFromChild(cell);
             m_hasOverflowingCell |= cell->hasVisibleOverflow();
                 continue;
             addOverflowFromChild(cell);
             m_hasOverflowingCell |= cell->hasVisibleOverflow();
@@ -731,17 +741,16 @@ int RenderTableSection::calcOuterBorderTop() const
     bool allHidden = true;
     for (int c = 0; c < totalCols; c++) {
         const CellStruct& current = cellAt(0, c);
     bool allHidden = true;
     for (int c = 0; c < totalCols; c++) {
         const CellStruct& current = cellAt(0, c);
-        if (current.inColSpan || !current.cell)
+        if (current.inColSpan || !current.hasCells())
             continue;
             continue;
-        const BorderValue& cb = current.cell->style()->borderTop();
+        const BorderValue& cb = current.primaryCell()->style()->borderTop();
         // FIXME: Don't repeat for the same col group
         RenderTableCol* colGroup = table()->colElement(c);
         if (colGroup) {
             const BorderValue& gb = colGroup->style()->borderTop();
             if (gb.style() == BHIDDEN || cb.style() == BHIDDEN)
                 continue;
         // FIXME: Don't repeat for the same col group
         RenderTableCol* colGroup = table()->colElement(c);
         if (colGroup) {
             const BorderValue& gb = colGroup->style()->borderTop();
             if (gb.style() == BHIDDEN || cb.style() == BHIDDEN)
                 continue;
-            else
-                allHidden = false;
+            allHidden = false;
             if (gb.style() > BHIDDEN && gb.width() > borderWidth)
                 borderWidth = gb.width();
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             if (gb.style() > BHIDDEN && gb.width() > borderWidth)
                 borderWidth = gb.width();
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
@@ -749,8 +758,7 @@ int RenderTableSection::calcOuterBorderTop() const
         } else {
             if (cb.style() == BHIDDEN)
                 continue;
         } else {
             if (cb.style() == BHIDDEN)
                 continue;
-            else
-                allHidden = false;
+            allHidden = false;
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
                 borderWidth = cb.width();
         }
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
                 borderWidth = cb.width();
         }
@@ -784,17 +792,16 @@ int RenderTableSection::calcOuterBorderBottom() const
     bool allHidden = true;
     for (int c = 0; c < totalCols; c++) {
         const CellStruct& current = cellAt(m_gridRows - 1, c);
     bool allHidden = true;
     for (int c = 0; c < totalCols; c++) {
         const CellStruct& current = cellAt(m_gridRows - 1, c);
-        if (current.inColSpan || !current.cell)
+        if (current.inColSpan || !current.hasCells())
             continue;
             continue;
-        const BorderValue& cb = current.cell->style()->borderBottom();
+        const BorderValue& cb = current.primaryCell()->style()->borderBottom();
         // FIXME: Don't repeat for the same col group
         RenderTableCol* colGroup = table()->colElement(c);
         if (colGroup) {
             const BorderValue& gb = colGroup->style()->borderBottom();
             if (gb.style() == BHIDDEN || cb.style() == BHIDDEN)
                 continue;
         // FIXME: Don't repeat for the same col group
         RenderTableCol* colGroup = table()->colElement(c);
         if (colGroup) {
             const BorderValue& gb = colGroup->style()->borderBottom();
             if (gb.style() == BHIDDEN || cb.style() == BHIDDEN)
                 continue;
-            else
-                allHidden = false;
+            allHidden = false;
             if (gb.style() > BHIDDEN && gb.width() > borderWidth)
                 borderWidth = gb.width();
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             if (gb.style() > BHIDDEN && gb.width() > borderWidth)
                 borderWidth = gb.width();
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
@@ -802,8 +809,7 @@ int RenderTableSection::calcOuterBorderBottom() const
         } else {
             if (cb.style() == BHIDDEN)
                 continue;
         } else {
             if (cb.style() == BHIDDEN)
                 continue;
-            else
-                allHidden = false;
+            allHidden = false;
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
                 borderWidth = cb.width();
         }
             if (cb.style() > BHIDDEN && cb.width() > borderWidth)
                 borderWidth = cb.width();
         }
@@ -841,15 +847,14 @@ int RenderTableSection::calcOuterBorderLeft(bool rtl) const
     bool allHidden = true;
     for (int r = 0; r < m_gridRows; r++) {
         const CellStruct& current = cellAt(r, leftmostColumn);
     bool allHidden = true;
     for (int r = 0; r < m_gridRows; r++) {
         const CellStruct& current = cellAt(r, leftmostColumn);
-        if (!current.cell)
+        if (!current.hasCells())
             continue;
         // FIXME: Don't repeat for the same cell
             continue;
         // FIXME: Don't repeat for the same cell
-        const BorderValue& cb = current.cell->style()->borderLeft();
-        const BorderValue& rb = current.cell->parent()->style()->borderLeft();
+        const BorderValue& cb = current.primaryCell()->style()->borderLeft();
+        const BorderValue& rb = current.primaryCell()->parent()->style()->borderLeft();
         if (cb.style() == BHIDDEN || rb.style() == BHIDDEN)
             continue;
         if (cb.style() == BHIDDEN || rb.style() == BHIDDEN)
             continue;
-        else
-            allHidden = false;
+        allHidden = false;
         if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             borderWidth = cb.width();
         if (rb.style() > BHIDDEN && rb.width() > borderWidth)
         if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             borderWidth = cb.width();
         if (rb.style() > BHIDDEN && rb.width() > borderWidth)
@@ -888,15 +893,14 @@ int RenderTableSection::calcOuterBorderRight(bool rtl) const
     bool allHidden = true;
     for (int r = 0; r < m_gridRows; r++) {
         const CellStruct& current = cellAt(r, rightmostColumn);
     bool allHidden = true;
     for (int r = 0; r < m_gridRows; r++) {
         const CellStruct& current = cellAt(r, rightmostColumn);
-        if (!current.cell)
+        if (!current.hasCells())
             continue;
         // FIXME: Don't repeat for the same cell
             continue;
         // FIXME: Don't repeat for the same cell
-        const BorderValue& cb = current.cell->style()->borderRight();
-        const BorderValue& rb = current.cell->parent()->style()->borderRight();
+        const BorderValue& cb = current.primaryCell()->style()->borderRight();
+        const BorderValue& rb = current.primaryCell()->parent()->style()->borderRight();
         if (cb.style() == BHIDDEN || rb.style() == BHIDDEN)
             continue;
         if (cb.style() == BHIDDEN || rb.style() == BHIDDEN)
             continue;
-        else
-            allHidden = false;
+        allHidden = false;
         if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             borderWidth = cb.width();
         if (rb.style() > BHIDDEN && rb.width() > borderWidth)
         if (cb.style() > BHIDDEN && cb.width() > borderWidth)
             borderWidth = cb.width();
         if (rb.style() > BHIDDEN && rb.width() > borderWidth)
@@ -929,7 +933,8 @@ int RenderTableSection::firstLineBoxBaseline() const
     firstLineBaseline = -1;
     Row* firstRow = m_grid[0].row;
     for (size_t i = 0; i < firstRow->size(); ++i) {
     firstLineBaseline = -1;
     Row* firstRow = m_grid[0].row;
     for (size_t i = 0; i < firstRow->size(); ++i) {
-        RenderTableCell* cell = firstRow->at(i).cell;
+        CellStruct& cs = firstRow->at(i);
+        RenderTableCell* cell = cs.primaryCell();
         if (cell)
             firstLineBaseline = max(firstLineBaseline, cell->y() + cell->paddingTop() + cell->borderTop() + cell->contentHeight());
     }
         if (cell)
             firstLineBaseline = max(firstLineBaseline, cell->y() + cell->paddingTop() + cell->borderTop() + cell->contentHeight());
     }
@@ -961,6 +966,45 @@ void RenderTableSection::paint(PaintInfo& paintInfo, int tx, int ty)
         popContentsClip(paintInfo, phase, tx, ty);
 }
 
         popContentsClip(paintInfo, phase, tx, ty);
 }
 
+static inline bool compareCellPositions(RenderTableCell* elem1, RenderTableCell* elem2)
+{
+    return elem1->row() < elem2->row();
+}
+
+void RenderTableSection::paintCell(RenderTableCell* cell, PaintInfo& paintInfo, int tx, int ty)
+{
+    PaintPhase paintPhase = paintInfo.phase;
+    RenderTableRow* row = toRenderTableRow(cell->parent());
+
+    if (paintPhase == PaintPhaseBlockBackground || paintPhase == PaintPhaseChildBlockBackground) {
+        // We need to handle painting a stack of backgrounds.  This stack (from bottom to top) consists of
+        // the column group, column, row group, row, and then the cell.
+        RenderObject* col = table()->colElement(cell->col());
+        RenderObject* colGroup = 0;
+        if (col && col->parent()->style()->display() == TABLE_COLUMN_GROUP)
+            colGroup = col->parent();
+
+        // Column groups and columns first.
+        // FIXME: Columns and column groups do not currently support opacity, and they are being painted "too late" in
+        // the stack, since we have already opened a transparency layer (potentially) for the table row group.
+        // Note that we deliberately ignore whether or not the cell has a layer, since these backgrounds paint "behind" the
+        // cell.
+        cell->paintBackgroundsBehindCell(paintInfo, tx, ty, colGroup);
+        cell->paintBackgroundsBehindCell(paintInfo, tx, ty, col);
+
+        // Paint the row group next.
+        cell->paintBackgroundsBehindCell(paintInfo, tx, ty, this);
+
+        // Paint the row next, but only if it doesn't have a layer.  If a row has a layer, it will be responsible for
+        // painting the row background for the cell.
+        if (!row->hasSelfPaintingLayer())
+            cell->paintBackgroundsBehindCell(paintInfo, tx, ty, row);
+    }
+    if ((!cell->hasSelfPaintingLayer() && !row->hasSelfPaintingLayer()) || paintInfo.phase == PaintPhaseCollapsedTableBorders)
+        cell->paint(paintInfo, tx, ty);
+
+}
+
 void RenderTableSection::paintObject(PaintInfo& paintInfo, int tx, int ty)
 {
     // Check which rows and cols are visible and only paint these.
 void RenderTableSection::paintObject(PaintInfo& paintInfo, int tx, int ty)
 {
     // Check which rows and cols are visible and only paint these.
@@ -1013,54 +1057,43 @@ void RenderTableSection::paintObject(PaintInfo& paintInfo, int tx, int ty)
         if (!endcol && tx + table()->columnPositions()[0] - table()->outerBorderLeft() <= y + w + os)
             endcol++;
     }
         if (!endcol && tx + table()->columnPositions()[0] - table()->outerBorderLeft() <= y + w + os)
             endcol++;
     }
-
     if (startcol < endcol) {
     if (startcol < endcol) {
-        // draw the cells
-        for (unsigned r = startrow; r < endrow; r++) {
-            unsigned c = startcol;
-            // since a cell can be -1 (indicating a colspan) we might have to search backwards to include it
-            while (c && cellAt(r, c).inColSpan)
-                c--;
-            for (; c < endcol; c++) {
-                CellStruct current = cellAt(r, c);
-                RenderTableCell* cell = current.cell;
-                    
-                // Cells must always paint in the order in which they appear taking into account
-                // their upper left originating row/column.  For cells with rowspans, avoid repainting
-                // if we've already seen the cell.
-                if (!cell || (r > startrow && (cellAt(r - 1, c).cell == cell)))
-                    continue;
-
-                RenderTableRow* row = toRenderTableRow(cell->parent());
-
-                if (paintPhase == PaintPhaseBlockBackground || paintPhase == PaintPhaseChildBlockBackground) {
-                    // We need to handle painting a stack of backgrounds.  This stack (from bottom to top) consists of
-                    // the column group, column, row group, row, and then the cell.
-                    RenderObject* col = table()->colElement(c);
-                    RenderObject* colGroup = 0;
-                    if (col && col->parent()->style()->display() == TABLE_COLUMN_GROUP)
-                        colGroup = col->parent();
-
-                    // Column groups and columns first.
-                    // FIXME: Columns and column groups do not currently support opacity, and they are being painted "too late" in
-                    // the stack, since we have already opened a transparency layer (potentially) for the table row group.
-                    // Note that we deliberately ignore whether or not the cell has a layer, since these backgrounds paint "behind" the
-                    // cell.
-                    cell->paintBackgroundsBehindCell(paintInfo, tx, ty, colGroup);
-                    cell->paintBackgroundsBehindCell(paintInfo, tx, ty, col);
-
-                    // Paint the row group next.
-                    cell->paintBackgroundsBehindCell(paintInfo, tx, ty, this);
-
-                    // Paint the row next, but only if it doesn't have a layer.  If a row has a layer, it will be responsible for
-                    // painting the row background for the cell.
-                    if (!row->hasSelfPaintingLayer())
-                        cell->paintBackgroundsBehindCell(paintInfo, tx, ty, row);
+        if (!m_hasMultipleCellLevels) {
+            // Draw the dirty cells in the order that they appear.
+            for (unsigned r = startrow; r < endrow; r++) {
+                for (unsigned c = startcol; c < endcol; c++) {
+                    CellStruct& current = cellAt(r, c);
+                    RenderTableCell* cell = current.primaryCell();
+                    if (current.empty || (r > startrow && primaryCellAt(r - 1, c) == cell) || (c > startcol && primaryCellAt(r, c - 1) == cell))
+                        continue;
+                    paintCell(cell, paintInfo, tx, ty);
                 }
                 }
-
-                if ((!cell->hasSelfPaintingLayer() && !row->hasSelfPaintingLayer()) || paintInfo.phase == PaintPhaseCollapsedTableBorders)
-                    cell->paint(paintInfo, tx, ty);
             }
             }
+        } else {
+            // Draw the cells in the correct paint order.
+            Vector<RenderTableCell*> cells;
+            HashSet<RenderTableCell*> spanningCells;
+            for (unsigned r = startrow; r < endrow; r++) {
+                for (unsigned c = startcol; c < endcol; c++) {
+                    CellStruct& current = cellAt(r, c);
+                    if (current.empty)
+                        continue;
+                    for (unsigned i = 0; i < current.cells.size(); ++i) {
+                        if (current.cells[i]->rowSpan() > 1 || current.cells[i]->colSpan() > 1) {
+                            if (spanningCells.contains(current.cells[i]))
+                                continue;
+                            spanningCells.add(current.cells[i]);
+                        }
+                        cells.append(current.cells[i]);
+                    }
+                }
+            }
+            // Sort the dirty cells by paint order.
+            std::stable_sort(cells.begin(), cells.end(), compareCellPositions);
+            int size = cells.size();
+            // Paint the cells.
+            for (int i = 0; i < size; ++i)
+                paintCell(cells[i], paintInfo, tx, ty);
         }
     }
 }
         }
     }
 }
@@ -1113,7 +1146,7 @@ int RenderTableSection::numColumns() const
     for (int r = 0; r < m_gridRows; ++r) {
         for (int c = result; c < table()->numEffCols(); ++c) {
             const CellStruct& cell = cellAt(r, c);
     for (int r = 0; r < m_gridRows; ++r) {
         for (int c = result; c < table()->numEffCols(); ++c) {
             const CellStruct& cell = cellAt(r, c);
-            if (cell.cell || cell.inColSpan)
+            if (cell.hasCells() || cell.inColSpan)
                 result = c;
         }
     }
                 result = c;
         }
     }
@@ -1126,21 +1159,31 @@ void RenderTableSection::appendColumn(int pos)
     for (int row = 0; row < m_gridRows; ++row) {
         m_grid[row].row->resize(pos + 1);
         CellStruct& c = cellAt(row, pos);
     for (int row = 0; row < m_gridRows; ++row) {
         m_grid[row].row->resize(pos + 1);
         CellStruct& c = cellAt(row, pos);
-        c.cell = 0;
         c.inColSpan = false;
         c.inColSpan = false;
+        c.empty = false;
     }
 }
 
     }
 }
 
-void RenderTableSection::splitColumn(int pos, int newSize)
+void RenderTableSection::splitColumn(int pos, int first)
 {
     if (m_cCol > pos)
         m_cCol++;
     for (int row = 0; row < m_gridRows; ++row) {
 {
     if (m_cCol > pos)
         m_cCol++;
     for (int row = 0; row < m_gridRows; ++row) {
-        m_grid[row].row->resize(newSize);
         Row& r = *m_grid[row].row;
         Row& r = *m_grid[row].row;
-        memmove(r.data() + pos + 1, r.data() + pos, (newSize - 1 - pos) * sizeof(CellStruct));
-        r[pos + 1].cell = 0;
-        r[pos + 1].inColSpan = r[pos].inColSpan || r[pos].cell;
+        r.insert(pos + 1, CellStruct());
+        if (r[pos].hasCells()) {
+            r[pos + 1].cells.append(r[pos].cells);
+            RenderTableCell* cell = r[pos].primaryCell();
+            ASSERT(cell);
+            int colleft = cell->colSpan() - r[pos].inColSpan;
+            if (first > colleft)
+              r[pos + 1].inColSpan = 0;
+            else
+              r[pos + 1].inColSpan = first + r[pos].inColSpan;
+        } else {
+            r[pos + 1].inColSpan = 0;
+        }
+        r[pos + 1].empty = false;
     }
 }
 
     }
 }
 
@@ -1165,7 +1208,6 @@ bool RenderTableSection::nodeAtPoint(const HitTestRequest& request, HitTestResul
             return true;
         }
     }
             return true;
         }
     }
-    
     return false;
 }
 
     return false;
 }
 
index 9f6d5ea..e3c09bc 100644 (file)
@@ -54,8 +54,30 @@ public:
     RenderTable* table() const { return toRenderTable(parent()); }
 
     struct CellStruct {
     RenderTable* table() const { return toRenderTable(parent()); }
 
     struct CellStruct {
-        RenderTableCell* cell;
+        Vector<RenderTableCell*, 1> cells; 
         bool inColSpan; // true for columns after the first in a colspan
         bool inColSpan; // true for columns after the first in a colspan
+        bool empty;
+
+        CellStruct():
+          inColSpan(false),
+          empty(false) {}
+
+        CellStruct(const CellStruct& other):
+            cells(other.cells),
+            inColSpan(other.inColSpan),
+            empty(other.empty) {}
+        
+        RenderTableCell* primaryCell()
+        {
+            return hasCells() ? cells[cells.size() - 1] : 0;
+        }
+
+        const RenderTableCell* primaryCell() const
+        {
+            return hasCells() ? cells[cells.size() - 1] : 0;
+        }
+
+        bool hasCells() const { return cells.size() > 0; }
     };
 
     typedef Vector<CellStruct> Row;
     };
 
     typedef Vector<CellStruct> Row;
@@ -69,9 +91,14 @@ public:
 
     CellStruct& cellAt(int row,  int col) { return (*m_grid[row].row)[col]; }
     const CellStruct& cellAt(int row, int col) const { return (*m_grid[row].row)[col]; }
 
     CellStruct& cellAt(int row,  int col) { return (*m_grid[row].row)[col]; }
     const CellStruct& cellAt(int row, int col) const { return (*m_grid[row].row)[col]; }
+    RenderTableCell* primaryCellAt(int row, int col)
+    {
+        CellStruct& c = (*m_grid[row].row)[col];
+        return c.primaryCell();
+    }
 
     void appendColumn(int pos);
 
     void appendColumn(int pos);
-    void splitColumn(int pos, int newSize);
+    void splitColumn(int pos, int first);
 
     int calcOuterBorderTop() const;
     int calcOuterBorderBottom() const;
 
     int calcOuterBorderTop() const;
     int calcOuterBorderBottom() const;
@@ -121,6 +148,7 @@ private:
     virtual int leftmostPosition(bool includeOverflowInterior, bool includeSelf) const;
 
     virtual void paint(PaintInfo&, int tx, int ty);
     virtual int leftmostPosition(bool includeOverflowInterior, bool includeSelf) const;
 
     virtual void paint(PaintInfo&, int tx, int ty);
+    virtual void paintCell(RenderTableCell*, PaintInfo&, int tx, int ty);
     virtual void paintObject(PaintInfo&, int tx, int ty);
 
     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
     virtual void paintObject(PaintInfo&, int tx, int ty);
 
     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
@@ -150,6 +178,8 @@ private:
 
     bool m_needsCellRecalc;
     bool m_hasOverflowingCell;
 
     bool m_needsCellRecalc;
     bool m_hasOverflowingCell;
+
+    bool m_hasMultipleCellLevels;
 };
 
 inline RenderTableSection* toRenderTableSection(RenderObject* object)
 };
 
 inline RenderTableSection* toRenderTableSection(RenderObject* object)