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()); }