1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
// 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 "config.h"
#include "core/paint/GridPainter.h"
#include "core/rendering/PaintInfo.h"
#include "core/rendering/RenderGrid.h"
namespace blink {
static GridSpan dirtiedGridAreas(const Vector<LayoutUnit>& coordinates, LayoutUnit start, LayoutUnit end)
{
// This function does a binary search over the coordinates.
// This doesn't work with grid items overflowing their grid areas, but that is managed with m_gridItemsOverflowingGridArea.
size_t startGridAreaIndex = std::upper_bound(coordinates.begin(), coordinates.end() - 1, start) - coordinates.begin();
if (startGridAreaIndex > 0)
--startGridAreaIndex;
size_t endGridAreaIndex = std::upper_bound(coordinates.begin() + startGridAreaIndex, coordinates.end() - 1, end) - coordinates.begin();
if (endGridAreaIndex > 0)
--endGridAreaIndex;
return GridSpan(startGridAreaIndex, endGridAreaIndex);
}
class GridItemsSorter {
public:
bool operator()(const std::pair<RenderBox*, size_t>& firstChild, const std::pair<RenderBox*, size_t>& secondChild) const
{
if (firstChild.first->style()->order() != secondChild.first->style()->order())
return firstChild.first->style()->order() < secondChild.first->style()->order();
return firstChild.second < secondChild.second;
}
};
void GridPainter::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
ASSERT_WITH_SECURITY_IMPLICATION(!m_renderGrid.gridIsDirty());
LayoutRect localPaintInvalidationRect = paintInfo.rect;
localPaintInvalidationRect.moveBy(-paintOffset);
GridSpan dirtiedColumns = dirtiedGridAreas(m_renderGrid.columnPositions(), localPaintInvalidationRect.x(), localPaintInvalidationRect.maxX());
GridSpan dirtiedRows = dirtiedGridAreas(m_renderGrid.rowPositions(), localPaintInvalidationRect.y(), localPaintInvalidationRect.maxY());
Vector<std::pair<RenderBox*, size_t> > gridItemsToBePainted;
for (GridSpan::iterator row = dirtiedRows.begin(); row != dirtiedRows.end(); ++row) {
for (GridSpan::iterator column = dirtiedColumns.begin(); column != dirtiedColumns.end(); ++column) {
const Vector<RenderBox*, 1>& children = m_renderGrid.gridCell(row.toInt(), column.toInt());
for (auto* child : children)
gridItemsToBePainted.append(std::make_pair(child, m_renderGrid.paintIndexForGridItem(child)));
}
}
for (auto* item: m_renderGrid.itemsOverflowingGridArea()) {
if (item->frameRect().intersects(localPaintInvalidationRect))
gridItemsToBePainted.append(std::make_pair(item, m_renderGrid.paintIndexForGridItem(item)));
}
// Sort grid items following order-modified document order.
// See http://www.w3.org/TR/css-flexbox/#order-modified-document-order
std::stable_sort(gridItemsToBePainted.begin(), gridItemsToBePainted.end(), GridItemsSorter());
RenderBox* previous = 0;
for (const auto& gridItemAndPaintIndex : gridItemsToBePainted) {
// We might have duplicates because of spanning children are included in all cells they span.
// Skip them here to avoid painting items several times.
RenderBox* current = gridItemAndPaintIndex.first;
if (current == previous)
continue;
paintChild(*current, paintInfo, paintOffset);
previous = current;
}
}
void GridPainter::paintChild(RenderBox& child, const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
LayoutPoint childPoint = m_renderGrid.flipForWritingModeForChild(&child, paintOffset);
if (!child.hasSelfPaintingLayer() && !child.isFloating())
child.paint(paintInfo, childPoint);
}
} // namespace blink
|
