21#include <QApplication>
25#include <QGraphicsItem>
26#include <QGraphicsScene>
27#include <QGraphicsView>
34#include <QResizeEvent>
42#include <QVariantAnimation>
43#include <QPropertyAnimation>
126 : QGraphicsView( parent )
128 , mExpressionContextScope( tr(
"Map Canvas" ) )
130 mScene =
new QGraphicsScene();
132 setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
133 setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
134 setMouseTracking(
true );
135 setFocusPolicy( Qt::StrongFocus );
140 mResizeTimer =
new QTimer(
this );
141 mResizeTimer->setSingleShot(
true );
144 mRefreshTimer =
new QTimer(
this );
145 mRefreshTimer->setSingleShot(
true );
146 connect( mRefreshTimer, &QTimer::timeout,
this, &QgsMapCanvas::refreshMap );
149 mMap =
new QgsMapCanvasMap(
this );
190 setDestinationCrs( crs );
203 double segmentationTolerance = settings.
value( QStringLiteral(
"qgis/segmentationTolerance" ),
"0.01745" ).toDouble();
208 mWheelZoomFactor = settings.
value( QStringLiteral(
"qgis/zoom_factor" ), 2 ).toDouble();
210 QSize s = viewport()->size();
215 setSceneRect( 0, 0, s.width(), s.height() );
216 mScene->setSceneRect( QRectF( 0, 0, s.width(), s.height() ) );
220 connect( &mMapUpdateTimer, &QTimer::timeout,
this, &QgsMapCanvas::mapUpdateTimeout );
221 mMapUpdateTimer.setInterval( 250 );
226 grabGesture( Qt::PinchGesture );
227 grabGesture( Qt::TapAndHoldGesture );
228 viewport()->setAttribute( Qt::WA_AcceptTouchEvents );
232 viewport()->setGraphicsEffect( mPreviewEffect );
236 connect( &mAutoRefreshTimer, &QTimer::timeout,
this, &QgsMapCanvas::autoRefreshTriggered );
240 setInteractive(
false );
256 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
264 const QList< QgsMapTool * > tools = findChildren< QgsMapTool *>();
267 tool->mCanvas =
nullptr;
270 mLastNonZoomMapTool =
nullptr;
277 qDeleteAll( mScene->items() );
279 mScene->deleteLater();
296 for (
auto previewJob = mPreviewJobs.constBegin(); previewJob != mPreviewJobs.constEnd(); ++previewJob )
304 mPreviewJobs.clear();
312 factor = std::clamp( factor, magnifierMin, magnifierMax );
347 if ( index >= 0 && index <
layers.size() )
370 if ( mCurrentLayer ==
layer )
373 mCurrentLayer =
layer;
384 return nullptr != mJob;
397 if ( !mTheme.isEmpty() )
400 setLayersPrivate(
layers );
403void QgsMapCanvas::setLayersPrivate(
const QList<QgsMapLayer *> &layers )
405 QList<QgsMapLayer *> oldLayers = mSettings.
layers();
408 if (
layers == oldLayers )
411 const auto constOldLayers = oldLayers;
445 const auto constLayers =
layers;
483 updateAutoRefreshTimer();
512 QgsDebugMsg( QStringLiteral(
"Transform error caught: %1" ).arg( e.
what() ) );
520 mBlockItemPositionUpdates++;
522 mBlockItemPositionUpdates--;
529 QgsDebugMsgLevel( QStringLiteral(
"refreshing after destination CRS changed" ), 2 );
549 mController = controller;
555void QgsMapCanvas::temporalControllerModeChanged()
559 switch ( temporalNavigationObject->navigationMode() )
562 mSettings.
setFrameRate( temporalNavigationObject->framesPerSecond() );
563 mSettings.
setCurrentFrame( temporalNavigationObject->currentFrameNumber() );
591 if ( !allowOutdatedResults && mLabelingResultsOutdated )
594 return mLabelingResults.get();
599 if ( !allowOutdatedResults && mRenderedItemResultsOutdated )
602 return mRenderedItemResults.get();
625 mPreviousRenderedItemResults.reset();
630 return nullptr != mCache;
638 if ( mPreviousRenderedItemResults )
639 mPreviousRenderedItemResults.reset();
640 if ( mRenderedItemResults )
641 mRenderedItemResults.reset();
646 mUseParallelRendering = enabled;
651 return mUseParallelRendering;
656 mMapUpdateTimer.setInterval( timeMilliseconds );
661 return mMapUpdateTimer.interval();
667 return mCurrentLayer;
687 expressionContext << generator->createExpressionContextScope();
691 return expressionContext;
698 QgsDebugMsgLevel( QStringLiteral(
"CANVAS refresh - invalid settings -> nothing to do" ), 2 );
702 if ( !mRenderFlag || mFrozen )
708 if ( mRefreshScheduled )
710 QgsDebugMsgLevel( QStringLiteral(
"CANVAS refresh already scheduled" ), 2 );
714 mRefreshScheduled =
true;
719 mRefreshTimer->start( 1 );
721 mLabelingResultsOutdated =
true;
722 mRenderedItemResultsOutdated =
true;
725void QgsMapCanvas::refreshMap()
727 Q_ASSERT( mRefreshScheduled );
739 switch ( temporalNavigationObject->navigationMode() )
742 mSettings.
setFrameRate( temporalNavigationObject->framesPerSecond() );
743 mSettings.
setCurrentFrame( temporalNavigationObject->currentFrameNumber() );
754 if ( !mTheme.isEmpty() )
767 QList<QgsMapLayer *> allLayers = renderSettings.
layers();
773 mJobCanceled =
false;
774 if ( mUseParallelRendering )
791 mRefreshScheduled =
false;
793 mMapUpdateTimer.start();
798void QgsMapCanvas::mapThemeChanged(
const QString &theme )
800 if (
theme == mTheme )
805 setLayersPrivate(
QgsProject::instance()->mapThemeCollection()->mapThemeVisibleLayers( mTheme ) );
818void QgsMapCanvas::mapThemeRenamed(
const QString &theme,
const QString &newTheme )
820 if ( mTheme.isEmpty() ||
theme != mTheme )
829void QgsMapCanvas::rendererJobFinished()
831 QgsDebugMsgLevel( QStringLiteral(
"CANVAS finish! %1" ).arg( !mJobCanceled ), 2 );
833 mMapUpdateTimer.stop();
835 notifyRendererErrors( mJob->
errors() );
845 mLabelingResultsOutdated =
false;
849 if ( mRenderedItemResults )
853 if ( mPreviousRenderedItemResults )
859 if ( mCache && !mPreviousRenderedItemResults )
860 mPreviousRenderedItemResults = std::make_unique< QgsRenderedItemResults >( mJob->
mapSettings().
extent() );
862 if ( mRenderedItemResults && mPreviousRenderedItemResults )
867 mPreviousRenderedItemResults->transferResults( mRenderedItemResults.get() );
869 if ( mPreviousRenderedItemResults )
875 mRenderedItemResultsOutdated =
false;
885 QString logMsg = tr(
"Canvas refresh: %1 ms" ).arg( mJob->
renderingTime() );
889 if ( mDrawRenderingStats )
891 int w = img.width(), h = img.height();
892 QFont fnt = p.font();
895 int lh = p.fontMetrics().height() * 2;
896 QRect r( 0, h - lh, w, lh );
897 p.setPen( Qt::NoPen );
898 p.setBrush( QColor( 0, 0, 0, 110 ) );
900 p.setPen( Qt::white );
901 QString msg = QStringLiteral(
"%1 :: %2 ms" ).arg( mUseParallelRendering ? QStringLiteral(
"PARALLEL" ) : QStringLiteral(
"SEQUENTIAL" ) ).arg( mJob->
renderingTime() );
902 p.drawText( r, msg, QTextOption( Qt::AlignCenter ) );
907 mMap->setContent( img, imageRect( img, mSettings ) );
909 mLastLayerRenderTime.clear();
911 for (
auto it = times.constBegin(); it != times.constEnd(); ++it )
913 mLastLayerRenderTime.insert( it.key()->id(), it.value() );
915 if ( mUsePreviewJobs && !mRefreshAfterJob )
920 mRefreshAfterJob =
false;
930 if ( mRefreshAfterJob )
932 mRefreshAfterJob =
false;
933 clearTemporalCache();
934 clearElevationCache();
939void QgsMapCanvas::previewJobFinished()
947 mPreviewJobs.removeAll( job );
949 int number = job->property(
"number" ).toInt();
952 startPreviewJob( number + 1 );
969 QgsLogger::warning( QStringLiteral(
"The renderer map has a wrong device pixel ratio" ) );
973 QgsRectangle rect( topLeft.
x(), topLeft.
y(), topLeft.
x() + img.width()*res, topLeft.
y() - img.height()*res );
979 return mUsePreviewJobs;
984 mUsePreviewJobs = enabled;
989 mDropHandlers = handlers;
992void QgsMapCanvas::clearTemporalCache()
996 bool invalidateLabels =
false;
1000 bool alreadyInvalidatedThisLayer =
false;
1008 alreadyInvalidatedThisLayer =
true;
1018 if ( vl->labelsEnabled() || vl->diagramsEnabled() )
1019 invalidateLabels =
true;
1025 if ( !alreadyInvalidatedThisLayer )
1030 if ( invalidateLabels )
1038void QgsMapCanvas::clearElevationCache()
1042 bool invalidateLabels =
false;
1050 if ( vl->labelsEnabled() || vl->diagramsEnabled() )
1051 invalidateLabels =
true;
1061 if ( invalidateLabels )
1071 const QgsPointXY mapPoint =
event->originalMapPoint();
1075 QMenu *copyCoordinateMenu =
new QMenu( tr(
"Copy Coordinate" ), &menu );
1083 const QgsPointXY transformedPoint = ct.transform( mapPoint );
1086 int displayPrecision = 0;
1094 displayPrecision = 0;
1096 displayPrecision = 1;
1098 displayPrecision = 2;
1100 displayPrecision = 3;
1102 displayPrecision = 4;
1104 displayPrecision = 5;
1106 displayPrecision = 6;
1108 displayPrecision = 7;
1110 displayPrecision = 8;
1112 displayPrecision = 9;
1120 QString firstSuffix;
1121 QString secondSuffix;
1122 if ( axisList.size() >= 2 )
1128 QString firstNumber;
1129 QString secondNumber;
1132 firstNumber = QString::number( transformedPoint.
y(),
'f', displayPrecision );
1133 secondNumber = QString::number( transformedPoint.
x(),
'f', displayPrecision );
1137 firstNumber = QString::number( transformedPoint.
x(),
'f', displayPrecision );
1138 secondNumber = QString::number( transformedPoint.
y(),
'f', displayPrecision );
1141 QAction *copyCoordinateAction =
new QAction( QStringLiteral(
"%5 (%1%2, %3%4)" ).arg(
1142 firstNumber, firstSuffix, secondNumber, secondSuffix, identifier ), &menu );
1144 connect( copyCoordinateAction, &QAction::triggered,
this, [firstNumber, secondNumber, transformedPoint]
1146 QClipboard *clipboard = QApplication::clipboard();
1148 const QString coordinates = firstNumber +
',' + secondNumber;
1151 if ( clipboard->supportsSelection() )
1153 clipboard->setText( coordinates, QClipboard::Selection );
1155 clipboard->setText( coordinates, QClipboard::Clipboard );
1158 copyCoordinateMenu->addAction( copyCoordinateAction );
1172 const QString customCrsString = settings.
value( QStringLiteral(
"qgis/custom_coordinate_crs" ) ).toString();
1173 if ( !customCrsString.isEmpty() )
1181 copyCoordinateMenu->addSeparator();
1182 QAction *setCustomCrsAction =
new QAction( tr(
"Set Custom CRS…" ), &menu );
1183 connect( setCustomCrsAction, &QAction::triggered,
this, [ = ]
1187 if ( selector.exec() )
1192 copyCoordinateMenu->addAction( setCustomCrsAction );
1194 menu.addMenu( copyCoordinateMenu );
1202 menu.exec(
event->globalPos() );
1207 const QDateTime currentTime = QDateTime::currentDateTime();
1212 const QString errorKey = error.layerID +
':' + error.message;
1213 if ( mRendererErrors.contains( errorKey ) )
1215 const QDateTime sameErrorTime = mRendererErrors.value( errorKey );
1217 if ( sameErrorTime.secsTo( currentTime ) < 60 )
1221 mRendererErrors[errorKey] = currentTime;
1228void QgsMapCanvas::updateDevicePixelFromScreen()
1234 if ( window()->windowHandle() )
1236 mSettings.
setOutputDpi( window()->windowHandle()->screen()->physicalDotsPerInch() );
1237 mSettings.
setDpiTarget( window()->windowHandle()->screen()->physicalDotsPerInch() );
1243 mSettings.
setOutputDpi( window()->windowHandle()->screen()->logicalDotsPerInch() );
1244 mSettings.
setDpiTarget( window()->windowHandle()->screen()->logicalDotsPerInch() );
1255 mSettings.
setIsTemporal( dateTimeRange.begin().isValid() || dateTimeRange.end().isValid() );
1262 clearTemporalCache();
1264 autoRefreshTriggered();
1274 mInteractionBlockers.append( blocker );
1279 mInteractionBlockers.removeAll( blocker );
1286 if ( block->blockCanvasInteraction( interaction ) )
1292void QgsMapCanvas::mapUpdateTimeout()
1297 mMap->setContent( img, imageRect( img, mSettings ) );
1306 mJobCanceled =
true;
1327 image = theQPixmap->toImage();
1328 painter.begin( &image );
1338 image = mMap->contentImage().copy();
1339 painter.begin( &image );
1343 QStyleOptionGraphicsItem option;
1344 option.initFrom(
this );
1345 QGraphicsItem *item =
nullptr;
1346 QListIterator<QGraphicsItem *> i( items() );
1348 while ( i.hasPrevious() )
1350 item = i.previous();
1359 QPointF itemScenePos = item->scenePos();
1360 painter.translate( itemScenePos.x(), itemScenePos.y() );
1362 item->paint( &painter, &option );
1366 image.save( fileName, format.toLocal8Bit().data() );
1368 QFileInfo myInfo = QFileInfo( fileName );
1371 QString outputSuffix = myInfo.suffix();
1372 QString myWorldFileName = myInfo.absolutePath() +
'/' + myInfo.completeBaseName() +
'.'
1373 + outputSuffix.at( 0 ) + outputSuffix.at( myInfo.suffix().size() - 1 ) +
'w';
1374 QFile myWorldFile( myWorldFileName );
1375 if ( !myWorldFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1379 QTextStream myStream( &myWorldFile );
1415 if ( ( r == current ) && magnified )
1428 QgsDebugMsgLevel( QStringLiteral(
"Empty extent - keeping old scale with new center!" ), 2 );
1436 if ( mScaleLocked && magnified )
1438 ScaleRestorer restorer(
this );
1455 for (
int i = mLastExtent.size() - 1; i > mLastExtentIndex; i-- )
1457 mLastExtent.removeAt( i );
1460 if ( !mLastExtent.isEmpty() && mLastExtent.last() != mSettings.
extent() )
1462 mLastExtent.append( mSettings.
extent() );
1466 if ( mLastExtent.size() > 100 )
1468 mLastExtent.removeAt( 0 );
1472 mLastExtentIndex = mLastExtent.size() - 1;
1521 return mCursorPoint;
1576 if ( mLastExtentIndex > 0 )
1579 mSettings.
setExtent( mLastExtent[mLastExtentIndex] );
1592 if ( mLastExtentIndex < mLastExtent.size() - 1 )
1595 mSettings.
setExtent( mLastExtent[mLastExtentIndex] );
1607 mLastExtent.clear();
1608 mLastExtent.append( mSettings.
extent() ) ;
1609 mLastExtentIndex = mLastExtent.size() - 1;
1627 double closestSquaredDistance = pow( extentRect.
width(), 2.0 ) + pow( extentRect.
height(), 2.0 );
1628 bool pointFound =
false;
1632 double sqrDist = point.
sqrDist( centerLayerCoordinates );
1633 if ( sqrDist > closestSquaredDistance || sqrDist < 4 * std::numeric_limits<double>::epsilon() )
1636 closestPoint = point;
1637 closestSquaredDistance = sqrDist;
1643 rect.scale( scaleFactor, &
center );
1656 layer = mCurrentLayer;
1676 emit
messageEmitted( tr(
"Cannot zoom to selected feature(s)" ), tr(
"No extent could be determined." ), Qgis::MessageLevel::Warning );
1686 rect = optimalExtentForPointLayer( vlayer, rect.
center() );
1698 for (
const QgsFeature &feature : selectedFeatures )
1700 if ( !feature.hasGeometry() )
1709 emit
messageEmitted( tr(
"Cannot zoom to selected feature(s)" ), tr(
"No extent could be determined." ), Qgis::MessageLevel::Warning );
1738 if ( !mapLayer || !mapLayer->isSpatial() )
1741 switch ( mapLayer->type() )
1747 if (
layer->selectedFeatureCount() == 0 )
1750 rect =
layer->boundingBoxOfSelected();
1758 rect = optimalExtentForPointLayer(
layer, rect.
center() );
1772 for (
const QgsFeature &feature : selectedFeatures )
1774 if ( !feature.hasGeometry() )
1795 if ( selectionExtent.
isNull() )
1797 emit
messageEmitted( tr(
"Cannot zoom to selected feature(s)" ), tr(
"No extent could be determined." ), Qgis::MessageLevel::Warning );
1806 return mSettings.
zRange();
1821 clearElevationCache();
1823 autoRefreshTriggered();
1859 if ( boundingBoxOfFeatureIds( ids,
layer, bbox, errorMsg ) )
1863 bbox = optimalExtentForPointLayer(
layer, bbox.
center() );
1869 emit
messageEmitted( tr(
"Zoom to feature id failed" ), errorMsg, Qgis::MessageLevel::Warning );
1883 if ( boundingBoxOfFeatureIds( ids,
layer, bbox, errorMsg ) )
1891 emit
messageEmitted( tr(
"Pan to feature id failed" ), errorMsg, Qgis::MessageLevel::Warning );
1900 int featureCount = 0;
1908 errorMsg = tr(
"Feature does not have a geometry" );
1912 errorMsg = tr(
"Feature geometry is empty" );
1914 if ( !errorMsg.isEmpty() )
1923 if ( featureCount != ids.count() )
1925 errorMsg = tr(
"Feature not found" );
1937 layer = mCurrentLayer;
1961 for (
const QgsFeature &feature : selectedFeatures )
1963 if ( !feature.hasGeometry() )
1982 emit
messageEmitted( tr(
"Cannot pan to selected feature(s)" ), tr(
"No extent could be determined." ), Qgis::MessageLevel::Warning );
1998 if ( !mapLayer || !mapLayer->isSpatial() )
2003 switch ( mapLayer->type() )
2008 if (
layer->selectedFeatureCount() == 0 )
2011 rect =
layer->boundingBoxOfSelected();
2019 rect = optimalExtentForPointLayer(
layer, rect.
center() );
2030 for (
const QgsFeature &feature : selectedFeatures )
2032 if ( !feature.hasGeometry() )
2054 if ( selectionExtent.
isNull() )
2056 emit
messageEmitted( tr(
"Cannot pan to selected feature(s)" ), tr(
"No extent could be determined." ), Qgis::MessageLevel::Warning );
2065 const QColor &color1,
const QColor &color2,
2066 int flashes,
int duration )
2073 QList< QgsGeometry > geoms;
2089 if ( geometries.isEmpty() )
2107 QColor startColor = color1;
2108 if ( !startColor.isValid() )
2118 startColor.setAlpha( 255 );
2120 QColor endColor = color2;
2121 if ( !endColor.isValid() )
2123 endColor = startColor;
2124 endColor.setAlpha( 0 );
2128 QVariantAnimation *animation =
new QVariantAnimation(
this );
2129 connect( animation, &QVariantAnimation::finished,
this, [animation, rb]
2131 animation->deleteLater();
2134 connect( animation, &QPropertyAnimation::valueChanged,
this, [rb, geomType](
const QVariant & value )
2136 QColor
c = value.value<QColor>();
2145 c.setAlpha(
c.alpha() );
2151 animation->setDuration( duration * flashes );
2152 animation->setStartValue( endColor );
2153 double midStep = 0.2 / flashes;
2154 for (
int i = 0; i < flashes; ++i )
2156 double start =
static_cast< double >( i ) / flashes;
2157 animation->setKeyValueAt( start + midStep, startColor );
2158 double end =
static_cast< double >( i + 1 ) / flashes;
2160 animation->setKeyValueAt( end, endColor );
2162 animation->setEndValue( endColor );
2185 if ( !e->isAccepted() )
2190 double dx = std::fabs( currentExtent.
width() / 4 );
2191 double dy = std::fabs( currentExtent.
height() / 4 );
2223 if ( ! e->isAutoRepeat() )
2231 case Qt::Key_PageUp:
2236 case Qt::Key_PageDown:
2243 mUseParallelRendering = !mUseParallelRendering;
2248 mDrawRenderingStats = !mDrawRenderingStats;
2276 mTemporaryCursorOverride.reset();
2290 QgsDebugMsgLevel(
"Ignoring key release: " + QString::number( e->key() ), 2 );
2309void QgsMapCanvas::beginZoomRect( QPoint pos )
2311 mZoomRect.setRect( 0, 0, 0, 0 );
2313 mZoomDragging =
true;
2315 QColor color( Qt::blue );
2316 color.setAlpha( 63 );
2317 mZoomRubberBand->setColor( color );
2318 mZoomRect.setTopLeft( pos );
2321void QgsMapCanvas::stopZoomRect()
2323 if ( mZoomDragging )
2325 mZoomDragging =
false;
2326 mZoomRubberBand.reset(
nullptr );
2327 mTemporaryCursorOverride.reset();
2331void QgsMapCanvas::endZoomRect( QPoint pos )
2336 mZoomRect.setRight( pos.x() );
2337 mZoomRect.setBottom( pos.y() );
2340 mZoomRect = mZoomRect.normalized();
2342 if ( mZoomRect.width() < 5 && mZoomRect.height() < 5 )
2349 const QSize &zoomRectSize = mZoomRect.size();
2350 const QSize &canvasSize = mSettings.
outputSize();
2351 double sfx =
static_cast< double >( zoomRectSize.width() ) / canvasSize.width();
2352 double sfy =
static_cast< double >( zoomRectSize.height() ) / canvasSize.height();
2353 double sf = std::max( sfx, sfy );
2361void QgsMapCanvas::startPan()
2371void QgsMapCanvas::stopPan()
2376 mTemporaryCursorOverride.reset();
2384 if ( e->button() == Qt::MiddleButton &&
2385 e->modifiers() & Qt::ShiftModifier )
2387 beginZoomRect( e->pos() );
2391 else if ( e->button() == Qt::MiddleButton )
2406 && e->modifiers() & Qt::ShiftModifier )
2408 beginZoomRect( e->pos() );
2414 showContextMenu( me.get() );
2437 if ( mZoomDragging &&
2438 e->button() == Qt::MiddleButton )
2440 endZoomRect( e->pos() );
2444 else if ( e->button() == Qt::MiddleButton )
2448 else if ( e->button() == Qt::BackButton )
2453 else if ( e->button() == Qt::ForwardButton )
2460 if ( mZoomDragging && e->button() == Qt::LeftButton )
2462 endZoomRect( e->pos() );
2472 QgsDebugMsgLevel( QStringLiteral(
"Right click in map tool zoom or pan, last tool is %1." ).arg(
2473 mLastNonZoomMapTool ? QStringLiteral(
"not null" ) : QStringLiteral(
"null" ) ), 2 );
2475 QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCurrentLayer );
2478 if ( mLastNonZoomMapTool
2483 mLastNonZoomMapTool =
nullptr;
2503 QGraphicsView::resizeEvent( e );
2504 mResizeTimer->start( 500 );
2506 double oldScale = mSettings.
scale();
2507 QSize lastSize = viewport()->size();
2510 mScene->setSceneRect( QRectF( 0, 0, lastSize.width(), lastSize.height() ) );
2516 double scaleFactor = oldScale / mSettings.
scale();
2534 QGraphicsView::paintEvent( e );
2539 if ( mBlockItemPositionUpdates )
2542 const QList<QGraphicsItem *> items = mScene->items();
2543 for ( QGraphicsItem *gi : items )
2560 QgsDebugMsgLevel(
"Wheel event delta " + QString::number( e->angleDelta().y() ), 2 );
2565 if ( e->isAccepted() )
2569 if ( e->angleDelta().y() == 0 )
2578 zoomFactor = 1.0 + ( zoomFactor - 1.0 ) / 120.0 * std::fabs( e->angleDelta().y() );
2580 if ( e->modifiers() & Qt::ControlModifier )
2583 zoomFactor = 1.0 + ( zoomFactor - 1.0 ) / 20.0;
2586 double signedWheelFactor = e->angleDelta().y() > 0 ? 1 / zoomFactor : zoomFactor;
2591 QgsPointXY newCenter( mousePos.
x() + ( ( oldCenter.
x() - mousePos.
x() ) * signedWheelFactor ),
2592 mousePos.
y() + ( ( oldCenter.
y() - mousePos.
y() ) * signedWheelFactor ) );
2600 mWheelZoomFactor = factor;
2629 ScaleRestorer restorer(
this );
2643 if ( mScaleLocked != isLocked )
2645 mScaleLocked = isLocked;
2658 else if ( mZoomDragging )
2660 mZoomRect.setBottomRight( e->pos() );
2661 mZoomRubberBand->setToCanvasRectangle( mZoomRect );
2662 mZoomRubberBand->show();
2675 if ( !panOperationInProgress() )
2692 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2702 mLastNonZoomMapTool = mMapTool;
2706 mLastNonZoomMapTool =
nullptr;
2716 connect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2724 if ( mMapTool && mMapTool == tool )
2726 disconnect( mMapTool, &QObject::destroyed,
this, &QgsMapCanvas::mapToolDestroyed );
2731 setCursor( Qt::ArrowCursor );
2734 if ( mLastNonZoomMapTool && mLastNonZoomMapTool == tool )
2736 mLastNonZoomMapTool =
nullptr;
2754 QBrush bgBrush( color );
2755 setBackgroundBrush( bgBrush );
2758 palette.setColor( backgroundRole(), color );
2759 setPalette( palette );
2763 mScene->setBackgroundBrush( bgBrush );
2772 return mScene->backgroundBrush().color();
2784 bool hasSelectedFeatures =
false;
2791 hasSelectedFeatures =
true;
2796 if ( hasSelectedFeatures )
2862 if ( mTheme ==
theme )
2876 setLayersPrivate(
QgsProject::instance()->mapThemeCollection()->mapThemeVisibleLayers( mTheme ) );
2894void QgsMapCanvas::connectNotify(
const char *signal )
2897 QgsDebugMsg(
"QgsMapCanvas connected to " + QString( signal ) );
2901void QgsMapCanvas::layerRepaintRequested(
bool deferred )
2907void QgsMapCanvas::autoRefreshTriggered()
2913 mRefreshAfterJob =
true;
2920void QgsMapCanvas::updateAutoRefreshTimer()
2924 int minAutoRefreshInterval = -1;
2928 int layerRefreshInterval = 0;
2939 if ( rendererRefreshRate > 0 )
2941 layerRefreshInterval = 1000 / rendererRefreshRate;
2946 if ( layerRefreshInterval == 0 )
2949 minAutoRefreshInterval = minAutoRefreshInterval > 0 ? std::min( layerRefreshInterval, minAutoRefreshInterval ) : layerRefreshInterval;
2952 if ( minAutoRefreshInterval > 0 )
2954 mAutoRefreshTimer.setInterval( minAutoRefreshInterval );
2955 mAutoRefreshTimer.start();
2959 mAutoRefreshTimer.stop();
2963void QgsMapCanvas::projectThemesChanged()
2965 if ( mTheme.isEmpty() )
2996 double dx = end.
x() - start.
x();
2997 double dy = end.
y() - start.
y();
2999 c.set(
c.x() - dx,
c.y() - dy );
3037 setSceneRect( -pnt.x(), -pnt.y(), viewport()->size().width(), viewport()->size().height() );
3045 bool allHandled =
true;
3048 bool handled =
false;
3051 if ( handler && handler->customUriProviderKey() == uri.providerKey )
3053 if ( handler->handleCustomUriCanvasDrop( uri,
this ) )
3077 updateDevicePixelFromScreen();
3087 if ( !mPreviewEffect )
3092 mPreviewEffect->setEnabled( previewEnabled );
3097 if ( !mPreviewEffect )
3102 return mPreviewEffect->isEnabled();
3107 if ( !mPreviewEffect )
3112 mPreviewEffect->
setMode( mode );
3117 if ( !mPreviewEffect )
3122 return mPreviewEffect->
mode();
3127 if ( !mSnappingUtils )
3133 return mSnappingUtils;
3138 mSnappingUtils = utils;
3145 QDomNodeList nodes = doc.elementsByTagName( QStringLiteral(
"mapcanvas" ) );
3146 if ( nodes.count() )
3148 QDomNode node = nodes.item( 0 );
3151 if ( nodes.count() > 1 )
3153 for (
int i = 0; i < nodes.size(); ++i )
3155 QDomElement elementNode = nodes.at( i ).toElement();
3157 if ( elementNode.hasAttribute( QStringLiteral(
"name" ) ) && elementNode.attribute( QStringLiteral(
"name" ) ) == objectName() )
3159 node = nodes.at( i );
3167 if ( objectName() != QLatin1String(
"theMapCanvas" ) )
3178 QDomElement elem = node.toElement();
3179 if ( elem.hasAttribute( QStringLiteral(
"theme" ) ) )
3181 if (
QgsProject::instance()->mapThemeCollection()->hasMapTheme( elem.attribute( QStringLiteral(
"theme" ) ) ) )
3183 setTheme( elem.attribute( QStringLiteral(
"theme" ) ) );
3186 setAnnotationsVisible( elem.attribute( QStringLiteral(
"annotationsVisible" ), QStringLiteral(
"1" ) ).toInt() );
3189 const QDomNodeList scopeElements = elem.elementsByTagName( QStringLiteral(
"expressionContextScope" ) );
3190 if ( scopeElements.size() > 0 )
3192 const QDomElement scopeElement = scopeElements.at( 0 ).toElement();
3198 QgsDebugMsg( QStringLiteral(
"Couldn't read mapcanvas information from project" ) );
3213 QDomNodeList nl = doc.elementsByTagName( QStringLiteral(
"qgis" ) );
3216 QgsDebugMsg( QStringLiteral(
"Unable to find qgis element in project file" ) );
3219 QDomNode qgisNode = nl.item( 0 );
3221 QDomElement mapcanvasNode = doc.createElement( QStringLiteral(
"mapcanvas" ) );
3222 mapcanvasNode.setAttribute( QStringLiteral(
"name" ), objectName() );
3223 if ( !mTheme.isEmpty() )
3224 mapcanvasNode.setAttribute( QStringLiteral(
"theme" ), mTheme );
3225 mapcanvasNode.setAttribute( QStringLiteral(
"annotationsVisible" ), mAnnotationsVisible );
3226 qgisNode.appendChild( mapcanvasNode );
3228 mSettings.
writeXml( mapcanvasNode, doc );
3231 QDomElement scopeElement = doc.createElement( QStringLiteral(
"expressionContextScope" ) );
3233 tmpScope.
removeVariable( QStringLiteral(
"atlas_featurenumber" ) );
3239 mapcanvasNode.appendChild( scopeElement );
3246 if ( mScaleLocked && !ignoreScaleLock )
3248 ScaleRestorer restorer(
this );
3283 bool allHandled =
true;
3286 bool handled =
false;
3289 if ( handler->canHandleCustomUriCanvasDrop( uri,
this ) )
3315 return QGraphicsView::viewportEvent(
event );
3318void QgsMapCanvas::mapToolDestroyed()
3326 if ( e->type() == QEvent::Gesture )
3328 if ( QTapAndHoldGesture *tapAndHoldGesture = qobject_cast< QTapAndHoldGesture * >(
static_cast<QGestureEvent *
>( e )->gesture( Qt::TapAndHoldGesture ) ) )
3330 QPointF pos = tapAndHoldGesture->position();
3331 pos = mapFromGlobal( QPoint( pos.x(), pos.y() ) );
3339 return mMapTool->
gestureEvent(
static_cast<QGestureEvent *
>( e ) );
3344 return QGraphicsView::event( e );
3370 while ( mRefreshScheduled || mJob )
3372 QgsApplication::processEvents();
3388 QList<QgsMapCanvasAnnotationItem *> annotationItemList;
3389 const QList<QGraphicsItem *> items = mScene->items();
3390 for ( QGraphicsItem *gi : items )
3395 annotationItemList.push_back( aItem );
3399 return annotationItemList;
3404 mAnnotationsVisible = show;
3408 item->setVisible( show );
3422void QgsMapCanvas::startPreviewJobs()
3431 schedulePreviewJob( 0 );
3434void QgsMapCanvas::startPreviewJob(
int number )
3447 double dx = ( i - 1 ) * mapRect.
width();
3448 double dy = ( 1 - j ) * mapRect.
height();
3461 const QList<QgsMapLayer *>
layers = jobSettings.
layers();
3462 QList< QgsMapLayer * > previewLayers;
3471 QgsDebugMsgLevel( QStringLiteral(
"Layer %1 not rendered because it does not match the renderInPreview criterion %2" ).arg(
layer->
id() ).arg( mLastLayerRenderTime.value(
layer->
id() ) ), 3 );
3475 previewLayers <<
layer;
3480 job->setProperty(
"number", number );
3481 mPreviewJobs.append( job );
3486void QgsMapCanvas::stopPreviewJobs()
3488 mPreviewTimer.stop();
3489 for (
auto previewJob = mPreviewJobs.constBegin(); previewJob != mPreviewJobs.constEnd(); ++previewJob )
3495 ( *previewJob )->cancelWithoutBlocking();
3498 mPreviewJobs.clear();
3501void QgsMapCanvas::schedulePreviewJob(
int number )
3503 mPreviewTimer.setSingleShot(
true );
3504 mPreviewTimer.setInterval( PREVIEW_JOB_DELAY_MS );
3505 disconnect( mPreviewTimerConnection );
3506 mPreviewTimerConnection = connect( &mPreviewTimer, &QTimer::timeout,
this, [ = ]()
3508 startPreviewJob( number );
3510 mPreviewTimer.start();
3513bool QgsMapCanvas::panOperationInProgress()
3518 if (
QgsMapToolPan *panTool = qobject_cast< QgsMapToolPan *>( mMapTool ) )
3520 if ( panTool->isDragging() )
3527int QgsMapCanvas::nextZoomLevel(
const QList<double> &resolutions,
bool zoomIn )
const
3529 int resolutionLevel = -1;
3532 for (
int i = 0, n = resolutions.size(); i < n; ++i )
3534 if (
qgsDoubleNear( resolutions[i], currentResolution, 0.0001 ) )
3536 resolutionLevel =
zoomIn ? ( i - 1 ) : ( i + 1 );
3539 else if ( currentResolution <= resolutions[i] )
3541 resolutionLevel =
zoomIn ? ( i - 1 ) : i;
3545 return ( resolutionLevel < 0 || resolutionLevel >= resolutions.size() ) ? -1 : resolutionLevel;
3550 if ( !mZoomResolutions.isEmpty() )
3552 int zoomLevel = nextZoomLevel( mZoomResolutions,
true );
3553 if ( zoomLevel != -1 )
3558 return 1 / mWheelZoomFactor;
3563 if ( !mZoomResolutions.isEmpty() )
3565 int zoomLevel = nextZoomLevel( mZoomResolutions,
false );
3566 if ( zoomLevel != -1 )
3571 return mWheelZoomFactor;
@ YX
Northing/Easting (or Latitude/Longitude for geographic CRS)
@ View
Renderer used for displaying on screen.
@ 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.
@ 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...
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.
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 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).
@ MediumString
A medium-length string, recommended for general purpose use.
void updateDefinition()
Updates the definition and parameters of the coordinate reference system to their latest values.
QString userFriendlyIdentifier(IdentifierType type=MediumString) const
Returns a user friendly identifier for the CRS.
@ WKT_PREFERRED
Preferred format, matching the most recent WKT ISO standard. Currently an alias to WKT2_2019,...
Q_GADGET QgsUnitTypes::DistanceUnit mapUnits
QList< Qgis::CrsAxisDirection > axisOrdering() const
Returns an ordered list of the axis directions reflecting the native axis order for the CRS.
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 SIP_THROW(QgsCsException)
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.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
QgsUnitTypes::DistanceUnit lengthUnits() const
Returns the units of distance for length calculations made by this object.
QgsRange which stores a range of double values.
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)
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 SIP_HOLDGIL
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) SIP_HOLDGIL
Creates a new geometry from a QgsPointXY object.
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
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 messageEmitted(const QString &title, const QString &message, Qgis::MessageLevel=Qgis::MessageLevel::Info)
emit a message (usually to be displayed in a message bar)
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.
QgsUnitTypes::DistanceUnit mapUnits() const
Convenience function for returning the current canvas map units.
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...
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 stopRendering()
stop rendering (if there is any right now)
void magnificationChanged(double)
Emitted when the scale of the map changes.
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.
bool antiAliasingEnabled() const
true if antialiasing is enabled
void setPreviewMode(QgsPreviewEffect::PreviewMode mode)
Sets a preview mode for the map canvas.
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 renderComplete(QPainter *)
Emitted when the canvas has rendered.
void tapAndHoldGestureOccurred(const QgsPointXY &mapPoint, QTapAndHoldGesture *gesture)
Emitted whenever a tap and hold gesture occurs at the specified map point.
void zoomNextStatusChanged(bool)
Emitted when zoom next status changed.
const QgsDateTimeRange & temporalRange() const
Returns map canvas datetime range.
void setCanvasColor(const QColor &_newVal)
Write property of QColor bgColor.
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)
void rotationChanged(double)
Emitted when the rotation of the map changes.
void dragEnterEvent(QDragEnterEvent *e) override
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.
QList< QgsMapLayer * > layers(bool expandGroupLayers=false) const
Returns the list of layers shown within the map canvas.
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns global labeling engine settings from the internal map settings.
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 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 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.
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 setPreviewJobsEnabled(bool enabled)
Sets whether canvas map preview jobs (low priority render jobs which render portions of the view just...
bool setReferencedExtent(const QgsReferencedRectangle &extent) SIP_THROW(QgsCsException)
Sets the canvas to the specified extent.
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 panToFeatureIds(QgsVectorLayer *layer, const QgsFeatureIds &ids, bool alwaysRecenter=true)
Centers canvas extent to feature ids.
void scaleChanged(double)
Emitted when the scale of the map changes.
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.
void panDistanceBearingChanged(double distance, QgsUnitTypes::DistanceUnit unit, double bearing)
Emitted whenever the distance or bearing of an in-progress panning operation is changed.
double scale() const
Returns the last reported scale of the canvas.
QgsSnappingUtils * snappingUtils() const
Returns snapping utility class that is associated with map canvas.
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 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.
QgsMapTool * mapTool()
Returns the currently active tool.
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 zoomLastStatusChanged(bool)
Emitted when zoom last status changed.
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 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.
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...
void autoRefreshIntervalChanged(int interval)
Emitted when the auto refresh interval changes.
QgsCoordinateReferenceSystem crs
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
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...
static const QgsSettingsEntryBool settingsLogCanvasRefreshEvent
Settings entry log canvas refresh event.
const QgsMapSettings & mapSettings() const
Returns map settings with which this job was started.
void finished()
emitted when asynchronous rendering is finished (or canceled).
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).
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 writeXml(QDomNode &node, QDomDocument &doc)
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.
QgsUnitTypes::DistanceUnit mapUnits() const
Returns the units of the map's geographical coordinates - used for scale calculation.
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.
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)
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.
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 SIP_HOLDGIL
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.
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
void readProject(const QDomDocument &)
Emitted when a project is being read.
void writeProject(QDomDocument &)
Emitted when the project is being written.
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.
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 yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
void setYMinimum(double y) SIP_HOLDGIL
Set the minimum y value.
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
void setXMaximum(double x) SIP_HOLDGIL
Set the maximum x value.
void setXMinimum(double x) SIP_HOLDGIL
Set the minimum x value.
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
void setYMaximum(double y) SIP_HOLDGIL
Set the maximum y value.
void setMinimal() SIP_HOLDGIL
Set a rectangle so that min corner is at max and max corner is at min.
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
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 is empty.
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
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(int 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.
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.
@ NavigationOff
Temporal navigation is disabled.
@ FixedRange
Temporal navigation relies on a fixed datetime range.
@ Animated
Temporal navigation relies on frames within a datetime range.
void navigationModeChanged(QgsTemporalNavigationObject::NavigationMode 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.
Temporarily sets a cursor override for the QApplication for the lifetime of the object.
void release()
Releases the cursor override early (i.e.
DistanceUnit
Units of distance.
@ DistanceDegrees
Degrees, for planar geographic CRS distance measurements.
Represents a vector layer which manages a vector based data sets.
Q_INVOKABLE QgsWkbTypes::GeometryType geometryType() const
Returns point, line or polygon.
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.
bool isEditable() const FINAL
Returns true if the provider is in editing mode.
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 GeometryType geometryType(Type type) SIP_HOLDGIL
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
@ PointCloudLayer
Point cloud layer. Added in QGIS 3.18.
@ MeshLayer
Mesh layer. Added in QGIS 3.2.
@ VectorLayer
Vector layer.
@ RasterLayer
Raster layer.
@ GroupLayer
Composite group layer. Added in QGIS 3.24.
@ VectorTileLayer
Vector tile layer. Added in QGIS 3.14.
@ AnnotationLayer
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
@ PluginLayer
Plugin based layer.
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)
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.