qgsmapcanvas.h

Go to the documentation of this file.

/***************************************************************************
                          qgsmapcanvas.h  -  description
                             -------------------
    begin                : Sun Jun 30 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.com
***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSMAPCANVAS_H
#define QGSMAPCANVAS_H
 
#include "qgsconfig.h"
 
#include "qgis_gui.h"
#include "qgis_sip.h"
#include "qgscustomdrophandler.h"
#include "qgsdistancearea.h"
#include "qgsexpressioncontext.h"
#include "qgsfeatureid.h"
#include "qgsgeometry.h"
#include "qgsmapcanvasinteractionblocker.h"
#include "qgsmaprendererjob.h"
#include "qgsmapsettings.h"
#include "qgsprevieweffect.h"
#include "qgsproject.h"
#include "qgsrectangle.h"
 
#include <QDomDocument>
#include <QGestureEvent>
#include <QGraphicsView>
#include <QTimer>
 
class QWheelEvent;
class QPixmap;
class QPaintEvent;
class QKeyEvent;
class ResizeEvent;
 
class QColor;
class QDomDocument;
class QPaintDevice;
class QMouseEvent;
class QRubberBand;
class QGraphicsScene;
 
class QgsMapToPixel;
class QgsMapLayer;
class QgsHighlight;
class QgsVectorLayer;
 
class QgsLabelingResults;
 
class QgsMapRendererCache;
class QgsMapRendererQImageJob;
class QgsMapSettings;
class QgsMapCanvasMap;
class QgsMapOverviewCanvas;
class QgsMapTool;
class QgsSnappingUtils;
class QgsRubberBand;
class QgsMapCanvasAnnotationItem;
class QgsReferencedRectangle;
class QgsRenderedItemResults;
class QgsTemporaryCursorOverride;
class QgsOverlayWidgetLayout;
 
class QgsTemporalController;
class QgsScreenHelper;
 
class QgsAbstract2DMapController;
 
class QMenu;
class QgsMapMouseEvent;
 

 
class GUI_EXPORT QgsMapCanvas : public QGraphicsView, public QgsExpressionContextGenerator
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( qobject_cast<QgsMapCanvas *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMapCanvas;
    else
      sipType = nullptr;
    SIP_END
#endif
 
    Q_OBJECT
    Q_PROPERTY( QString theme READ theme WRITE setTheme NOTIFY themeChanged )
    Q_PROPERTY( bool previewJobsEnabled READ previewJobsEnabled WRITE setPreviewJobsEnabled )
 
  public:
    QgsMapCanvas( QWidget *parent SIP_TRANSFERTHIS = nullptr );
 
    ~QgsMapCanvas() override;

    void addOverlayWidget( QWidget *widget SIP_TRANSFER, Qt::Edge edge );

    double magnificationFactor() const;

    void setLayers( const QList<QgsMapLayer *> &layers );

    void setFlags( Qgis::MapCanvasFlags flags );

    Qgis::MapCanvasFlags flags() const;
 
    void setCurrentLayer( QgsMapLayer *layer );

    const QgsMapSettings &mapSettings() const SIP_KEEPREFERENCE;

    QgsMapSettings &mapSettings() SIP_SKIP;

    void setTemporalController( QgsTemporalController *controller );

    const QgsTemporalController *temporalController() const;

    void setDestinationCrs( const QgsCoordinateReferenceSystem &crs );

    void setMapSettingsFlags( Qgis::MapSettingsFlags flags );

    const QgsLabelingResults *labelingResults( bool allowOutdatedResults = true ) const;

    const QgsRenderedItemResults *renderedItemResults( bool allowOutdatedResults = true ) const;

    void setCachingEnabled( bool enabled );

    bool isCachingEnabled() const;

    void clearCache();

    QgsMapRendererCache *cache();

    void cancelJobs() SIP_SKIP;

    void waitWhileRendering();

    void setParallelRenderingEnabled( bool enabled );

    bool isParallelRenderingEnabled() const;

    void setMapUpdateInterval( int timeMilliseconds );

    int mapUpdateInterval() const;

    double scale() const;

    double mapUnitsPerPixel() const;

    QgsRectangle extent() const;

    QgsRectangle fullExtent() const;

    QgsRectangle projectExtent() const;

    void setExtent( const QgsRectangle &r, bool magnified = false );

    bool setReferencedExtent( const QgsReferencedRectangle &extent ) SIP_THROW( QgsCsException );

    double rotation() const;

    void setRotation( double degrees );

    void setCenter( const QgsPointXY &center );

    QgsPointXY center() const;

    void zoomToFullExtent();

    void zoomToProjectExtent();

    void zoomToPreviousExtent();

    void zoomToNextExtent();

    void clearExtentHistory();
 

    void zoomToFeatureIds( QgsVectorLayer *layer, const QgsFeatureIds &ids );

    void panToFeatureIds( QgsVectorLayer *layer, const QgsFeatureIds &ids, bool alwaysRecenter = true );

    void panToSelected( QgsMapLayer *layer = nullptr );

    void panToSelected( const QList<QgsMapLayer *> &layers );

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

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

    void setMapTool( QgsMapTool *mapTool, bool clean = false );

    void unsetMapTool( QgsMapTool *mapTool );

    QgsMapTool *mapTool() const;

    void setProject( QgsProject *project );

    QgsProject *project();

    void setCanvasColor( const QColor &_newVal );
    QColor canvasColor() const;

    void setSelectionColor( const QColor &color );

    QColor selectionColor() const;

    void updateScale();

    QgsMapLayer *layer( int index );

    QgsMapLayer *layer( const QString &id );

    int layerCount() const;

    QList<QgsMapLayer *> layers( bool expandGroupLayers = false ) const;
 
#ifndef SIP_RUN
    template<typename T>
    QVector<T> layers() const { return mapSettings().layers<T>(); }
#endif

    void freeze( bool frozen = true );

    bool isFrozen() const;

    bool renderFlag() const { return mRenderFlag; }

    Qgis::DistanceUnit mapUnits() const;

    QMap<QString, QString> layerStyleOverrides() const;

    void setLayerStyleOverrides( const QMap<QString, QString> &overrides );

    void setTheme( const QString &theme );

    QString theme() const { return mTheme; }

    const QgsMapToPixel *getCoordinateTransform();

    bool isDrawing();

    QgsMapLayer *currentLayer();

    void setWheelFactor( double factor );

    void zoomScale( double scale, bool ignoreScaleLock = false );

    void zoomByFactor( double scaleFactor, const QgsPointXY *center = nullptr, bool ignoreScaleLock = false );

    void zoomWithCenter( int x, int y, bool zoomIn );

    void zoomToFeatureExtent( QgsRectangle &rect );

    bool scaleLocked() const { return mScaleLocked; }

    void enableAntiAliasing( bool flag );

    bool antiAliasingEnabled() const;

    void enableMapTileRendering( bool flag );
 
    // following 2 methods should be moved elsewhere or changed to private
    // currently used by pan map tool
    void panActionEnd( QPoint releasePoint );
 
#ifndef SIP_RUN

    void panActionStart( QPoint releasePoint );
#endif

    void panAction( QMouseEvent *event );

    QPoint mouseLastXY();

    void setPreviewModeEnabled( bool previewEnabled );

    bool previewModeEnabled() const;

    void setPreviewMode( QgsPreviewEffect::PreviewMode mode );

    QgsPreviewEffect::PreviewMode previewMode() const;

    QgsSnappingUtils *snappingUtils() const;

    void setSnappingUtils( QgsSnappingUtils *utils );

    void setExpressionContextScope( const QgsExpressionContextScope &scope ) { mExpressionContextScope = scope; }

    QgsExpressionContextScope &expressionContextScope() { return mExpressionContextScope; }

    const QgsExpressionContextScope &expressionContextScope() const SIP_SKIP
    {
      return mExpressionContextScope;
    }

    QgsExpressionContextScope *defaultExpressionContextScope() const SIP_FACTORY;
 
    QgsExpressionContext createExpressionContext() const override;

    void setSegmentationTolerance( double tolerance );

    void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type );

    QList<QgsMapCanvasAnnotationItem *> annotationItems() const;

    bool annotationsVisible() const { return mAnnotationsVisible; }

    void setAnnotationsVisible( bool visible );

    void setLabelingEngineSettings( const QgsLabelingEngineSettings &settings );

    const QgsLabelingEngineSettings &labelingEngineSettings() const;

    bool previewJobsEnabled() const;

    void setPreviewJobsEnabled( bool enabled );

    void setCustomDropHandlers( const QVector<QPointer<QgsCustomDropHandler>> &handlers ) SIP_SKIP;

    void setTemporalRange( const QgsDateTimeRange &range );

    const QgsDateTimeRange &temporalRange() const;

    void installInteractionBlocker( QgsMapCanvasInteractionBlocker *blocker );

    void removeInteractionBlocker( QgsMapCanvasInteractionBlocker *blocker );

    bool allowInteraction( QgsMapCanvasInteractionBlocker::Interaction interaction ) const;

    void setMapController( QgsAbstract2DMapController *controller SIP_TRANSFER );
 
  public slots:

    void refresh();

    void refreshAllLayers();

    void redrawAllLayers();

    void selectionChangedSlot();

    void saveAsImage( const QString &fileName, QPixmap *QPixmap = nullptr, const QString & = "PNG" );

    void layerStateChange();

    void setRenderFlag( bool flag );

    void stopRendering();

    void readProject( const QDomDocument & );

    void writeProject( QDomDocument & );

    void setMagnificationFactor( double factor, const QgsPointXY *center = nullptr );

    void setScaleLocked( bool isLocked );

    void zoomIn();

    void zoomOut();

    void zoomToSelected( QgsMapLayer *layer = nullptr );

    void zoomToSelected( const QList<QgsMapLayer *> &layers );

    void setZoomResolutions( const QList<double> &resolutions ) { mZoomResolutions = resolutions; }

    double zoomInFactor() const;

    double zoomOutFactor() const;

    const QList<double> &zoomResolutions() const { return mZoomResolutions; }

    QgsDoubleRange zRange() const;

    void setZRange( const QgsDoubleRange &range );
 
  private slots:
    void mapToolDestroyed();

    void rendererJobFinished();

    void previewJobFinished();
 
    void mapUpdateTimeout();
 
    void refreshMap();
 
    void mapThemeChanged( const QString &theme );
    void mapThemeRenamed( const QString &theme, const QString &newTheme );
 
    void updateDevicePixelFromScreen();
 
    void onElevationShadingRendererChanged();
 
  signals:

    void xyCoordinates( const QgsPointXY &p );

    void scaleChanged( double scale );

    void scaleLockChanged( bool locked );
 

    void extentsChanged();

    void rotationChanged( double rotation );

    void magnificationChanged( double magnification );

    void canvasColorChanged();
 
    // TODO: deprecate when decorations are reimplemented as map canvas items

    void renderComplete( QPainter *painter );
 
    // ### QGIS 3: renamte to mapRefreshFinished()
    void mapCanvasRefreshed();
 
    // ### QGIS 3: rename to mapRefreshStarted()
    void renderStarting();

    void mapRefreshCanceled();

    void layersChanged();

    void keyPressed( QKeyEvent *e );

    void keyReleased( QKeyEvent *e );

    void mapToolSet( QgsMapTool *newTool, QgsMapTool *oldTool );

    void selectionChanged( QgsMapLayer *layer );

    void zoomLastStatusChanged( bool available );

    void zoomNextStatusChanged( bool available );

    void destinationCrsChanged();

    void transformContextChanged();

    void currentLayerChanged( QgsMapLayer *layer );

    void layerStyleOverridesChanged();

    void themeChanged( const QString &theme );

    void messageEmitted( const QString &title, const QString &message, Qgis::MessageLevel level = Qgis::MessageLevel::Info );

    void renderErrorOccurred( const QString &error, QgsMapLayer *layer );

    void panDistanceBearingChanged( double distance, Qgis::DistanceUnit unit, double bearing );

    void tapAndHoldGestureOccurred( const QgsPointXY &mapPoint, QTapAndHoldGesture *gesture );

    void temporalRangeChanged();

    void zRangeChanged();

    void contextMenuAboutToShow( QMenu *menu, QgsMapMouseEvent *event );
 
  protected:
    bool event( QEvent *e ) override;
    void keyPressEvent( QKeyEvent *e ) override;
    void keyReleaseEvent( QKeyEvent *e ) override;
    void mouseDoubleClickEvent( QMouseEvent *e ) override;
    void mouseMoveEvent( QMouseEvent *e ) override;
    void mousePressEvent( QMouseEvent *e ) override;
    void mouseReleaseEvent( QMouseEvent *e ) override;
    void wheelEvent( QWheelEvent *e ) override;
    void resizeEvent( QResizeEvent *e ) override;
    void paintEvent( QPaintEvent *e ) override;
    void dragEnterEvent( QDragEnterEvent *e ) override;
    bool viewportEvent( QEvent *event ) override;

    void moveCanvasContents( bool reset = false );
 
    void dropEvent( QDropEvent *event ) override;
 
    void showEvent( QShowEvent *event ) override;

    void emitExtentsChanged();

    class CanvasProperties;

    std::unique_ptr<CanvasProperties> mCanvasProperties;
 
#if 0

    void connectNotify( const char *signal ) override;
#endif
 
  protected slots:
    void updateCanvasItemPositions();
 
  private slots:
 
    void layerRepaintRequested( bool deferred );
 
    void autoRefreshTriggered();
 
    void updateAutoRefreshTimer();
 
    void projectThemesChanged();
 
    void startPreviewJob( int number );
 
    void temporalControllerModeChanged();
 
  private:
    // Restore scale RAII
    class ScaleRestorer
    {
      public:
        ScaleRestorer( QgsMapCanvas *canvas )
          : mCanvas( canvas )
        {
          mLockedScale = mCanvas->mapSettings().scale();
        };
 
        ~ScaleRestorer()
        {
          QgsRectangle newExtent = mCanvas->mapSettings().extent();
          newExtent.scale( mLockedScale / mCanvas->mapSettings().scale() );
          mCanvas->mSettings.setExtent( newExtent );
        };
 
      private:
        QgsMapCanvas *mCanvas;
        double mLockedScale;
    };
 
    enum class CacheInvalidationType
    {
      Temporal = 1 << 0,
      Elevation = 1 << 1,
    };
 
    QgsOverlayWidgetLayout *mLayout = nullptr;
 
    Qgis::MapCanvasFlags mFlags;

    QgsMapSettings mSettings;

    QgsMapCanvasMap *mMap = nullptr;
 
    QgsScreenHelper *mScreenHelper = nullptr;

    QgsTemporalController *mController = nullptr;

    bool mFrozen = false;

    bool mRefreshScheduled = false;

    bool mRefreshAfterJob = false;

    bool mRenderFlag = true;
 
    QFlags<CacheInvalidationType> mCacheInvalidations;

    QPointer<QgsMapLayer> mCurrentLayer;

    QGraphicsScene *mScene = nullptr;

    QgsMapTool *mMapTool = nullptr;

    QgsProject *mProject = nullptr;

    QList<QgsRectangle> mLastExtent;
    int mLastExtentIndex = -1;

    double mWheelZoomFactor = 2.0;

    QTimer mMapUpdateTimer;

    QgsMapRendererQImageJob *mJob = nullptr;

    bool mJobCanceled = false;

    std::unique_ptr<QgsLabelingResults> mLabelingResults;

    bool mLabelingResultsOutdated = false;

    std::unique_ptr<QgsRenderedItemResults> mRenderedItemResults;

    std::unique_ptr<QgsRenderedItemResults> mPreviousRenderedItemResults;

    bool mRenderedItemResultsOutdated = false;

    bool mUseParallelRendering = false;

    bool mDrawRenderingStats = false;

    QgsMapRendererCache *mCache = nullptr;
 
    QTimer *mResizeTimer = nullptr;
    QTimer *mRefreshTimer = nullptr;
 
    QgsPreviewEffect *mPreviewEffect = nullptr;
 
    QgsRectangle imageRect( const QImage &img, const QgsMapSettings &mapSettings );
 
    QgsSnappingUtils *mSnappingUtils = nullptr;
 
    QList<QgsMapRendererQImageJob *> mPreviewJobs;

    bool mScaleLocked = false;
 
    QgsExpressionContextScope mExpressionContextScope;

    QRect mZoomRect;

    bool mZoomDragging = false;

    std::unique_ptr<QgsRubberBand> mZoomRubberBand;
 
    QCursor mZoomCursor;
 
    QTimer mAutoRefreshTimer;
 
    QTimer mPreviewTimer;
    QMetaObject::Connection mPreviewTimerConnection;
 
    QString mTheme;
 
    QgsPointXY mCursorPoint;
 
    bool mAnnotationsVisible = true;
 
    bool mUsePreviewJobs = false;
 
    QHash<QString, int> mLastLayerRenderTime;
 
    QVector<QPointer<QgsCustomDropHandler>> mDropHandlers;
 
    QgsDistanceArea mDa;
    QList<double> mZoomResolutions;
 
    QList<QgsMapCanvasInteractionBlocker *> mInteractionBlockers;
 
    int mBlockItemPositionUpdates = 0;
    int mBlockExtentChangedSignal = 0;
    int mBlockScaleChangedSignal = 0;
 
    std::unique_ptr<QgsTemporaryCursorOverride> mTemporaryCursorOverride;

    QMap<QString, QDateTime> mRendererErrors;
 
 
    QPointer<QgsAbstract2DMapController> mMapController;

    QgsPointXY cursorPoint() const;

    void updateMapSize();

    void beginZoomRect( QPoint pos );

    void endZoomRect( QPoint pos );

    void stopZoomRect();

    void startPan();

    void stopPan();

    bool boundingBoxOfFeatureIds( const QgsFeatureIds &ids, QgsVectorLayer *layer, QgsRectangle &bbox, QString &errorMsg ) const;

    QgsRectangle optimalExtentForPointLayer( QgsVectorLayer *layer, const QgsPointXY &center, int scaleFactor = 5 );
 
    void setLayersPrivate( const QList<QgsMapLayer *> &layers );
 
    void startPreviewJobs();
    void stopPreviewJobs();
    void schedulePreviewJob( int number );

    bool panOperationInProgress();
 
    int nextZoomLevel( const QList<double> &resolutions, bool zoomIn = true ) const;

    void clearTemporalCache();

    void clearElevationCache();
 
    void showContextMenu( QgsMapMouseEvent *event );

    void notifyRendererErrors( const QgsMapRendererJob::Errors &errors );
 
    friend class TestQgsMapCanvas;
 
}; // class QgsMapCanvas
 
// clazy:excludeall=qstring-allocations
 
#endif