void MapControl::tick()
{
if ( !layermanager->layer() || !layermanager->layer()->mapadapter() )
{
qDebug() << "MapControl::tick() - no layers configured";
return;
}
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(target);
QPoint step = (dest-start)/steps;
layermanager->scrollView(step);
update();
layermanager->updateRequest();
steps--;
if (steps>0)
{
QTimer::singleShot(50, this, SLOT(tick()));
}
else
{
moveMutex.unlock();
}
}
void TiledDrawingAreaProxy::paint(const IntRect& rect, PlatformDrawingContext context)
{
if (m_isWaitingForDidSetFrameNotification) {
WebPageProxy* page = this->page();
if (!page->isValid())
return;
if (page->process()->isLaunching())
return;
}
adjustVisibleRect();
GraphicsContext gc(context);
gc.save();
// Assumes the backing store is painted with the scale transform applied.
// Since tile content is already scaled, first revert the scaling from the painter.
gc.scale(FloatSize(1 / m_contentsScale, 1 / m_contentsScale));
IntRect dirtyRect = mapFromContents(rect);
TiledDrawingAreaTile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.topLeft());
TiledDrawingAreaTile::Coordinate bottomRight = tileCoordinateForPoint(dirtyRect.bottomRight());
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
TiledDrawingAreaTile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
RefPtr<TiledDrawingAreaTile> currentTile = tileAt(currentCoordinate);
if (currentTile && currentTile->isReadyToPaint())
currentTile->paint(&gc, dirtyRect);
}
}
gc.restore();
}
void TiledBackingStore::paint(GraphicsContext* context, const IntRect& rect)
{
context->save();
// Assumes the backing store is painted with the scale transform applied.
// Since tile content is already scaled, first revert the scaling from the painter.
context->scale(FloatSize(1.f / m_contentsScale, 1.f / m_contentsScale));
IntRect dirtyRect = mapFromContents(rect);
Tile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(dirtyRect));
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
RefPtr<Tile> currentTile = tileAt(currentCoordinate);
if (currentTile && currentTile->isReadyToPaint())
currentTile->paint(context, dirtyRect);
else {
IntRect tileRect = tileRectForCoordinate(currentCoordinate);
IntRect target = intersection(tileRect, dirtyRect);
if (target.isEmpty())
continue;
m_backend->paintCheckerPattern(context, FloatRect(target));
}
}
}
context->restore();
}
void MapControl::resize(const QSize newSize)
{
this->size = newSize;
screen_middle = QPoint(newSize.width()/2, newSize.height()/2);
this->setMaximumSize(newSize.width()+1, newSize.height()+1);
layermanager->resize(newSize);
emit viewChanged(currentCoordinate(), currentZoom());
}
void QmlMapControl::zoomOut(QPoint middle)
{
if( currentZoom() == 0 )
{
return;
}
layermanager->zoomOut(middle);
updateView();
emit viewChanged(currentCoordinate(), currentZoom());
}
void MapControl::positionChanged(Geometry* geom)
{
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(((Point*)geom)->coordinate());
QPoint step = (dest-start);
layermanager->scrollView(step);
// setView(geom);
update();
}
void MapControl::tick()
{
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(target);
QPoint step = (dest-start)/steps;
QPointF next = currentCoordinate()- step;
// setView(Coordinate(next.x(), next.y()));
layermanager->scrollView(step);
update();
steps--;
if (steps>0)
{
QTimer::singleShot(40, this, SLOT(tick()));
}
else
{
moveMutex.unlock();
}
}
void QmlMapControl::setZoom(int zoomlevel)
{
if ( currentZoom() == zoomlevel ||
zoomlevel < 0 ||
zoomlevel > 17 )
{
return;
}
layermanager->setZoom(zoomlevel);
updateView();
emit viewChanged(currentCoordinate(), currentZoom());
refresh();
}
void QmlMapControl::positionChanged(Geometry* geom)
{
if ( !layermanager->layer() || !layermanager->layer()->mapAdapter() )
{
qDebug() << "MapControl::positionChanged() - no layers configured";
return;
}
QPoint start = layermanager->layer()->mapAdapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapAdapter()->coordinateToDisplay(((Point*)geom)->coordinate());
QPoint step = (dest-start);
layermanager->scrollView(step);
updateRequestNew();
}
void MapControl::positionChanged(Geometry* geom)
{
if ( !layermanager->layer() || !layermanager->layer()->mapadapter() )
{
qDebug() << "MapControl::positionChanged() - no layers configured";
return;
}
Point* point = dynamic_cast<Point*>(geom);
if (point!=0)
{
QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(point->coordinate());
QPoint step = (dest-start);
layermanager->scrollView(step);
updateRequestNew();
}
}
// Returns a ratio between 0.0f and 1.0f of the surface of contentsRect covered by rendered tiles.
float TiledBackingStore::coverageRatio(const WebCore::IntRect& contentsRect) const
{
IntRect dirtyRect = mapFromContents(contentsRect);
float rectArea = dirtyRect.width() * dirtyRect.height();
float coverArea = 0.0f;
Tile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(dirtyRect));
for (unsigned yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (unsigned xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
RefPtr<Tile> currentTile = tileAt(Tile::Coordinate(xCoordinate, yCoordinate));
if (currentTile && currentTile->isReadyToPaint()) {
IntRect coverRect = intersection(dirtyRect, currentTile->rect());
coverArea += coverRect.width() * coverRect.height();
}
}
}
return coverArea / rectArea;
}
void QmlMapControl::mouseMoveEvent(QMouseEvent* evnt)
{
// emit(mouseEvent(evnt));
/*
// rotating
QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
evnt = me;
*/
if (mousepressed && mymousemode == Panning)
{
QPoint offset = pre_click_px - QPoint(evnt->x(), evnt->y());
layermanager->scrollView(offset);
pre_click_px = QPoint(evnt->x(), evnt->y());
}
else if (mousepressed && mymousemode == Dragging)
{
current_mouse_pos = QPoint(evnt->x(), evnt->y());
}
evnt->accept();
update();
emit viewChanged(currentCoordinate(), currentZoom());
}
void MapControl::zoomOut()
{
layermanager->zoomOut();
updateView();
emit viewChanged(currentCoordinate(), currentZoom());
}
void MapControl::paintEvent(QPaintEvent* evnt)
{
QWidget::paintEvent(evnt);
QPainter painter(this);
double line;
// painter.translate(150,190);
// painter.scale(0.5,0.5);
// painter.setClipRect(0,0, size.width(), size.height());
// painter.setViewport(10000000000,0,size.width(),size.height());
/*
// rotating
rotation = 45;
painter.translate(256,256);
painter.rotate(rotation);
painter.translate(-256,-256);
*/
layermanager->drawImage(&painter);
layermanager->drawGeoms(&painter);
// added by wolf
// draw scale
if (scaleVisible)
{
if (currentZoom() >= 0 && distanceList.size() > currentZoom())
{
line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
// draw the scale
painter.setPen(mapPen);
QPoint p1(10,size.height()-20);
QPoint p2((int)line,size.height()-20);
painter.drawLine(p1,p2);
painter.drawLine(10,size.height()-15, 10,size.height()-25);
painter.drawLine((int)line,size.height()-15, (int)line,size.height()-25);
QString distance;
if (distanceList.at(currentZoom()) >= 1000)
{
distance = QVariant( distanceList.at(currentZoom())/1000 ) .toString()+ " km";
}
else
{
distance = QVariant( distanceList.at(currentZoom()) ).toString() + " m";
}
painter.drawText(QPoint((int)line+10,size.height()-15), distance);
}
}
painter.drawLine(screen_middle.x(), screen_middle.y()-10,
screen_middle.x(), screen_middle.y()+10); // |
painter.drawLine(screen_middle.x()-10, screen_middle.y(),
screen_middle.x()+10, screen_middle.y()); // -
// int cross_x = int(layermanager->getMapmiddle_px().x())%256;
// int cross_y = int(layermanager->getMapmiddle_px().y())%256;
// painter.drawLine(screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+0,
// screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+256); // |
// painter.drawLine(screen_middle.x()-cross_x+0, screen_middle.y()-cross_y+cross_y,
// screen_middle.x()-cross_x+256, screen_middle.y()-cross_y+cross_y); // -
painter.drawRect(0,0, size.width(), size.height());
/*
// rotating
painter.setMatrix(painter.matrix().inverted());
//qt = painter.transform();
qm = painter.combinedMatrix();
*/
if (mousepressed && mymousemode == Dragging)
{
QRect rect = QRect(pre_click_px, current_mouse_pos);
painter.drawRect(rect);
}
// Draw the Lat and Lon if needed
// FIXME Mariano
if (cursorPosVisible && currentZoom() < 19)
{
line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
QString str;
str = QString(tr(" Lat: %1")).arg(currentWorldCoordinate.y());
painter.drawText(QPoint((int)line+70,size.height()-15), str);
str = QString(tr(" Lon: %1")).arg(currentWorldCoordinate.x());
painter.drawText(QPoint((int)line+160,size.height()-15), str);
}
emit viewChanged(currentCoordinate(), currentZoom());
}
void TiledBackingStore::createTiles()
{
// Guard here as as these can change before the timer fires.
if (isBackingStoreUpdatesSuspended())
return;
// Update our backing store geometry.
const IntRect previousRect = m_rect;
m_rect = mapFromContents(m_client->tiledBackingStoreContentsRect());
m_trajectoryVector = m_pendingTrajectoryVector;
m_visibleRect = visibleRect();
if (m_rect.isEmpty()) {
setCoverRect(IntRect());
setKeepRect(IntRect());
return;
}
/* We must compute cover and keep rects using the visibleRect, instead of the rect intersecting the visibleRect with m_rect,
* because TBS can be used as a backing store of GraphicsLayer and the visible rect usually does not intersect with m_rect.
* In the below case, the intersecting rect is an empty.
*
* +---------------+
* | |
* | m_rect |
* | +-------|-----------------------+
* | | HERE | cover or keep |
* +---------------+ rect |
* | +---------+ |
* | | visible | |
* | | rect | |
* | +---------+ |
* | |
* | |
* +-------------------------------+
*
* We must create or keep the tiles in the HERE region.
*/
IntRect coverRect;
IntRect keepRect;
computeCoverAndKeepRect(m_visibleRect, coverRect, keepRect);
setCoverRect(coverRect);
setKeepRect(keepRect);
if (coverRect.isEmpty())
return;
// Resize tiles at the edge in case the contents size has changed, but only do so
// after having dropped tiles outside the keep rect.
bool didResizeTiles = false;
if (previousRect != m_rect)
didResizeTiles = resizeEdgeTiles();
// 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;
// Cover areas (in tiles) with minimum distance from the visible rect. If the visible rect is
// not covered already it will be covered first in one go, due to the distance being 0 for tiles
// inside the visible rect.
Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coverRect));
for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
if (tileAt(currentCoordinate))
continue;
++requiredTileCount;
double distance = tileDistance(m_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 or resized tiles.
if (tilesToCreateCount || didResizeTiles)
updateTileBuffers();
// Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
m_pendingTileCreation = requiredTileCount;
if (m_pendingTileCreation) {
if (!m_commitTileUpdatesOnIdleEventLoop) {
m_client->tiledBackingStoreHasPendingTileCreation();
return;
}
static const double tileCreationDelay = 0.01;
startBackingStoreUpdateTimer(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);
}
void TiledBackingStore::createTiles()
{
// Guard here as as these can change before the timer fires.
if (isBackingStoreUpdatesSuspended())
return;
// Update our backing store geometry.
const IntRect previousRect = m_rect;
m_rect = mapFromContents(m_client->tiledBackingStoreContentsRect());
const IntRect visibleRect = this->visibleRect();
m_visibleRect = visibleRect;
if (visibleRect.isEmpty())
return;
IntRect keepRect;
IntRect coverRect;
computeCoverAndKeepRect(visibleRect, coverRect, keepRect);
setKeepRect(keepRect);
// Resize tiles at the edge in case the contents size has changed, but only do so
// after having dropped tiles outside the keep rect.
bool didResizeTiles = false;
if (previousRect != m_rect)
didResizeTiles = resizeEdgeTiles();
// 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;
// Cover areas (in tiles) with minimum distance from the visible rect. If the visible rect is
// not covered already it will be covered first in one go, due to the distance being 0 for tiles
// inside the visible rect.
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;
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 or resized tiles.
if (tilesToCreateCount || didResizeTiles)
updateTileBuffers();
// Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
if (requiredTileCount)
m_backingStoreUpdateTimer.startOneShot(m_tileCreationDelay);
}
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 MapControl::setViewAndZoomIn(const QList<QPointF> coordinates) const
{
layermanager->setViewAndZoomIn(coordinates);
emit viewChanged(currentCoordinate(), currentZoom());
}
void MapControl::setView(const QPointF& coordinate) const
{
layermanager->setView(coordinate);
emit viewChanged(currentCoordinate(), currentZoom());
}
void MapControl::updateView() const
{
layermanager->setView( currentCoordinate() );
emit viewChanged(currentCoordinate(), currentZoom());
}
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 MapControl::setZoom(int zoomlevel)
{
layermanager->setZoom(zoomlevel);
updateView();
emit viewChanged(currentCoordinate(), currentZoom());
}