21#include <QApplication>
25#include <QGraphicsItem>
26#include <QGraphicsScene>
27#include <QGraphicsView>
34#include <QResizeEvent>
42#include <QVariantAnimation>
43#include <QPropertyAnimation>
54#include "moc_qgsmapcanvas.cpp"
130 : QGraphicsView( parent )
132 , mExpressionContextScope( tr(
"Map Canvas" ) )
134 mScene =
new QGraphicsScene();
136 setLayout( mLayout );
139 setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
140 setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
141 setMouseTracking(
true );
142 setFocusPolicy( Qt::StrongFocus );
147 mResizeTimer =
new QTimer(
this );
148 mResizeTimer->setSingleShot(
true );
151 mRefreshTimer =
new QTimer(
this );
152 mRefreshTimer->setSingleShot(
true );
153 connect( mRefreshTimer, &QTimer::timeout,
this, &QgsMapCanvas::refreshMap );
156 mMap =
new QgsMapCanvasMap(
this );
197 setDestinationCrs( crs );
210 double segmentationTolerance = settings.
value( QStringLiteral(
"qgis/segmentationTolerance" ),
"0.01745" ).toDouble();
215 mWheelZoomFactor = settings.
value( QStringLiteral(
"qgis/zoom_factor" ), 2 ).toDouble();
217 QSize s = viewport()->size();
222 setSceneRect( 0, 0, s.width(), s.height() );
223 mScene->setSceneRect( QRectF( 0, 0, s.width(), s.height() ) );
227 connect( &mMapUpdateTimer, &QTimer::timeout,
this, &QgsMapCanvas::mapUpdateTimeout );
228 mMapUpdateTimer.setInterval( 250 );
233 grabGesture( Qt::PinchGesture );
234 grabGesture( Qt::TapAndHoldGesture );
235 viewport()->setAttribute( Qt::WA_AcceptTouchEvents );
239 viewport()->setGraphicsEffect( mPreviewEffect );
243 connect( &mAutoRefreshTimer, &QTimer::timeout,
this, &QgsMapCanvas::autoRefreshTriggered );
247 setInteractive(
false );
263 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
271 const QList< QgsMapTool * > tools = findChildren< QgsMapTool *>();
274 tool->mCanvas =
nullptr;
282 qDeleteAll( mScene->items() );
284 mScene->deleteLater();
305 for (
auto previewJob = mPreviewJobs.constBegin(); previewJob != mPreviewJobs.constEnd(); ++previewJob )
313 mPreviewJobs.clear();
321 factor = std::clamp( factor, magnifierMin, magnifierMax );
356 if ( index >= 0 && index <
layers.size() )
379 if ( mCurrentLayer ==
layer )
382 mCurrentLayer =
layer;
393 return nullptr != mJob;
406 if ( !mTheme.isEmpty() )
409 setLayersPrivate(
layers );
422void QgsMapCanvas::setLayersPrivate(
const QList<QgsMapLayer *> &layers )
424 const QList<QgsMapLayer *> oldLayers = mSettings.
layers();
427 if (
layers == oldLayers )
502 updateAutoRefreshTimer();
543 mBlockExtentChangedSignal++;
544 mBlockScaleChangedSignal++;
550 mBlockItemPositionUpdates++;
552 mBlockItemPositionUpdates--;
555 mBlockExtentChangedSignal--;
556 mBlockScaleChangedSignal--;
564 QgsDebugMsgLevel( QStringLiteral(
"refreshing after destination CRS changed" ), 2 );
584 mController = controller;
590void QgsMapCanvas::temporalControllerModeChanged()
594 switch ( temporalNavigationObject->navigationMode() )
598 mSettings.
setFrameRate( temporalNavigationObject->framesPerSecond() );
599 mSettings.
setCurrentFrame( temporalNavigationObject->currentFrameNumber() );
627 if ( !allowOutdatedResults && mLabelingResultsOutdated )
630 return mLabelingResults.get();
635 if ( !allowOutdatedResults && mRenderedItemResultsOutdated )
638 return mRenderedItemResults.get();
661 mPreviousRenderedItemResults.reset();
666 return nullptr != mCache;
674 if ( mPreviousRenderedItemResults )
675 mPreviousRenderedItemResults.reset();
676 if ( mRenderedItemResults )
677 mRenderedItemResults.reset();
687 mUseParallelRendering = enabled;
692 return mUseParallelRendering;
697 mMapUpdateTimer.setInterval( timeMilliseconds );
702 return mMapUpdateTimer.interval();
708 return mCurrentLayer;
728 expressionContext << generator->createExpressionContextScope();
732 return expressionContext;
739 QgsDebugMsgLevel( QStringLiteral(
"CANVAS refresh - invalid settings -> nothing to do" ), 2 );
743 if ( !mRenderFlag || mFrozen )
749 if ( mRefreshScheduled )
751 QgsDebugMsgLevel( QStringLiteral(
"CANVAS refresh already scheduled" ), 2 );
755 mRefreshScheduled =
true;
760 mRefreshTimer->start( 1 );
762 mLabelingResultsOutdated =
true;
763 mRenderedItemResultsOutdated =
true;
768 QList<QgsMapLayer *> filteredLayers;
771 if (
QgsAnnotationLayer *annotationLayer = qobject_cast< QgsAnnotationLayer * >( layer ) )
773 if (
QgsMapLayer *linkedLayer = annotationLayer->linkedVisibilityLayer() )
775 if ( !layers.contains( linkedLayer ) )
779 filteredLayers.append( layer );
781 return filteredLayers;
784void QgsMapCanvas::refreshMap()
786 Q_ASSERT( mRefreshScheduled );
793 if ( mCacheInvalidations.testFlag( CacheInvalidationType::Temporal ) )
795 clearTemporalCache();
796 mCacheInvalidations &= ~(
static_cast< int >( CacheInvalidationType::Temporal ) );
798 if ( mCacheInvalidations.testFlag( CacheInvalidationType::Elevation ) )
800 clearElevationCache();
801 mCacheInvalidations &= ~(
static_cast< int >( CacheInvalidationType::Elevation ) );
809 switch ( temporalNavigationObject->navigationMode() )
813 mSettings.
setFrameRate( temporalNavigationObject->framesPerSecond() );
814 mSettings.
setCurrentFrame( temporalNavigationObject->currentFrameNumber() );
825 if ( !mTheme.isEmpty() )
838 QList<QgsMapLayer *> allLayers = renderSettings.
layers();
849 mJobCanceled =
false;
850 if ( mUseParallelRendering )
867 mRefreshScheduled =
false;
869 mMapUpdateTimer.start();
874void QgsMapCanvas::mapThemeChanged(
const QString &theme )
876 if (
theme == mTheme )
881 setLayersPrivate(
QgsProject::instance()->mapThemeCollection()->mapThemeVisibleLayers( mTheme ) );
894void QgsMapCanvas::mapThemeRenamed(
const QString &theme,
const QString &newTheme )
896 if ( mTheme.isEmpty() ||
theme != mTheme )
905void QgsMapCanvas::rendererJobFinished()
907 QgsDebugMsgLevel( QStringLiteral(
"CANVAS finish! %1" ).arg( !mJobCanceled ), 2 );
909 mMapUpdateTimer.stop();
911 notifyRendererErrors( mJob->
errors() );
921 mLabelingResultsOutdated =
false;
925 if ( mRenderedItemResults )
929 if ( mPreviousRenderedItemResults )
935 if ( mCache && !mPreviousRenderedItemResults )
936 mPreviousRenderedItemResults = std::make_unique< QgsRenderedItemResults >( mJob->
mapSettings().
extent() );
938 if ( mRenderedItemResults && mPreviousRenderedItemResults )
943 mPreviousRenderedItemResults->transferResults( mRenderedItemResults.get() );
945 if ( mPreviousRenderedItemResults )
951 mRenderedItemResultsOutdated =
false;
961 QString logMsg = tr(
"Canvas refresh: %1 ms" ).arg( mJob->
renderingTime() );
965 if ( mDrawRenderingStats )
967 int w = img.width(), h = img.height();
968 QFont fnt = p.font();
971 int lh = p.fontMetrics().height() * 2;
972 QRect r( 0, h - lh, w, lh );
973 p.setPen( Qt::NoPen );
974 p.setBrush( QColor( 0, 0, 0, 110 ) );
976 p.setPen( Qt::white );
977 QString msg = QStringLiteral(
"%1 :: %2 ms" ).arg( mUseParallelRendering ? QStringLiteral(
"PARALLEL" ) : QStringLiteral(
"SEQUENTIAL" ) ).arg( mJob->renderingTime() );
978 p.drawText( r, msg, QTextOption( Qt::AlignCenter ) );
983 mMap->setContent( img, imageRect( img, mSettings ) );
985 mLastLayerRenderTime.clear();
987 for (
auto it = times.constBegin(); it != times.constEnd(); ++it )
989 mLastLayerRenderTime.insert( it.key()->id(), it.value() );
991 if ( mUsePreviewJobs && !mRefreshAfterJob )
996 mRefreshAfterJob =
false;
1001 mJob->deleteLater();
1006 if ( mRefreshAfterJob )
1008 mRefreshAfterJob =
false;
1013void QgsMapCanvas::previewJobFinished()
1021 mPreviewJobs.removeAll( job );
1023 int number = job->property(
"number" ).toInt();
1026 startPreviewJob( number + 1 );
1043 QgsLogger::warning( QStringLiteral(
"The renderer map has a wrong device pixel ratio" ) );
1047 QgsRectangle rect( topLeft.
x(), topLeft.
y(), topLeft.
x() + img.width()*res, topLeft.
y() - img.height()*res );
1053 return mUsePreviewJobs;
1058 mUsePreviewJobs = enabled;
1063 mDropHandlers = handlers;
1066void QgsMapCanvas::clearTemporalCache()
1070 bool invalidateLabels =
false;
1074 bool alreadyInvalidatedThisLayer =
false;
1082 alreadyInvalidatedThisLayer =
true;
1093 invalidateLabels =
true;
1099 if ( !alreadyInvalidatedThisLayer )
1106 const QList<QgsMapLayer *> childLayerList = gl->childLayers();
1109 if ( childLayer->temporalProperties() && childLayer->temporalProperties()->isActive() )
1121 if ( invalidateLabels )
1129void QgsMapCanvas::clearElevationCache()
1133 bool invalidateLabels =
false;
1142 invalidateLabels =
true;
1152 const QList<QgsMapLayer *> childLayerList = gl->childLayers();
1155 if ( childLayer->elevationProperties() && childLayer->elevationProperties()->hasElevation() )
1167 if ( invalidateLabels )
1177 const QgsPointXY mapPoint =
event->originalMapPoint();
1181 QMenu *copyCoordinateMenu =
new QMenu( tr(
"Copy Coordinate" ), &menu );
1189 const QgsPointXY transformedPoint = ct.transform( mapPoint );
1192 int displayPrecision = 0;
1200 displayPrecision = 0;
1202 displayPrecision = 1;
1204 displayPrecision = 2;
1206 displayPrecision = 3;
1208 displayPrecision = 4;
1210 displayPrecision = 5;
1212 displayPrecision = 6;
1214 displayPrecision = 7;
1216 displayPrecision = 8;
1218 displayPrecision = 9;
1226 QString firstSuffix;
1227 QString secondSuffix;
1228 if ( axisList.size() >= 2 )
1234 QString firstNumber;
1235 QString secondNumber;
1238 firstNumber = QString::number( transformedPoint.
y(),
'f', displayPrecision );
1239 secondNumber = QString::number( transformedPoint.
x(),
'f', displayPrecision );
1243 firstNumber = QString::number( transformedPoint.
x(),
'f', displayPrecision );
1244 secondNumber = QString::number( transformedPoint.
y(),
'f', displayPrecision );
1247 QAction *copyCoordinateAction =
new QAction( QStringLiteral(
"%5 (%1%2, %3%4)" ).arg(
1248 firstNumber, firstSuffix, secondNumber, secondSuffix, identifier ), &menu );
1250 connect( copyCoordinateAction, &QAction::triggered,
this, [firstNumber, secondNumber, transformedPoint]
1252 QClipboard *clipboard = QApplication::clipboard();
1254 const QString coordinates = firstNumber +
',' + secondNumber;
1257 if ( clipboard->supportsSelection() )
1259 clipboard->setText( coordinates, QClipboard::Selection );
1261 clipboard->setText( coordinates, QClipboard::Clipboard );
1264 copyCoordinateMenu->addAction( copyCoordinateAction );
1278 const QString customCrsString = settings.
value( QStringLiteral(
"qgis/custom_coordinate_crs" ) ).toString();
1279 if ( !customCrsString.isEmpty() )
1287 copyCoordinateMenu->addSeparator();
1288 QAction *setCustomCrsAction =
new QAction( tr(
"Set Custom CRS…" ), &menu );
1289 connect( setCustomCrsAction, &QAction::triggered,
this, [ = ]
1293 if ( selector.exec() )
1298 copyCoordinateMenu->addAction( setCustomCrsAction );
1300 menu.addMenu( copyCoordinateMenu );
1308 if ( !menu.isEmpty() )
1309 menu.exec(
event->globalPos() );
1314 const QDateTime currentTime = QDateTime::currentDateTime();
1319 const QString errorKey = error.layerID +
':' + error.message;
1320 if ( mRendererErrors.contains( errorKey ) )
1322 const QDateTime sameErrorTime = mRendererErrors.value( errorKey );
1324 if ( sameErrorTime.secsTo( currentTime ) < 60 )
1328 mRendererErrors[errorKey] = currentTime;
1335void QgsMapCanvas::updateDevicePixelFromScreen()
1341 if ( window()->windowHandle() )
1343 mSettings.
setOutputDpi( window()->windowHandle()->screen()->physicalDotsPerInch() );
1344 mSettings.
setDpiTarget( window()->windowHandle()->screen()->physicalDotsPerInch() );
1350 mSettings.
setOutputDpi( window()->windowHandle()->screen()->logicalDotsPerInch() );
1351 mSettings.
setDpiTarget( window()->windowHandle()->screen()->logicalDotsPerInch() );
1356void QgsMapCanvas::onElevationShadingRendererChanged()
1362 if ( mCache && wasDeactivated )
1379 mCacheInvalidations |= CacheInvalidationType::Temporal;
1381 autoRefreshTriggered();
1391 mInteractionBlockers.append( blocker );
1396 mInteractionBlockers.removeAll( blocker );
1403 if ( block->blockCanvasInteraction( interaction ) )
1411 if ( mMapController )
1413 delete mMapController;
1414 mMapController =
nullptr;
1420 mMapController = controller;
1421 mMapController->setParent(
this );
1425 connect( mMapController, &QgsAbstract2DMapController::zoomMap,
this, [ = ](
double factor ) {
zoomByFactor( factor ); } );
1429void QgsMapCanvas::mapUpdateTimeout()
1434 mMap->setContent( img, imageRect( img, mSettings ) );
1443 mJobCanceled =
true;
1464 image = theQPixmap->toImage();
1465 painter.begin( &image );
1475 image = mMap->contentImage().copy();
1476 painter.begin( &image );
1480 QStyleOptionGraphicsItem option;
1481 option.initFrom(
this );
1482 QGraphicsItem *item =
nullptr;
1483 QListIterator<QGraphicsItem *> i( items() );
1485 while ( i.hasPrevious() )
1487 item = i.previous();
1496 QPointF itemScenePos = item->scenePos();
1497 painter.translate( itemScenePos.x(), itemScenePos.y() );
1499 item->paint( &painter, &option );
1503 image.save( fileName, format.toLocal8Bit().data() );
1505 QFileInfo myInfo = QFileInfo( fileName );
1508 QString outputSuffix = myInfo.suffix();
1509 QString myWorldFileName = myInfo.absolutePath() +
'/' + myInfo.completeBaseName() +
'.'
1510 + outputSuffix.at( 0 ) + outputSuffix.at( myInfo.suffix().size() - 1 ) +
'w';
1511 QFile myWorldFile( myWorldFileName );
1512 if ( !myWorldFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1516 QTextStream myStream( &myWorldFile );
1538 rect = ct.transformBoundingBox(
extent );
1552 if ( ( r == current ) && magnified )
1565 QgsDebugMsgLevel( QStringLiteral(
"Empty extent - keeping old scale with new center!" ), 2 );
1574 if ( mScaleLocked && magnified )
1576 ScaleRestorer restorer(
this );
1593 for (
int i = mLastExtent.size() - 1; i > mLastExtentIndex; i-- )
1595 mLastExtent.removeAt( i );
1598 if ( !mLastExtent.isEmpty() && mLastExtent.last() != mSettings.
extent() )
1600 mLastExtent.append( mSettings.
extent() );
1604 if ( mLastExtent.size() > 100 )
1606 mLastExtent.removeAt( 0 );
1610 mLastExtentIndex = mLastExtent.size() - 1;
1659 return mCursorPoint;
1681 if ( !mBlockScaleChangedSignal )
1714 if ( mLastExtentIndex > 0 )
1717 mSettings.
setExtent( mLastExtent[mLastExtentIndex] );
1730 if ( mLastExtentIndex < mLastExtent.size() - 1 )
1733 mSettings.
setExtent( mLastExtent[mLastExtentIndex] );
1745 mLastExtent.clear();
1746 mLastExtent.append( mSettings.
extent() ) ;
1747 mLastExtentIndex = mLastExtent.size() - 1;
1765 double closestSquaredDistance = pow( extentRect.
width(), 2.0 ) + pow( extentRect.
height(), 2.0 );
1766 bool pointFound =
false;
1770 double sqrDist = point.
sqrDist( centerLayerCoordinates );
1771 if ( sqrDist > closestSquaredDistance || sqrDist < 4 * std::numeric_limits<double>::epsilon() )
1774 closestPoint = point;
1775 closestSquaredDistance = sqrDist;
1781 rect.scale( scaleFactor, &
center );
1794 layer = mCurrentLayer;
1824 rect = optimalExtentForPointLayer( vlayer, rect.
center() );
1836 for (
const QgsFeature &feature : selectedFeatures )
1838 if ( !feature.hasGeometry() )
1877 if ( !mapLayer || !mapLayer->isSpatial() )
1880 switch ( mapLayer->type() )
1886 if (
layer->selectedFeatureCount() == 0 )
1889 rect =
layer->boundingBoxOfSelected();
1897 rect = optimalExtentForPointLayer(
layer, rect.
center() );
1911 for (
const QgsFeature &feature : selectedFeatures )
1913 if ( !feature.hasGeometry() )
1935 if ( selectionExtent.
isNull() )
1946 return mSettings.
zRange();
1960 mCacheInvalidations |= CacheInvalidationType::Elevation;
1962 autoRefreshTriggered();
1998 if ( boundingBoxOfFeatureIds( ids,
layer, bbox, errorMsg ) )
2002 bbox = optimalExtentForPointLayer(
layer, bbox.
center() );
2022 if ( boundingBoxOfFeatureIds( ids,
layer, bbox, errorMsg ) )
2039 int featureCount = 0;
2047 errorMsg = tr(
"Feature does not have a geometry" );
2051 errorMsg = tr(
"Feature geometry is empty" );
2053 if ( !errorMsg.isEmpty() )
2062 if ( featureCount != ids.count() )
2064 errorMsg = tr(
"Feature not found" );
2076 layer = mCurrentLayer;
2100 for (
const QgsFeature &feature : selectedFeatures )
2102 if ( !feature.hasGeometry() )
2138 if ( !mapLayer || !mapLayer->isSpatial() )
2142 switch ( mapLayer->type() )
2147 if (
layer->selectedFeatureCount() == 0 )
2150 rect =
layer->boundingBoxOfSelected();
2158 rect = optimalExtentForPointLayer(
layer, rect.
center() );
2169 for (
const QgsFeature &feature : selectedFeatures )
2171 if ( !feature.hasGeometry() )
2194 if ( selectionExtent.
isNull() )
2205 const QColor &color1,
const QColor &color2,
2206 int flashes,
int duration )
2213 QList< QgsGeometry > geoms;
2229 if ( geometries.isEmpty() )
2247 QColor startColor = color1;
2248 if ( !startColor.isValid() )
2258 startColor.setAlpha( 255 );
2260 QColor endColor = color2;
2261 if ( !endColor.isValid() )
2263 endColor = startColor;
2264 endColor.setAlpha( 0 );
2268 QVariantAnimation *animation =
new QVariantAnimation(
this );
2269 connect( animation, &QVariantAnimation::finished,
this, [animation, rb]
2271 animation->deleteLater();
2274 connect( animation, &QPropertyAnimation::valueChanged,
this, [rb, geomType](
const QVariant & value )
2276 QColor
c = value.value<QColor>();
2285 c.setAlpha(
c.alpha() );
2291 animation->setDuration( duration * flashes );
2292 animation->setStartValue( endColor );
2293 double midStep = 0.2 / flashes;
2294 for (
int i = 0; i < flashes; ++i )
2296 double start =
static_cast< double >( i ) / flashes;
2297 animation->setKeyValueAt( start + midStep, startColor );
2298 double end =
static_cast< double >( i + 1 ) / flashes;
2300 animation->setKeyValueAt( end, endColor );
2302 animation->setEndValue( endColor );
2325 if ( !e->isAccepted() )
2330 double dx = std::fabs( currentExtent.
width() / 4 );
2331 double dy = std::fabs( currentExtent.
height() / 4 );
2363 if ( ! e->isAutoRepeat() )
2371 case Qt::Key_PageUp:
2376 case Qt::Key_PageDown:
2383 mUseParallelRendering = !mUseParallelRendering;
2388 mDrawRenderingStats = !mDrawRenderingStats;
2416 mTemporaryCursorOverride.reset();
2430 QgsDebugMsgLevel(
"Ignoring key release: " + QString::number( e->key() ), 2 );
2449void QgsMapCanvas::beginZoomRect( QPoint pos )
2451 mZoomRect.setRect( 0, 0, 0, 0 );
2453 mZoomDragging =
true;
2455 QColor color( Qt::blue );
2456 color.setAlpha( 63 );
2457 mZoomRubberBand->setColor( color );
2458 mZoomRect.setTopLeft( pos );
2461void QgsMapCanvas::stopZoomRect()
2463 if ( mZoomDragging )
2465 mZoomDragging =
false;
2466 mZoomRubberBand.reset(
nullptr );
2467 mTemporaryCursorOverride.reset();
2471void QgsMapCanvas::endZoomRect( QPoint pos )
2476 mZoomRect.setRight( pos.x() );
2477 mZoomRect.setBottom( pos.y() );
2480 mZoomRect = mZoomRect.normalized();
2482 if ( mZoomRect.width() < 5 && mZoomRect.height() < 5 )
2489 const QSize &zoomRectSize = mZoomRect.size();
2490 const QSize &canvasSize = mSettings.
outputSize();
2491 double sfx =
static_cast< double >( zoomRectSize.width() ) / canvasSize.width();
2492 double sfy =
static_cast< double >( zoomRectSize.height() ) / canvasSize.height();
2493 double sf = std::max( sfx, sfy );
2501void QgsMapCanvas::startPan()
2511void QgsMapCanvas::stopPan()
2516 mTemporaryCursorOverride.reset();
2524 if ( e->button() == Qt::MiddleButton &&
2525 e->modifiers() & Qt::ShiftModifier )
2527 beginZoomRect( e->pos() );
2531 else if ( e->button() == Qt::MiddleButton )
2546 && e->modifiers() & Qt::ShiftModifier )
2548 beginZoomRect( e->pos() );
2554 showContextMenu( me.get() );
2577 if ( mZoomDragging &&
2578 e->button() == Qt::MiddleButton )
2580 endZoomRect( e->pos() );
2584 else if ( e->button() == Qt::MiddleButton )
2588 else if ( e->button() == Qt::BackButton )
2593 else if ( e->button() == Qt::ForwardButton )
2600 if ( mZoomDragging && e->button() == Qt::LeftButton )
2602 endZoomRect( e->pos() );
2624 QGraphicsView::resizeEvent( e );
2625 mResizeTimer->start( 500 );
2627 double oldScale = mSettings.
scale();
2628 QSize lastSize = viewport()->size();
2631 mScene->setSceneRect( QRectF( 0, 0, lastSize.width(), lastSize.height() ) );
2637 double scaleFactor = oldScale / mSettings.
scale();
2655 QGraphicsView::paintEvent( e );
2660 if ( mBlockItemPositionUpdates )
2663 const QList<QGraphicsItem *> items = mScene->items();
2664 for ( QGraphicsItem *gi : items )
2681 QgsDebugMsgLevel(
"Wheel event delta " + QString::number( e->angleDelta().y() ), 2 );
2686 if ( e->isAccepted() )
2690 if ( e->angleDelta().y() == 0 )
2697 bool reverseZoom = settings.
value( QStringLiteral(
"qgis/reverse_wheel_zoom" ),
false ).toBool();
2698 bool zoomIn = reverseZoom ? e->angleDelta().y() < 0 : e->angleDelta().y() > 0;
2702 zoomFactor = 1.0 + ( zoomFactor - 1.0 ) / 120.0 * std::fabs( e->angleDelta().y() );
2704 if ( e->modifiers() & Qt::ControlModifier )
2707 zoomFactor = 1.0 + ( zoomFactor - 1.0 ) / 20.0;
2710 double signedWheelFactor =
zoomIn ? 1 / zoomFactor : zoomFactor;
2715 QgsPointXY newCenter( mousePos.
x() + ( ( oldCenter.
x() - mousePos.
x() ) * signedWheelFactor ),
2716 mousePos.
y() + ( ( oldCenter.
y() - mousePos.
y() ) * signedWheelFactor ) );
2724 mWheelZoomFactor = std::max( factor, 1.01 );
2753 ScaleRestorer restorer(
this );
2764 if ( mScaleLocked != isLocked )
2766 mScaleLocked = isLocked;
2779 else if ( mZoomDragging )
2781 mZoomRect.setBottomRight( e->pos() );
2782 mZoomRubberBand->setToCanvasRectangle( mZoomRect );
2783 mZoomRubberBand->show();
2796 if ( !panOperationInProgress() )
2808 if ( tool == mMapTool )
2819 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2830 connect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2838 if ( mMapTool && mMapTool == tool )
2840 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2845 setCursor( Qt::ArrowCursor );
2869 QBrush bgBrush( color );
2870 setBackgroundBrush( bgBrush );
2873 palette.setColor( backgroundRole(), color );
2874 setPalette( palette );
2878 mScene->setBackgroundBrush( bgBrush );
2887 return mScene->backgroundBrush().color();
2899 bool hasSelectedFeatures =
false;
2906 hasSelectedFeatures =
true;
2911 if ( hasSelectedFeatures )
2977 if ( mTheme ==
theme )
2991 setLayersPrivate(
QgsProject::instance()->mapThemeCollection()->mapThemeVisibleLayers( mTheme ) );
3009void QgsMapCanvas::connectNotify(
const char *signal )
3016void QgsMapCanvas::layerRepaintRequested(
bool deferred )
3022void QgsMapCanvas::autoRefreshTriggered()
3028 mRefreshAfterJob =
true;
3035void QgsMapCanvas::updateAutoRefreshTimer()
3039 int minAutoRefreshInterval = -1;
3043 int layerRefreshInterval = 0;
3054 if ( rendererRefreshRate > 0 )
3056 layerRefreshInterval = 1000 / rendererRefreshRate;
3061 if ( layerRefreshInterval == 0 )
3064 minAutoRefreshInterval = minAutoRefreshInterval > 0 ? std::min( layerRefreshInterval, minAutoRefreshInterval ) : layerRefreshInterval;
3067 if ( minAutoRefreshInterval > 0 )
3069 mAutoRefreshTimer.setInterval( minAutoRefreshInterval );
3070 mAutoRefreshTimer.start();
3074 mAutoRefreshTimer.stop();
3078void QgsMapCanvas::projectThemesChanged()
3080 if ( mTheme.isEmpty() )
3111 double dx = end.
x() - start.
x();
3112 double dy = end.
y() - start.
y();
3114 c.set(
c.x() - dx,
c.y() - dy );
3152 setSceneRect( -pnt.x(), -pnt.y(), viewport()->size().width(), viewport()->size().height() );
3160 bool allHandled =
true;
3163 bool handled =
false;
3166 if ( handler && handler->customUriProviderKey() == uri.providerKey )
3168 if ( handler->handleCustomUriCanvasDrop( uri,
this ) )
3192 updateDevicePixelFromScreen();
3197 if ( !mBlockExtentChangedSignal )
3208 if ( !mPreviewEffect )
3213 mPreviewEffect->setEnabled( previewEnabled );
3218 if ( !mPreviewEffect )
3223 return mPreviewEffect->isEnabled();
3228 if ( !mPreviewEffect )
3233 mPreviewEffect->
setMode( mode );
3238 if ( !mPreviewEffect )
3243 return mPreviewEffect->
mode();
3248 if ( !mSnappingUtils )
3254 return mSnappingUtils;
3259 mSnappingUtils = utils;
3266 QDomNodeList nodes = doc.elementsByTagName( QStringLiteral(
"mapcanvas" ) );
3267 if ( nodes.count() )
3269 QDomNode node = nodes.item( 0 );
3272 if ( nodes.count() > 1 )
3274 for (
int i = 0; i < nodes.size(); ++i )
3276 QDomElement elementNode = nodes.at( i ).toElement();
3278 if ( elementNode.hasAttribute( QStringLiteral(
"name" ) ) && elementNode.attribute( QStringLiteral(
"name" ) ) == objectName() )
3280 node = nodes.at( i );
3288 if ( objectName() != QLatin1String(
"theMapCanvas" ) )
3299 QDomElement elem = node.toElement();
3300 if ( elem.hasAttribute( QStringLiteral(
"theme" ) ) )
3302 if (
QgsProject::instance()->mapThemeCollection()->hasMapTheme( elem.attribute( QStringLiteral(
"theme" ) ) ) )
3304 setTheme( elem.attribute( QStringLiteral(
"theme" ) ) );
3307 setAnnotationsVisible( elem.attribute( QStringLiteral(
"annotationsVisible" ), QStringLiteral(
"1" ) ).toInt() );
3310 const QDomNodeList scopeElements = elem.elementsByTagName( QStringLiteral(
"expressionContextScope" ) );
3311 if ( scopeElements.size() > 0 )
3313 const QDomElement scopeElement = scopeElements.at( 0 ).toElement();
3319 QgsDebugMsgLevel( QStringLiteral(
"Couldn't read mapcanvas information from project" ), 2 );
3334 QDomNodeList nl = doc.elementsByTagName( QStringLiteral(
"qgis" ) );
3337 QgsDebugError( QStringLiteral(
"Unable to find qgis element in project file" ) );
3340 QDomNode qgisNode = nl.item( 0 );
3342 QDomElement mapcanvasNode = doc.createElement( QStringLiteral(
"mapcanvas" ) );
3343 mapcanvasNode.setAttribute( QStringLiteral(
"name" ), objectName() );
3344 if ( !mTheme.isEmpty() )
3345 mapcanvasNode.setAttribute( QStringLiteral(
"theme" ), mTheme );
3346 mapcanvasNode.setAttribute( QStringLiteral(
"annotationsVisible" ), mAnnotationsVisible );
3347 qgisNode.appendChild( mapcanvasNode );
3349 mSettings.
writeXml( mapcanvasNode, doc );
3352 QDomElement scopeElement = doc.createElement( QStringLiteral(
"expressionContextScope" ) );
3354 tmpScope.
removeVariable( QStringLiteral(
"atlas_featurenumber" ) );
3360 mapcanvasNode.appendChild( scopeElement );
3367 if ( mScaleLocked && !ignoreScaleLock )
3369 ScaleRestorer restorer(
this );
3404 bool allHandled =
true;
3407 bool handled =
false;
3410 if ( handler->canHandleCustomUriCanvasDrop( uri,
this ) )
3436 return QGraphicsView::viewportEvent(
event );
3439void QgsMapCanvas::mapToolDestroyed()
3447 if ( e->type() == QEvent::Gesture )
3449 if ( QTapAndHoldGesture *tapAndHoldGesture = qobject_cast< QTapAndHoldGesture * >(
static_cast<QGestureEvent *
>( e )->gesture( Qt::TapAndHoldGesture ) ) )
3451 QPointF pos = tapAndHoldGesture->position();
3452 pos = mapFromGlobal( QPoint( pos.x(), pos.y() ) );
3460 return mMapTool->
gestureEvent(
static_cast<QGestureEvent *
>( e ) );
3465 return QGraphicsView::event( e );
3491 while ( mRefreshScheduled || mJob )
3493 QgsApplication::processEvents();
3509 QList<QgsMapCanvasAnnotationItem *> annotationItemList;
3510 const QList<QGraphicsItem *> items = mScene->items();
3511 for ( QGraphicsItem *gi : items )
3516 annotationItemList.push_back( aItem );
3520 return annotationItemList;
3525 mAnnotationsVisible = show;
3529 item->setVisible( show );
3543void QgsMapCanvas::startPreviewJobs()
3552 schedulePreviewJob( 0 );
3555void QgsMapCanvas::startPreviewJob(
int number )
3568 double dx = ( i - 1 ) * mapRect.
width();
3569 double dy = ( 1 - j ) * mapRect.
height();
3584 const QList<QgsMapLayer *>
layers = jobSettings.
layers();
3585 QList< QgsMapLayer * > previewLayers;
3590 if (
layer->
customProperty( QStringLiteral(
"rendering/noPreviewJobs" ),
false ).toBool() )
3592 QgsDebugMsgLevel( QStringLiteral(
"Layer %1 not rendered because it is explicitly blocked from preview jobs" ).arg(
layer->
id() ), 3 );
3599 QgsDebugMsgLevel( QStringLiteral(
"Layer %1 not rendered because it does not match the renderInPreview criterion %2" ).arg(
layer->
id() ).arg( mLastLayerRenderTime.value(
layer->
id() ) ), 3 );
3603 previewLayers <<
layer;
3613 job->setProperty(
"number", number );
3614 mPreviewJobs.append( job );
3619void QgsMapCanvas::stopPreviewJobs()
3621 mPreviewTimer.stop();
3622 for (
auto previewJob = mPreviewJobs.constBegin(); previewJob != mPreviewJobs.constEnd(); ++previewJob )
3628 ( *previewJob )->cancelWithoutBlocking();
3631 mPreviewJobs.clear();
3634void QgsMapCanvas::schedulePreviewJob(
int number )
3636 mPreviewTimer.setSingleShot(
true );
3637 mPreviewTimer.setInterval( PREVIEW_JOB_DELAY_MS );
3638 disconnect( mPreviewTimerConnection );
3639 mPreviewTimerConnection = connect( &mPreviewTimer, &QTimer::timeout,
this, [ = ]()
3641 startPreviewJob( number );
3643 mPreviewTimer.start();
3646bool QgsMapCanvas::panOperationInProgress()
3651 if (
QgsMapToolPan *panTool = qobject_cast< QgsMapToolPan *>( mMapTool ) )
3653 if ( panTool->isDragging() )
3660int QgsMapCanvas::nextZoomLevel(
const QList<double> &resolutions,
bool zoomIn )
const
3662 int resolutionLevel = -1;
3664 int nResolutions = resolutions.size();
3666 for (
int i = 0; i < nResolutions; ++i )
3668 if (
qgsDoubleNear( resolutions[i], currentResolution, 0.0001 ) )
3670 resolutionLevel =
zoomIn ? ( i - 1 ) : ( i + 1 );
3673 else if ( currentResolution <= resolutions[i] )
3675 resolutionLevel =
zoomIn ? ( i - 1 ) : i;
3678 resolutionLevel =
zoomIn ? i : i + 1;
3681 if ( resolutionLevel < 0 || resolutionLevel >= nResolutions )
3685 if (
zoomIn && resolutionLevel == nResolutions - 1 && resolutions[nResolutions - 1] < currentResolution / mWheelZoomFactor )
3690 if ( !
zoomIn && resolutionLevel == 0 && resolutions[0] > mWheelZoomFactor * currentResolution )
3695 return resolutionLevel;
3700 if ( !mZoomResolutions.isEmpty() )
3702 int zoomLevel = nextZoomLevel( mZoomResolutions,
true );
3703 if ( zoomLevel != -1 )
3708 return 1 / mWheelZoomFactor;
3713 if ( !mZoomResolutions.isEmpty() )
3715 int zoomLevel = nextZoomLevel( mZoomResolutions,
false );
3716 if ( zoomLevel != -1 )
3721 return mWheelZoomFactor;
QFlags< MapSettingsFlag > MapSettingsFlags
Map settings flags.
@ MediumString
A medium-length string, recommended for general purpose use.
DistanceUnit
Units of distance.
@ Degrees
Degrees, for planar geographic CRS distance measurements.
@ ShowMainAnnotationLayer
The project's main annotation layer should be rendered in the canvas.
@ Animated
Temporal navigation relies on frames within a datetime range.
@ Movie
Movie mode – behaves like a video player, with a fixed frame duration and no temporal range.
@ FixedRange
Temporal navigation relies on a fixed datetime range.
@ Disabled
Temporal navigation is disabled.
@ Warning
Warning message.
@ AffectsLabeling
If present, indicates that the renderer will participate in the map labeling problem.
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
@ Group
Composite group layer. Added in QGIS 3.24.
@ Plugin
Plugin based layer.
@ TiledScene
Tiled scene layer. Added in QGIS 3.34.
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
@ Mesh
Mesh layer. Added in QGIS 3.2.
@ PointCloud
Point cloud layer. Added in QGIS 3.18.
@ YX
Northing/Easting (or Latitude/Longitude for geographic CRS)
@ View
Renderer used for displaying on screen.
QFlags< MapCanvasFlag > MapCanvasFlags
Flags controlling behavior of map canvases.
@ Preferred
Preferred format, matching the most recent WKT ISO standard. Currently an alias to WKT2_2019,...
@ BallparkTransformsAreAppropriate
Indicates that approximate "ballpark" results are appropriate for this coordinate transform....
@ IgnoreImpossibleTransformations
Indicates that impossible transformations (such as those which attempt to transform between two diffe...
@ DrawEditingInfo
Enable drawing of vertex markers for layers in editing mode.
@ RenderPreviewJob
Render is a 'canvas preview' render, and shortcuts should be taken to ensure fast rendering.
@ RenderMapTile
Draw map such that there are no problems between adjacent tiles.
@ RecordProfile
Enable run-time profiling while rendering.
@ UseRenderingOptimization
Enable vector simplification and other rendering optimizations.
@ RenderPartialOutput
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
@ Antialiasing
Enable anti-aliasing for map rendering.
@ DrawLabeling
Enable drawing of labels on top of the map.
@ HighQualityImageTransforms
Enable high quality image transformations, which results in better appearance of scaled or rotated ra...
Abstract base class for all 2D map controllers.
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle.
@ MaximumAngle
Maximum angle between generating radii (lines from arc center to output vertices)
virtual bool isEmpty() const
Returns true if the geometry is empty.
Represents a map layer containing a set of georeferenced annotations, e.g.
static QCursor getThemeCursor(Cursor cursor)
Helper to get a theme cursor.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QgsImageCache * imageCache()
Returns the application's image cache, used for caching resampled versions of raster images.
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
static QgsSvgCache * svgCache()
Returns the application's SVG cache, used for caching SVG images and handling parameter replacement w...
static QgsCoordinateReferenceSystemRegistry * coordinateReferenceSystemRegistry()
Returns the application's coordinate reference system (CRS) registry, which handles known CRS definit...
void userCrsChanged(const QString &id)
Emitted whenever an existing user CRS definition is changed.
static Qgis::CoordinateOrder defaultCoordinateOrderForCrs(const QgsCoordinateReferenceSystem &crs)
Returns the default coordinate order to use for the specified crs.
static QString axisDirectionToAbbreviatedString(Qgis::CrsAxisDirection axis)
Returns a translated abbreviation representing an axis direction.
This class represents a coordinate reference system (CRS).
QString userFriendlyIdentifier(Qgis::CrsIdentifierType type=Qgis::CrsIdentifierType::MediumString) const
Returns a user friendly identifier for the CRS.
void updateDefinition()
Updates the definition and parameters of the coordinate reference system to their latest values.
QList< Qgis::CrsAxisDirection > axisOrdering() const
Returns an ordered list of the axis directions reflecting the native axis order for the CRS.
Qgis::DistanceUnit mapUnits
Custom exception class for Coordinate Reference System related exceptions.
Abstract base class that may be implemented to handle new types of data to be dropped in QGIS.
Abstract base class for spatial data provider implementations.
virtual bool renderInPreview(const QgsDataProvider::PreviewContext &context)
Returns whether the layer must be rendered in preview jobs.
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
double bearing(const QgsPointXY &p1, const QgsPointXY &p2) const
Computes the bearing (in radians) between two points.
double measureLine(const QVector< QgsPointXY > &points) const
Measures the length of a line with multiple segments.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
Qgis::DistanceUnit lengthUnits() const
Returns the units of distance for length calculations made by this object.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
QgsRange which stores a range of double values.
bool isActive() const
Returns whether this shading renderer is active.
Abstract interface for generating an expression context scope.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads scope variables from an XML element.
bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes scope variables to an XML element.
bool removeVariable(const QString &name)
Removes a variable from the context scope, if found.
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * atlasScope(const QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Abstract base class for all 2D vector feature renderers.
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setLimit(long long limit)
Set the maximum number of features to request.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
bool hasGeometry() const
Returns true if the feature has an associated geometry.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsPointXY asPoint() const
Returns the contents of the geometry as a 2-dimensional point.
static QgsGeometry fromPointXY(const QgsPointXY &point)
Creates a new geometry from a QgsPointXY object.
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
A map layer which consists of a set of child layers, where all component layers are rendered as a sin...
void remoteImageFetched(const QString &url)
Emitted when the cache has finished retrieving an image file from a remote url.
Stores global configuration for labeling engine.
Class that stores computed placement from labeling engine.
static void warning(const QString &msg)
Goes to qWarning.
An interactive map canvas item which displays a QgsAnnotation.
An interface for objects which block interactions with a QgsMapCanvas.
Interaction
Available interactions to block.
An abstract class for items that can be placed on the map canvas.
virtual void updatePosition()
called on changed extent or resize event to update position of the item
Snapping utils instance that is connected to a canvas and updates the configuration (map settings + c...
Deprecated to be deleted, stuff from here should be moved elsewhere.
QPoint mouseLastXY
Last seen point of the mouse.
bool panSelectorDown
Flag to indicate the pan selector key is held down by user.
CanvasProperties()=default
Constructor for CanvasProperties.
QPoint rubberStartPoint
Beginning point of a rubber band.
bool mouseButtonDown
Flag to indicate status of mouse button.
Map canvas is a class for displaying all GIS data types on a canvas.
void setCurrentLayer(QgsMapLayer *layer)
void contextMenuAboutToShow(QMenu *menu, QgsMapMouseEvent *event)
Emitted before the map canvas context menu will be shown.
void zoomToProjectExtent()
Zoom to the full extent the project associated with this canvas.
void panToSelected(QgsMapLayer *layer=nullptr)
Pan to the selected features of current ayer keeping same extent.
void freeze(bool frozen=true)
Freeze/thaw the map canvas.
void enableAntiAliasing(bool flag)
used to determine if anti-aliasing is enabled or not
void zoomToSelected(QgsMapLayer *layer=nullptr)
Zoom to the extent of the selected features of provided map layer.
void setSnappingUtils(QgsSnappingUtils *utils)
Assign an instance of snapping utils to the map canvas.
bool isCachingEnabled() const
Check whether images of rendered layers are curerently being cached.
void zoomToFullExtent()
Zoom to the full extent of all layers currently visible in the canvas.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers that should be shown in the canvas.
void setProject(QgsProject *project)
Sets the project linked to this canvas.
const QgsRenderedItemResults * renderedItemResults(bool allowOutdatedResults=true) const
Gets access to the rendered item results (may be nullptr), which includes the results of rendering an...
void setMapController(QgsAbstract2DMapController *controller)
Sets the input controller device to use for controlling the canvas.
QColor selectionColor() const
Returns color for selected features.
bool event(QEvent *e) override
void setCachingEnabled(bool enabled)
Set whether to cache images of rendered layers.
void mouseReleaseEvent(QMouseEvent *e) override
QgsDoubleRange zRange() const
Returns the range of z-values which will be visible in the map.
void setExtent(const QgsRectangle &r, bool magnified=false)
Sets the extent of the map canvas to the specified rectangle.
void setRenderFlag(bool flag)
Sets whether a user has disabled canvas renders via the GUI.
void selectionChanged(QgsMapLayer *layer)
Emitted when selection in any layer gets changed.
QList< QgsMapCanvasAnnotationItem * > annotationItems() const
Returns a list of all annotation items in the canvas.
void updateCanvasItemPositions()
called on resize or changed extent to notify canvas items to change their rectangle
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
void extentsChanged()
Emitted when the extents of the map change.
QgsExpressionContextScope * defaultExpressionContextScope() const
Creates a new scope which contains default variables and functions relating to the map canvas.
void xyCoordinates(const QgsPointXY &p)
Emits current mouse position.
void setFlags(Qgis::MapCanvasFlags flags)
Sets flags which control how the map canvas behaves.
void stopRendering()
stop rendering (if there is any right now)
void setLabelingEngineSettings(const QgsLabelingEngineSettings &settings)
Sets global labeling engine settings in the internal map settings.
QgsPointXY center() const
Gets map center, in geographical coordinates.
void showEvent(QShowEvent *event) override
int layerCount() const
Returns number of layers on the map.
void emitExtentsChanged()
Emits the extentsChanged signal when appropriate.
bool antiAliasingEnabled() const
true if antialiasing is enabled
void setPreviewMode(QgsPreviewEffect::PreviewMode mode)
Sets a preview mode for the map canvas.
QVector< T > layers() const
Returns a list of registered map layers with a specified layer type.
void layerStateChange()
This slot is connected to the visibility change of one or more layers.
QgsPreviewEffect::PreviewMode previewMode() const
Returns the current preview mode for the map canvas.
void zoomScale(double scale, bool ignoreScaleLock=false)
Zooms the canvas to a specific scale.
void zoomWithCenter(int x, int y, bool zoomIn)
Zooms in/out with a given center.
QPoint mouseLastXY()
returns last position of mouse cursor
void clearCache()
Make sure to remove any rendered images from cache (does nothing if cache is not enabled)
void tapAndHoldGestureOccurred(const QgsPointXY &mapPoint, QTapAndHoldGesture *gesture)
Emitted whenever a tap and hold gesture occurs at the specified map point.
const QgsDateTimeRange & temporalRange() const
Returns map canvas datetime range.
void setCanvasColor(const QColor &_newVal)
Write property of QColor bgColor.
void panDistanceBearingChanged(double distance, Qgis::DistanceUnit unit, double bearing)
Emitted whenever the distance or bearing of an in-progress panning operation is changed.
void zoomByFactor(double scaleFactor, const QgsPointXY *center=nullptr, bool ignoreScaleLock=false)
Zoom with the factor supplied.
const QgsTemporalController * temporalController() const
Gets access to the temporal controller that will be used to update the canvas temporal range.
void flashGeometries(const QList< QgsGeometry > &geometries, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem(), const QColor &startColor=QColor(255, 0, 0, 255), const QColor &endColor=QColor(255, 0, 0, 0), int flashes=3, int duration=500)
Causes a set of geometries to flash within the canvas.
void setMapUpdateInterval(int timeMilliseconds)
Set how often map preview should be updated while it is being rendered (in milliseconds)
bool setReferencedExtent(const QgsReferencedRectangle &extent)
Sets the canvas to the specified extent.
void dragEnterEvent(QDragEnterEvent *e) override
QgsMapRendererCache * cache()
Returns the map renderer cache, if caching is enabled.
bool isDrawing()
Find out whether rendering is in progress.
void zRangeChanged()
Emitted when the map canvas z (elevation) range changes.
void keyPressEvent(QKeyEvent *e) override
void setZRange(const QgsDoubleRange &range)
Sets the range of z-values which will be visible in the map.
void clearExtentHistory()
Clears the list of extents and sets current extent as first item.
void zoomToPreviousExtent()
Zoom to the previous extent (view)
void enableMapTileRendering(bool flag)
sets map tile rendering flag
void panAction(QMouseEvent *event)
Called when mouse is moving and pan is activated.
void setLayerStyleOverrides(const QMap< QString, QString > &overrides)
Sets the stored overrides of styles for rendering layers.
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns global labeling engine settings from the internal map settings.
void scaleChanged(double scale)
Emitted when the scale of the map changes.
void mapToolSet(QgsMapTool *newTool, QgsMapTool *oldTool)
Emit map tool changed with the old tool.
void canvasColorChanged()
Emitted when canvas background color changes.
double zoomInFactor() const
Returns the zoom in factor.
void saveAsImage(const QString &fileName, QPixmap *QPixmap=nullptr, const QString &="PNG")
Save the contents of the map canvas to disk as an image.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
void setTemporalRange(const QgsDateTimeRange &range)
Set datetime range for the map canvas.
void moveCanvasContents(bool reset=false)
called when panning is in action, reset indicates end of panning
void magnificationChanged(double magnification)
Emitted when the scale of the map changes.
void zoomOut()
Zoom out with fixed factor.
void currentLayerChanged(QgsMapLayer *layer)
Emitted when the current layer is changed.
void setTemporalController(QgsTemporalController *controller)
Sets the temporal controller for this canvas.
void renderErrorOccurred(const QString &error, QgsMapLayer *layer)
Emitted whenever an error is encountered during a map render operation.
void addOverlayWidget(QWidget *widget, Qt::Edge edge)
Adds an overlay widget to the layout, which will be bound to the specified edge.
void waitWhileRendering()
Blocks until the rendering job has finished.
void mapRefreshCanceled()
Emitted when the pending map refresh has been canceled.
double magnificationFactor() const
Returns the magnification factor.
void writeProject(QDomDocument &)
called to write map canvas settings to project
void mousePressEvent(QMouseEvent *e) override
void updateScale()
Emits signal scaleChanged to update scale in main window.
void setMagnificationFactor(double factor, const QgsPointXY *center=nullptr)
Sets the factor of magnification to apply to the map canvas.
void refreshAllLayers()
Reload all layers (including refreshing layer properties from their data sources),...
void unsetMapTool(QgsMapTool *mapTool)
Unset the current map tool or last non zoom tool.
void panActionEnd(QPoint releasePoint)
Ends pan action and redraws the canvas.
void resizeEvent(QResizeEvent *e) override
double zoomOutFactor() const
Returns the zoom in factor.
void renderStarting()
Emitted when the canvas is about to be rendered.
void setMapSettingsFlags(Qgis::MapSettingsFlags flags)
Resets the flags for the canvas' map settings.
std::unique_ptr< CanvasProperties > mCanvasProperties
Handle pattern for implementation object.
void keyReleased(QKeyEvent *e)
Emit key release event.
QgsMapTool * mapTool() const
Returns the currently active tool.
void setWheelFactor(double factor)
Sets wheel zoom factor (should be greater than 1)
void setAnnotationsVisible(bool visible)
Sets whether annotations are visible in the canvas.
void layerStyleOverridesChanged()
Emitted when the configuration of overridden layer styles changes.
QgsMapCanvas(QWidget *parent=nullptr)
Constructor.
void panActionStart(QPoint releasePoint)
Starts a pan action.
void zoomNextStatusChanged(bool available)
Emitted when zoom next status changed.
void setPreviewJobsEnabled(bool enabled)
Sets whether canvas map preview jobs (low priority render jobs which render portions of the view just...
QgsRectangle fullExtent() const
Returns the combined extent for all layers on the map canvas.
void redrawAllLayers()
Clears all cached images and redraws all layers.
void keyReleaseEvent(QKeyEvent *e) override
bool isFrozen() const
Returns true if canvas is frozen.
void rotationChanged(double rotation)
Emitted when the rotation of the map changes.
void panToFeatureIds(QgsVectorLayer *layer, const QgsFeatureIds &ids, bool alwaysRecenter=true)
Centers canvas extent to feature ids.
void messageEmitted(const QString &title, const QString &message, Qgis::MessageLevel level=Qgis::MessageLevel::Info)
emit a message (usually to be displayed in a message bar)
void scaleLockChanged(bool locked)
Emitted when the scale locked state of the map changes.
const QgsLabelingResults * labelingResults(bool allowOutdatedResults=true) const
Gets access to the labeling results (may be nullptr).
void mouseMoveEvent(QMouseEvent *e) override
QgsRectangle projectExtent() const
Returns the associated project's full extent, in the canvas' CRS.
void setCenter(const QgsPointXY ¢er)
Set the center of the map canvas, in geographical coordinates.
void setParallelRenderingEnabled(bool enabled)
Set whether the layers are rendered in parallel or sequentially.
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets destination coordinate reference system.
void flashFeatureIds(QgsVectorLayer *layer, const QgsFeatureIds &ids, const QColor &startColor=QColor(255, 0, 0, 255), const QColor &endColor=QColor(255, 0, 0, 0), int flashes=3, int duration=500)
Causes a set of features with matching ids from a vector layer to flash within the canvas.
void installInteractionBlocker(QgsMapCanvasInteractionBlocker *blocker)
Installs an interaction blocker onto the canvas, which may prevent certain map canvas interactions fr...
bool isParallelRenderingEnabled() const
Check whether the layers are rendered in parallel or sequentially.
double scale() const
Returns the last reported scale of the canvas.
QgsSnappingUtils * snappingUtils() const
Returns snapping utility class that is associated with map canvas.
Qgis::DistanceUnit mapUnits() const
Convenience function for returning the current canvas map units.
double rotation() const
Gets the current map canvas rotation in clockwise degrees.
void temporalRangeChanged()
Emitted when the map canvas temporal range changes.
void paintEvent(QPaintEvent *e) override
void zoomLastStatusChanged(bool available)
Emitted when zoom last status changed.
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
void themeChanged(const QString &theme)
Emitted when the canvas has been assigned a different map theme.
void destinationCrsChanged()
Emitted when map CRS has changed.
void transformContextChanged()
Emitted when the canvas transform context is changed.
void keyPressed(QKeyEvent *e)
Emit key press event.
void setMapTool(QgsMapTool *mapTool, bool clean=false)
Sets the map tool currently being used on the canvas.
QColor canvasColor() const
Read property of QColor bgColor.
void mapCanvasRefreshed()
Emitted when canvas finished a refresh request.
int mapUpdateInterval() const
Find out how often map preview should be updated while it is being rendered (in milliseconds)
void setSelectionColor(const QColor &color)
Set color of selected vector features.
double mapUnitsPerPixel() const
Returns the mapUnitsPerPixel (map units per pixel) for the canvas.
void mouseDoubleClickEvent(QMouseEvent *e) override
void selectionChangedSlot()
Receives signal about selection change, and pass it on with layer info.
bool viewportEvent(QEvent *event) override
void setCustomDropHandlers(const QVector< QPointer< QgsCustomDropHandler > > &handlers)
Sets a list of custom drop handlers to use when drop events occur on the canvas.
void zoomToNextExtent()
Zoom to the next extent (view)
void layersChanged()
Emitted when a new set of layers has been received.
void zoomToFeatureIds(QgsVectorLayer *layer, const QgsFeatureIds &ids)
Set canvas extent to the bounding box of a set of features.
void renderComplete(QPainter *painter)
Emitted when the canvas has rendered.
void zoomIn()
Zoom in with fixed factor.
QgsMapLayer * layer(int index)
Returns the map layer at position index in the layer stack.
void cancelJobs()
Cancel any rendering job, in a blocking way.
Qgis::MapCanvasFlags flags() const
Returns flags which control how the map canvas behaves.
bool allowInteraction(QgsMapCanvasInteractionBlocker::Interaction interaction) const
Returns true if the specified interaction is currently permitted on the canvas.
void wheelEvent(QWheelEvent *e) override
bool previewModeEnabled() const
Returns whether a preview mode is enabled for the map canvas.
const QgsMapToPixel * getCoordinateTransform()
Gets the current coordinate transform.
void dropEvent(QDropEvent *event) override
void setPreviewModeEnabled(bool previewEnabled)
Enables a preview mode for the map canvas.
QgsProject * project()
Returns the project linked to this canvas.
void setScaleLocked(bool isLocked)
Lock the scale, so zooming can be performed using magnication.
void setRotation(double degrees)
Set the rotation of the map canvas in clockwise degrees.
void removeInteractionBlocker(QgsMapCanvasInteractionBlocker *blocker)
Removes an interaction blocker from the canvas.
void readProject(const QDomDocument &)
called to read map canvas settings from project
void setTheme(const QString &theme)
Sets a map theme to show in the canvas.
void zoomToFeatureExtent(QgsRectangle &rect)
Zooms to feature extent.
QMap< QString, QString > layerStyleOverrides() const
Returns the stored overrides of styles for layers.
const QgsMapSettings & mapSettings() const
Gets access to properties used for map rendering.
QgsRectangle extent() const
Returns the current zoom extent of the map canvas.
void refresh()
Repaints the canvas map.
QgsMapLayer * currentLayer()
returns current layer (set by legend widget)
virtual QgsMapLayerElevationProperties::Flags flags() const
Returns flags associated to the elevation properties.
@ FlagDontInvalidateCachedRendersWhenRangeChanges
Any cached rendering will not be invalidated when z range context is modified.
virtual bool hasElevation() const
Returns true if the layer has an elevation or z component.
static QgsRectangle combinedExtent(const QList< QgsMapLayer * > &layers, const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &transformContext)
Returns the combined extent of a list of layers.
Base class for all map layer types.
virtual bool isSpatial() const
Returns true if the layer is considered a spatial layer, ie it has some form of geometry associated w...
Q_INVOKABLE QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
void autoRefreshIntervalChanged(int interval)
Emitted when the auto refresh interval changes.
QgsCoordinateReferenceSystem crs
Q_DECL_DEPRECATED bool hasAutoRefreshEnabled() const
Returns true if auto refresh is enabled for the layer.
void rendererChanged()
Signal emitted when renderer is changed.
virtual QgsMapLayerTemporalProperties * temporalProperties()
Returns the layer's temporal properties.
void repaintRequested(bool deferredUpdate=false)
By emitting this signal the layer tells that either appearance or content have been changed and any v...
virtual QgsMapLayerElevationProperties * elevationProperties()
Returns the layer's elevation properties.
virtual Q_INVOKABLE QgsDataProvider * dataProvider()
Returns the layer's data provider, it may be nullptr.
virtual Q_INVOKABLE void reload()
Synchronises with changes in the datasource.
A QgsMapMouseEvent is the result of a user interaction with the mouse on a QgsMapCanvas.
This class is responsible for keeping cache of rendered images resulting from a map rendering job.
void clear()
Invalidates the cache contents, clearing all cached images.
void invalidateCacheForLayer(QgsMapLayer *layer)
Invalidates cached images which relate to the specified map layer.
void clearCacheImage(const QString &cacheKey)
Removes an image from the cache with matching cacheKey.
Job implementation that renders everything sequentially using a custom painter.
void waitForFinished() override
Block until the job has finished.
virtual void waitForFinished()=0
Block until the job has finished.
void setCache(QgsMapRendererCache *cache)
Assign a cache to be used for reading and storing rendered images of individual layers.
QHash< QgsMapLayer *, int > perLayerRenderingTime() const
Returns the render time (in ms) per layer.
virtual bool usedCachedLabels() const =0
Returns true if the render job was able to use a cached labeling solution.
Errors errors() const
List of errors that happened during the rendering job - available when the rendering has been finishe...
const QgsMapSettings & mapSettings() const
Returns map settings with which this job was started.
void finished()
emitted when asynchronous rendering is finished (or canceled).
static const QgsSettingsEntryBool * settingsLogCanvasRefreshEvent
Settings entry log canvas refresh event.
void start()
Start the rendering job and immediately return.
int renderingTime() const
Returns the total time it took to finish the job (in milliseconds).
QStringList layersRedrawnFromCache() const
Returns a list of the layer IDs for all layers which were redrawn from cached images.
QList< QgsMapRendererJob::Error > Errors
QgsRenderedItemResults * takeRenderedItemResults()
Takes the rendered item results from the map render job and returns them.
virtual bool isActive() const =0
Tell whether the rendering job is currently running in background.
virtual QgsLabelingResults * takeLabelingResults()=0
Gets pointer to internal labeling engine (in order to get access to the results).
virtual void cancel()=0
Stop the rendering job - does not return until the job has terminated.
void setLayerRenderingTimeHints(const QHash< QString, int > &hints)
Sets approximate render times (in ms) for map layers.
virtual void cancelWithoutBlocking()=0
Triggers cancellation of the rendering job without blocking.
Job implementation that renders all layers in parallel.
Intermediate base class adding functionality that allows client to query the rendered image.
virtual QImage renderedImage()=0
Gets a preview/resulting image.
Job implementation that renders everything sequentially in one thread.
static QString worldFileContent(const QgsMapSettings &mapSettings)
Creates the content of a world file.
The QgsMapSettings class contains configuration for rendering of the map.
void setElevationShadingRenderer(const QgsElevationShadingRenderer &renderer)
Sets the shading renderer used to render shading on the entire map.
Qgis::DistanceUnit mapUnits() const
Returns the units of the map's geographical coordinates - used for scale calculation.
void writeXml(QDomNode &node, QDomDocument &doc)
Writes the map settings to an XML node.
QgsPointXY layerToMapCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from layer's CRS to output CRS
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns the global configuration of the labeling engine.
QList< QgsMapLayer * > layers(bool expandGroupLayers=false) const
Returns the list of layers which will be rendered in the map.
void setSelectionColor(const QColor &color)
Sets the color that is used for drawing of selected vector features.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers to render in the map.
double scale() const
Returns the calculated map scale.
void setFrameRate(double rate)
Sets the frame rate of the map (in frames per second), for maps which are part of an animation.
void setFlags(Qgis::MapSettingsFlags flags)
Sets combination of flags that will be used for rendering.
QgsRectangle layerExtentToOutputExtent(const QgsMapLayer *layer, QgsRectangle extent) const
transform bounding box from layer's CRS to output CRS
QgsDoubleRange zRange() const
Returns the range of z-values which will be visible in the map.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
void setDpiTarget(double dpi)
Sets the target dpi (dots per inch) to be taken into consideration when rendering.
double magnificationFactor() const
Returns the magnification factor.
QStringList layerIds(bool expandGroupLayers=false) const
Returns the list of layer IDs which will be rendered in the map.
void setDevicePixelRatio(float dpr)
Sets the device pixel ratio.
void setZRange(const QgsDoubleRange &range)
Sets the range of z-values which will be visible in the map.
QColor backgroundColor() const
Returns the background color of the map.
void setOutputDpi(double dpi)
Sets the dpi (dots per inch) used for conversion between real world units (e.g.
const QgsMapToPixel & mapToPixel() const
double mapUnitsPerPixel() const
Returns the distance in geographical coordinates that equals to one pixel in the map.
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the rendering usage.
float devicePixelRatio() const
Returns the device pixel ratio.
QSize outputSize() const
Returns the size of the resulting map image, in pixels.
QgsRectangle extent() const
Returns geographical coordinates of the rectangle that should be rendered.
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
void setLayerStyleOverrides(const QMap< QString, QString > &overrides)
Sets the map of map layer style overrides (key: layer ID, value: style name) where a different style ...
void setExtent(const QgsRectangle &rect, bool magnified=true)
Sets the coordinates of the rectangle which should be rendered.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
QColor selectionColor() const
Returns the color that is used for drawing of selected vector features.
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes output image size into account.
void setLabelingEngineSettings(const QgsLabelingEngineSettings &settings)
Sets the global configuration of the labeling engine.
QgsRectangle fullExtent() const
returns current extent of layer set
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
void setRotation(double rotation)
Sets the rotation of the resulting map image, in degrees clockwise.
void setCurrentFrame(long long frame)
Sets the current frame of the map, for maps which are part of an animation.
const QgsElevationShadingRenderer & elevationShadingRenderer() const
Returns the shading renderer used to render shading on the entire map.
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
bool testFlag(Qgis::MapSettingsFlag flag) const
Check whether a particular flag is enabled.
QMap< QString, QString > layerStyleOverrides() const
Returns the map of map layer style overrides (key: layer ID, value: style name) where a different sty...
double rotation() const
Returns the rotation of the resulting map image, in degrees clockwise.
bool hasValidSettings() const
Check whether the map settings are valid and can be used for rendering.
void setOutputSize(QSize size)
Sets the size of the resulting map image, in pixels.
QgsPointXY mapToLayerCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from output CRS to layer's CRS
void setBackgroundColor(const QColor &color)
Sets the background color of the map.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
void setFlag(Qgis::MapSettingsFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination crs (coordinate reference system) for the map render.
void readXml(QDomNode &node)
Restore the map settings from a XML node.
void setMagnificationFactor(double factor, const QgsPointXY *center=nullptr)
Set the magnification factor.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
void mapThemesChanged()
Emitted when map themes within the collection are changed.
void mapThemeRenamed(const QString &name, const QString &newName)
Emitted when a map theme within the collection is renamed.
bool hasMapTheme(const QString &name) const
Returns whether a map theme with a matching name exists.
QMap< QString, QString > mapThemeStyleOverrides(const QString &name)
Gets layer style overrides (for QgsMapSettings) of the visible layers for given map theme.
void mapThemeChanged(const QString &theme)
Emitted when a map theme changes definition.
Perform transforms between map coordinates and device coordinates.
double mapUnitsPerPixel() const
Returns the current map units per pixel.
QgsPointXY toMapCoordinates(int x, int y) const
Transforms device coordinates to map (world) coordinates.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
static bool isUriList(const QMimeData *data)
QList< QgsMimeDataUtils::Uri > UriList
static UriList decodeUriList(const QMimeData *data)
A class to represent a 2D point.
double sqrDist(double x, double y) const
Returns the squared distance between this point a specified x, y coordinate.
A graphics effect which can be applied to a widget to simulate various printing and color blindness m...
void setMode(PreviewMode mode)
Sets the mode for the preview effect, which controls how the effect modifies a widgets appearance.
PreviewMode mode() const
Returns the mode used for the preview effect.
double defaultRotation() const
Returns the default map rotation (in clockwise degrees) for maps in the project.
QgsReferencedRectangle defaultViewExtent() const
Returns the default view extent, which should be used as the initial map extent when this project is ...
QgsReferencedRectangle fullExtent() const
Returns the full extent of the project, which represents the maximal limits of the project.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
static QgsProject * instance()
Returns the QgsProject singleton instance.
Q_INVOKABLE QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
QgsPathResolver pathResolver() const
Returns path resolver object with considering whether the project uses absolute or relative paths and...
QgsAnnotationLayer * mainAnnotationLayer()
Returns the main annotation layer associated with the project.
void ellipsoidChanged(const QString &ellipsoid)
Emitted when the project ellipsoid is changed.
QgsMapThemeCollection * mapThemeCollection
void projectColorsChanged()
Emitted whenever the project's color scheme has been changed.
QgsCoordinateTransformContext transformContext
QgsElevationShadingRenderer elevationShadingRenderer() const
Returns the elevation shading renderer used for map shading.
void elevationShadingRendererChanged()
Emitted when the map shading renderer changes.
void readProject(const QDomDocument &document)
Emitted when a project is being read.
const QgsProjectViewSettings * viewSettings() const
Returns the project's view settings, which contains settings and properties relating to how a QgsProj...
void transformContextChanged()
Emitted when the project transformContext() is changed.
void writeProject(QDomDocument &document)
Emitted when the project is being written.
A generic dialog to prompt the user for a Coordinate Reference System.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
void scale(double scaleFactor, const QgsPointXY *c=nullptr)
Scale the rectangle around its center point.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
void setYMinimum(double y)
Set the minimum y value.
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
void setXMinimum(double x)
Set the minimum x value.
double width() const
Returns the width of the rectangle.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
bool isNull() const
Test if the rectangle is null (holding no spatial information).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
void setYMaximum(double y)
Set the maximum y value.
QgsPointXY center() const
Returns the center point of the rectangle.
void setXMaximum(double x)
Set the maximum x value.
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
bool isEmpty() const
Returns true if the rectangle has no area.
double height() const
Returns the height of the rectangle.
void setNull()
Mark a rectangle as being null (holding no spatial information).
A QgsRectangle with associated coordinate reference system.
Stores collated details of rendered items during a map rendering operation.
void transferResults(QgsRenderedItemResults *other, const QStringList &layerIds)
Transfers all results from an other QgsRenderedItemResults object where the items have layer IDs matc...
A class for drawing transient features (e.g.
void setWidth(double width)
Sets the width of the line.
void setSecondaryStrokeColor(const QColor &color)
Sets a secondary stroke color for the rubberband which will be drawn under the main stroke color.
@ ICON_CIRCLE
A circle is used to highlight points (○)
void setStrokeColor(const QColor &color)
Sets the stroke color for the rubberband.
QColor secondaryStrokeColor
void setIcon(IconType icon)
Sets the icon type to highlight point geometries.
void updatePosition() override
called on changed extent or resize event to update position of the item
void addGeometry(const QgsGeometry &geometry, QgsMapLayer *layer, bool doUpdate=true)
Adds the geometry of an existing feature to a rubberband This is useful for multi feature highlightin...
void setFillColor(const QColor &color)
Sets the fill color for the rubberband.
void clear(const QString &group="startup")
clear Clear all profile data.
Scoped object for saving and restoring a QPainter object's state.
Scoped object for logging of the runtime for a single operation or group of operations.
A utility class for dynamic handling of changes to screen properties.
void screenDpiChanged(double dpi)
Emitted whenever the screen dpi associated with the widget is changed.
static const QgsSettingsEntryBool * settingsRespectScreenDPI
Settings entry respect screen dpi.
This class is a composition of two QSettings instances:
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
void setValue(const QString &key, const QVariant &value, QgsSettings::Section section=QgsSettings::NoSection)
Sets the value of setting key to value.
T enumValue(const QString &key, const T &defaultValue, const Section section=NoSection)
Returns the setting value for a setting based on an enum.
This class has all the configuration of snapping and can return answers to snapping queries.
void remoteSvgFetched(const QString &url)
Emitted when the cache has finished retrieving an SVG file from a remote url.
static double rendererFrameRate(const QgsFeatureRenderer *renderer)
Calculates the frame rate (in frames per second) at which the given renderer must be redrawn.
A controller base class for temporal objects, contains a signal for notifying updates of the objects ...
void updateTemporalRange(const QgsDateTimeRange &range)
Signals that a temporal range has changed and needs to be updated in all connected objects.
Implements a temporal controller based on a frame by frame navigation and animation.
void navigationModeChanged(Qgis::TemporalNavigationMode mode)
Emitted whenever the navigation mode changes.
bool isActive() const
Returns true if the temporal property is active.
virtual QgsTemporalProperty::Flags flags() const
Returns flags associated to the temporal property.
@ FlagDontInvalidateCachedRendersWhenRangeChanges
Any cached rendering will not be invalidated when temporal range context is modified.
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
void setIsTemporal(bool enabled)
Sets whether the temporal range is enabled (i.e.
void setTemporalRange(const QgsDateTimeRange &range)
Sets the temporal range for the object.
T begin() const
Returns the beginning of the range.
T end() const
Returns the upper bound of the range.
Temporarily sets a cursor override for the QApplication for the lifetime of the object.
void release()
Releases the cursor override early (i.e.
Represents a vector layer which manages a vector based data sets.
Q_INVOKABLE QgsRectangle boundingBoxOfSelected() const
Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,...
int selectedFeatureCount() const
Returns the number of features that are selected in this layer.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
void selectionChanged(const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect)
Emitted when selection was changed.
Implements a map layer that is dedicated to rendering of vector tiles.
QList< QgsFeature > selectedFeatures() const
Returns the list of features currently selected in the layer.
void selectionChanged()
Emitted whenever the selected features in the layer are changed.
int selectedFeatureCount() const
Returns the number of features that are selected in this layer.
A class to represent a vector.
static Qgis::GeometryType geometryType(Qgis::WkbType type)
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
constexpr double CANVAS_MAGNIFICATION_MIN
Minimum magnification level allowed in map canvases.
constexpr double CANVAS_MAGNIFICATION_MAX
Maximum magnification level allowed in map canvases.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
QgsSignalBlocker< Object > whileBlocking(Object *object)
Temporarily blocks signals from a QObject while calling a single method from the object.
QSet< QgsFeatureId > QgsFeatureIds
#define QgsDebugMsgLevel(str, level)
#define QgsDebugError(str)
QList< QgsMapLayer * > filterLayersForRender(const QList< QgsMapLayer * > &layers)
const QgsCoordinateReferenceSystem & crs
Stores settings related to the context in which a preview job runs.
double maxRenderingTimeMs
Default maximum allowable render time, in ms.
double lastRenderingTimeMs
Previous rendering time for the layer, in ms.