Display table header groups at the top of each page

third_party/WebKit/Source/core/paint/TableSectionPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/paint/BoxClipper.h"
@@ skipping 17 matching lines @@
         return nullptr;
     // We have painted (row, column) when painting (row - 1, column).
     if (row > dirtiedRows.start() && m_layoutTableSection.primaryCellAt(row - 1, column) == cell)
         return nullptr;
     // We have painted (row, column) when painting (row, column -1).
     if (column > dirtiedColumns.start() && m_layoutTableSection.primaryCellAt(row, column - 1) == cell)
         return nullptr;
     return cell;
 }
 
+void TableSectionPainter::paintRepeatingHeaderGroup(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const CollapsedBorderValue& currentBorderValue, ItemToPaint itemToPaint)
+{
+    if (m_layoutTableSection.getPaginationBreakability() == LayoutBox::AllowAnyBreaks)
+        return;
+    // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?
+    if (m_layoutTableSection.hasSelfPaintingLayer())
+        return;
+    LayoutTable* table = m_layoutTableSection.table();
+    LayoutUnit pageHeight = table->pageLogicalHeightForOffset(LayoutUnit());
+    if (!pageHeight)
+        return;
+
+    LayoutPoint paginationOffset = paintOffset;
+    // Move paginationOffset to the top of the second page.
+    paginationOffset.move(0, pageHeight - table->pageLogicalOffset());
+    // Now move paginationOffset to the top of the page the cull rect starts on.
+    if (paintInfo.cullRect().m_rect.y() > paginationOffset.y())
+        paginationOffset.move(0, pageHeight * static_cast<int>((paintInfo.cullRect().m_rect.y() - paginationOffset.y()) / pageHeight));
+    LayoutUnit bottomBound = std::min(LayoutUnit(paintInfo.cullRect().m_rect.maxY()), paintOffset.y() + table->logicalHeight());
+    while (paginationOffset.y() < bottomBound) {
+        if (itemToPaint == PaintCollapsedBorders)
+            paintCollapsedSectionBorders(paintInfo, paginationOffset, currentBorderValue);
+        else
+            paintSection(paintInfo, paginationOffset);
+        paginationOffset.move(0, pageHeight);
+    }
+}
+
 void TableSectionPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
+    paintSection(paintInfo, paintOffset);
+    LayoutTable* table = m_layoutTableSection.table();
+    if (table->header() == m_layoutTableSection)
+        paintRepeatingHeaderGroup(paintInfo, paintOffset, CollapsedBorderValue(), PaintSection);
+}
+
+void TableSectionPainter::paintSection(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
     DCHECK(!m_layoutTableSection.needsLayout());
     // avoid crashing on bugs that cause us to paint with dirty layout
     if (m_layoutTableSection.needsLayout())
         return;
 
     unsigned totalRows = m_layoutTableSection.numRows();
     unsigned totalCols = m_layoutTableSection.table()->numEffectiveColumns();
 
     if (!totalRows || !totalCols)
         return;
@@ skipping 21 matching lines @@
 static inline bool compareCellPositionsWithOverflowingCells(LayoutTableCell* elem1, LayoutTableCell* elem2)
 {
     if (elem1->rowIndex() != elem2->rowIndex())
         return elem1->rowIndex() < elem2->rowIndex();
 
     return elem1->absoluteColumnIndex() < elem2->absoluteColumnIndex();
 }
 
 void TableSectionPainter::paintCollapsedBorders(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const CollapsedBorderValue& currentBorderValue)
 {
+    paintCollapsedSectionBorders(paintInfo, paintOffset, currentBorderValue);
+    LayoutTable* table = m_layoutTableSection.table();
+    if (table->header() == m_layoutTableSection)
+        paintRepeatingHeaderGroup(paintInfo, paintOffset, currentBorderValue, PaintCollapsedBorders);
+}
+
+void TableSectionPainter::paintCollapsedSectionBorders(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const CollapsedBorderValue& currentBorderValue)
+{
     if (!m_layoutTableSection.numRows() || !m_layoutTableSection.table()->effectiveColumns().size())
         return;
 
     LayoutPoint adjustedPaintOffset = paintOffset + m_layoutTableSection.location();
     BoxClipper boxClipper(m_layoutTableSection, paintInfo, adjustedPaintOffset, ForceContentsClip);
 
     LayoutRect localPaintInvalidationRect = LayoutRect(paintInfo.cullRect().m_rect);
     localPaintInvalidationRect.moveBy(-adjustedPaintOffset);
 
     LayoutRect tableAlignedRect = m_layoutTableSection.logicalRectForWritingModeAndDirection(localPaintInvalidationRect);
@@ skipping 163 matching lines @@
     DisplayItem::Type type = shadowStyle == Normal ? DisplayItem::TableSectionBoxShadowNormal : DisplayItem::TableSectionBoxShadowInset;
     if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutTableSection, type))
         return;
 
     LayoutRect bounds = BoxPainter(m_layoutTableSection).boundsForDrawingRecorder(paintOffset);
     LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutTableSection, type, bounds);
     BoxPainter::paintBoxShadow(paintInfo, LayoutRect(paintOffset, m_layoutTableSection.size()), m_layoutTableSection.styleRef(), shadowStyle);
 }
 
 } // namespace blink