void TiledBackingStore::removeAllNonVisibleTiles()
{
dropTilesOutsideRect(visibleContentsRect());
}
void TiledDrawingAreaProxy::createTiles()
{
IntRect visibleRect = mapFromContents(webViewVisibleRect());
m_previousVisibleRect = visibleRect;
if (visibleRect.isEmpty())
return;
// Resize tiles on edges in case the contents size has changed.
bool didResizeTiles = resizeEdgeTiles();
// Remove tiles outside out current maximum keep rect.
dropTilesOutsideRect(calculateKeepRect(visibleRect));
// Cover the cover rect with tiles.
IntRect coverRect = calculateCoverRect(visibleRect);
// Search for the tile position closest to the viewport center that does not yet contain a tile.
// Which position is considered the closest depends on the tileDistance function.
double shortestDistance = std::numeric_limits<double>::infinity();
Vector<TiledDrawingAreaTile::Coordinate> tilesToCreate;
unsigned requiredTileCount = 0;
bool hasVisibleCheckers = false;
TiledDrawingAreaTile::Coordinate topLeft = tileCoordinateForPoint(coverRect.topLeft());
TiledDrawingAreaTile::Coordinate bottomRight = tileCoordinateForPoint(coverRect.bottomRight());
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
TiledDrawingAreaTile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
// Distance is 0 for all currently visible tiles.
double distance = tileDistance(visibleRect, currentCoordinate);
RefPtr<TiledDrawingAreaTile> tile = tileAt(currentCoordinate);
if (!distance && (!tile || !tile->isReadyToPaint()))
hasVisibleCheckers = true;
if (tile)
continue;
++requiredTileCount;
if (distance > shortestDistance)
continue;
if (distance < shortestDistance) {
tilesToCreate.clear();
shortestDistance = distance;
}
tilesToCreate.append(currentCoordinate);
}
}
if (hasVisibleCheckers && shortestDistance > 0)
return;
// Now construct the tile(s).
unsigned tilesToCreateCount = tilesToCreate.size();
for (unsigned n = 0; n < tilesToCreateCount; ++n)
createTile(tilesToCreate[n]);
requiredTileCount -= tilesToCreateCount;
// Paint the content of the newly created tiles.
if (tilesToCreateCount || didResizeTiles)
updateTileBuffers();
// Keep creating tiles until the whole coverRect is covered.
if (requiredTileCount)
m_tileCreationTimer.startOneShot(m_tileCreationDelay);
}
void TiledBackingStore::createTiles()
{
if (m_contentsFrozen)
return;
IntRect visibleRect = visibleContentsRect();
m_previousVisibleRect = visibleRect;
if (visibleRect.isEmpty())
return;
// Resize tiles on edges in case the contents size has changed.
bool didResizeTiles = resizeEdgeTiles();
IntRect keepRect;
IntRect coverRect;
computeCoverAndKeepRect(visibleRect, coverRect, keepRect);
dropTilesOutsideRect(keepRect);
// Search for the tile position closest to the viewport center that does not yet contain a tile.
// Which position is considered the closest depends on the tileDistance function.
double shortestDistance = std::numeric_limits<double>::infinity();
Vector<Tile::Coordinate> tilesToCreate;
unsigned requiredTileCount = 0;
Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coverRect));
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
if (tileAt(currentCoordinate))
continue;
++requiredTileCount;
// Distance is 0 for all tiles inside the visibleRect.
double distance = tileDistance(visibleRect, currentCoordinate);
if (distance > shortestDistance)
continue;
if (distance < shortestDistance) {
tilesToCreate.clear();
shortestDistance = distance;
}
tilesToCreate.append(currentCoordinate);
}
}
// Now construct the tile(s) within the shortest distance.
unsigned tilesToCreateCount = tilesToCreate.size();
for (unsigned n = 0; n < tilesToCreateCount; ++n) {
Tile::Coordinate coordinate = tilesToCreate[n];
setTile(coordinate, m_backend->createTile(this, coordinate));
}
requiredTileCount -= tilesToCreateCount;
// Paint the content of the newly created tiles.
if (tilesToCreateCount || didResizeTiles)
updateTileBuffers();
// Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
if (requiredTileCount)
m_tileCreationTimer->startOneShot(m_tileCreationDelay);
}
void TiledBackingStore::createTiles()
{
if (m_contentsFrozen)
return;
IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect());
m_previousVisibleRect = visibleRect;
if (visibleRect.isEmpty())
return;
// Remove tiles that extend outside the current contents rect.
dropOverhangingTiles();
IntRect keepRect = visibleRect;
// Inflates to both sides, so divide inflate delta by 2
keepRect.inflateX(visibleRect.width() * (m_keepAreaMultiplier.width() - 1.f) / 2);
keepRect.inflateY(visibleRect.height() * (m_keepAreaMultiplier.height() - 1.f) / 2);
keepRect.intersect(contentsRect());
dropTilesOutsideRect(keepRect);
IntRect coverRect = visibleRect;
// Inflates to both sides, so divide inflate delta by 2
coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier.width() - 1.f) / 2);
coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier.height() - 1.f) / 2);
coverRect.intersect(contentsRect());
// Search for the tile position closest to the viewport center that does not yet contain a tile.
// Which position is considered the closest depends on the tileDistance function.
double shortestDistance = std::numeric_limits<double>::infinity();
Vector<Tile::Coordinate> tilesToCreate;
unsigned requiredTileCount = 0;
Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(IntPoint(coverRect.maxX(), coverRect.maxY()));
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
if (tileAt(currentCoordinate))
continue;
++requiredTileCount;
// Distance is 0 for all currently visible tiles.
double distance = tileDistance(visibleRect, currentCoordinate);
if (distance > shortestDistance)
continue;
if (distance < shortestDistance) {
tilesToCreate.clear();
shortestDistance = distance;
}
tilesToCreate.append(currentCoordinate);
}
}
// Now construct the tile(s)
unsigned tilesToCreateCount = tilesToCreate.size();
for (unsigned n = 0; n < tilesToCreateCount; ++n) {
Tile::Coordinate coordinate = tilesToCreate[n];
setTile(coordinate, Tile::create(this, coordinate));
}
requiredTileCount -= tilesToCreateCount;
// Paint the content of the newly created tiles
if (tilesToCreateCount)
updateTileBuffers();
// Keep creating tiles until the whole coverRect is covered.
if (requiredTileCount)
m_tileCreationTimer->startOneShot(m_tileCreationDelay);
}