Table cell background painting

third_party/WebKit/Source/core/layout/LayoutTableCol.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 92 matching lines @@
 
 bool LayoutTableCol::canHaveChildren() const
 {
     // Cols cannot have children. This is actually necessary to fix a bug
     // with libraries.uc.edu, which makes a <p> be a table-column.
     return isTableColumnGroup();
 }
 
 LayoutRect LayoutTableCol::clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
-    // For now, just paint invalidate the whole table.
-    // FIXME: Find a better way to do this, e.g., need to paint invalidate all the cells that we
-    // might have propagated a background color or borders into.
-    // FIXME: check for paintInvalidationContainer each time here?
-
-    LayoutTable* parentTable = table();
-    if (!parentTable)
-        return LayoutRect();
-    return parentTable->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationState);
+    LayoutRect r = positionByCellSpan();
+    mapToVisibleRectInAncestorSpace(paintInvalidationContainer, r, paintInvalidationState);
+    return r;
 }
 
 void LayoutTableCol::imageChanged(WrappedImagePtr, const IntRect*)
 {
     // FIXME: Issue paint invalidation of only the rect the image paints in.
-    setShouldDoFullPaintInvalidation();
+    // INVALIDATE ALL THE CHILDREN
+
+    // This does not work, background does not paint
+    // table()->setShouldDoFullPaintInvalidation(PaintInvalidationFull);
+    // This ends up with nothing being painted at all
+    // setShouldDoFullPaintInvalidation();

[Xianzhu, 2016/02/23 22:58:27]

Why doesn't the logic in LayoutTable::invalidatePaintOfSubtreesIfNeeded() work
for the case?

[atotic1, 2016/03/15 16:50:47]

We do not call invalidatePaintOfSubtreesIfNeeded from here, I did not know about
that call. Looking at it, it does something similar, invalidating every cell in
the table instead of every cell in the column. We could use that instead,
slightly less efficient. What would you like to do? 

+    Vector<LayoutTableCell*> cells = getColumnCells();
+    for (auto c = cells.begin(); c != cells.end(); c++)
+        (*c)->setShouldDoFullPaintInvalidation();
 }
 
 void LayoutTableCol::clearPreferredLogicalWidthsDirtyBits()
 {
     clearPreferredLogicalWidthsDirty();
 
     for (LayoutObject* child = firstChild(); child; child = child->nextSibling())
         child->clearPreferredLogicalWidthsDirty();
 }
 
 LayoutTable* LayoutTableCol::table() const
 {
     LayoutObject* table = parent();
     if (table && !table->isTable())
         table = table->parent();
     return table && table->isTable() ? toLayoutTable(table) : nullptr;
 }
 
 LayoutTableCol* LayoutTableCol::enclosingColumnGroup() const
 {
     if (!parent()->isLayoutTableCol())
         return nullptr;
 
     LayoutTableCol* parentColumnGroup = toLayoutTableCol(parent());
     ASSERT(parentColumnGroup->isTableColumnGroup());
     ASSERT(isTableColumn());
     return parentColumnGroup;
 }
 
+LayoutTableCol * LayoutTableCol::lastColumnInGroup() const
+{
+    ASSERT(this->isTableColumnGroup());
+
+    LayoutTableCol * endCol = 0;
+    LayoutTableCol * currentCol = this->nextColumn();
+    // if column has children, traverse the children to find last
+    if (this->firstChild()) {
+        while (currentCol && currentCol->enclosingColumnGroup() == this) {
+            endCol = currentCol;
+            currentCol = currentCol->nextColumn();
+        }
+    } else { // otherwise, if we have span, use that to find next child
+        auto span = this->span();
+        endCol = currentCol;
+        while (--span > 0 && currentCol) {
+            currentCol = currentCol->nextColumn();
+            endCol = currentCol;
+        }
+    }
+    return endCol;
+}
+
 LayoutTableCol* LayoutTableCol::nextColumn() const
 {
     // If |this| is a column-group, the next column is the colgroup's first child column.
     if (LayoutObject* firstChild = this->firstChild())
         return toLayoutTableCol(firstChild);
 
     // Otherwise it's the next column along.
     LayoutObject* next = nextSibling();
 
     // Failing that, the child is the last column in a column-group, so the next column is the next column/column-group after its column-group.
-    if (!next && parent()->isLayoutTableCol())
-        next = parent()->nextSibling();
+
+    auto p = parent();
+    if (!next && p && p->isLayoutTableCol())

[Xianzhu, 2016/02/23 22:58:27]

Can parent() be null?

[atotic1, 2016/03/15 16:50:47]

Yes, seen it live when restoring from history.

+        next = p->nextSibling();
 
     for (; next && !next->isLayoutTableCol(); next = next->nextSibling()) { }
 
     return toLayoutTableCol(next);
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellStartBorder(const LayoutTableCell*) const
 {
     return style()->borderStart();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellEndBorder(const LayoutTableCell*) const
 {
     return style()->borderEnd();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellBefore(const LayoutTableCell* cell) const
 {
     ASSERT_UNUSED(cell, table()->colElement(cell->col() + cell->colSpan()).innermostColOrColGroup() == this);
     return style()->borderStart();
 }
 
 const BorderValue& LayoutTableCol::borderAdjoiningCellAfter(const LayoutTableCell* cell) const
 {
     ASSERT_UNUSED(cell, table()->colElement(cell->col() - 1).innermostColOrColGroup() == this);
     return style()->borderEnd();
 }
 
+// computes col/colgroup position that only spans cells
+LayoutRect LayoutTableCol::positionByCellSpan() const
+{
+
+    LayoutTable * myTable = table();
+    LayoutRect position;
+
+    if (!myTable)
+        return position;
+
+    LayoutTableSection* topSection = myTable->topNonEmptySection();
+    LayoutTableSection* bottomSection = myTable->bottomNonEmptySection();
+    if (!topSection || !bottomSection)
+        return position;
+
+    unsigned startColumnIndex;
+    unsigned endColumnIndex;
+
+    if (isTableColumnGroup()) {
+        // colgroup position
+        LayoutTableCol * startColumn = nextColumn();
+        LayoutTableCol * endColumn = lastColumnInGroup();
+
+        if (startColumn && endColumn) {
+            startColumnIndex = myTable->colElementToCol(startColumn);
+            endColumnIndex = myTable->colElementToCol(endColumn);
+        } else {
+            return position;
+        }
+    } else {
+        // col position
+        startColumnIndex = myTable->colElementToCol(this);
+        endColumnIndex = std::min(startColumnIndex + span() - 1, bottomSection->numColumns() - 1);
+    }
+
+    position = topSection->positionOfIdealCell(0, startColumnIndex);
+    position.moveBy(topSection->location());
+    LayoutRect bottomPosition = bottomSection->positionOfIdealCell(bottomSection->numRows() - 1, endColumnIndex);
+    bottomPosition.moveBy(bottomSection->location());
+    position.unite(bottomPosition);
+    return position;
+}
+
+// returns indexes to all columns that span this column
+Vector<unsigned> LayoutTableCol::getColumnIndexes() const
+{
+    LayoutTable * myTable = table();
+    Vector<unsigned> indexes;
+    if (isTableColumn()) {
+        unsigned idx = myTable->colElementToCol(this);
+        auto span = this->span();
+        while (span--)
+            indexes.append(idx++);
+    } else {
+        // isTableColumnGroup
+        LayoutTableCol* currentCol = nullptr;
+        auto lastCol = lastColumnInGroup();
+        do {
+            currentCol = currentCol ? currentCol->nextColumn() : nextColumn();
+            if (currentCol) {
+                auto colIndexes = currentCol->getColumnIndexes();
+                for (auto c = colIndexes.begin(); c != colIndexes.end(); c++)
+                    indexes.append(*c);
+            }
+        } while (currentCol && currentCol != lastCol);
+    }
+    return indexes;
+}
+
+// returns all cells inside a column
+Vector<LayoutTableCell*> LayoutTableCol::getColumnCells() const
+{
+    // enumerate all the columns we need
+    LayoutTable * myTable = table();
+    Vector<LayoutTableCell*> cells;
+
+    if (!myTable) // can't do this before table is laid out
+        return cells;
+
+    auto colIndexes = getColumnIndexes();
+    auto section = myTable->topSection();
+    // Get all cells from all columns
+    while (section) {
+        for (auto c = colIndexes.begin(); c != colIndexes.end(); c++) {
+            for (unsigned r = 0; r < section->numRows(); r++)  {
+                LayoutTableCell * cell = section->primaryCellAt(r, *c);
+                if (cell && cell->hasCol() && cell->col() == *c)
+                    cells.append(cell);
+            }
+        }
+        section = myTable->sectionBelow(section, SkipEmptySections);
+    }
+    return cells;
+}
+
 } // namespace blink