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_sip.h"
 
#include "qgsexpressioncontext.h"
#include "qgsrectangle.h"
#include "qgsfeatureid.h"
#include "qgsgeometry.h"
#include "qgscustomdrophandler.h"
#include "qgsmapcanvasinteractionblocker.h"
#include "qgsproject.h"
#include "qgsdistancearea.h"
#include "qgsmaprendererjob.h"
 
#include <QDomDocument>
#include <QGraphicsView>
 
#include "qgsmapsettings.h" // TEMPORARY
#include "qgsprevieweffect.h" //for QgsPreviewEffect::PreviewMode
 
#include <QTimer>
#include <QGestureEvent>
#include "qgis_gui.h"
 
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 QgsTemporalController;
class QgsScreenHelper;
 
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;
 
    double magnificationFactor() const;
 
    void setLayers( const QList<QgsMapLayer *> &layers );
 
    void setCurrentLayer( QgsMapLayer *layer );
 
    const QgsMapSettings &mapSettings() const SIP_KEEPREFERENCE;
 
    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();
 
    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();
 
    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;
 
    void freeze( bool frozen = true );
 
    bool isFrozen() const;
 
    bool renderFlag() const { return mRenderFlag; }
 
    QgsUnitTypes::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 { return mExpressionContextScope; } SIP_SKIP
 
    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;
 
  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();
 
  signals:
 
    void xyCoordinates( const QgsPointXY &p );
 
    void scaleChanged( double );
 
    void scaleLockChanged( bool locked );
 
 
    void extentsChanged();
 
    void rotationChanged( double );
 
    void magnificationChanged( double );
 
    void canvasColorChanged();
 
    // TODO: deprecate when decorations are reimplemented as map canvas items
 
    void renderComplete( QPainter * );
 
    // ### 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 );
 
    void zoomNextStatusChanged( bool );
 
    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 = Qgis::MessageLevel::Info );
 
    void renderErrorOccurred( const QString &error, QgsMapLayer *layer );
 
    void panDistanceBearingChanged( double distance, QgsUnitTypes::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;
 
    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;
    };
 
    QgsMapSettings mSettings;
 
    QgsMapCanvasMap *mMap = nullptr;
 
    QgsScreenHelper *mScreenHelper = nullptr;
 
    QgsTemporalController *mController = nullptr;
 
    bool mFrozen = false;
 
    bool mRefreshScheduled = false;
 
    bool mRefreshAfterJob = false;
 
    bool mRenderFlag = true;
 
    QPointer< QgsMapLayer > mCurrentLayer;
 
    QGraphicsScene *mScene = nullptr;
 
    QgsMapTool *mMapTool = nullptr;
 
    QgsMapTool *mLastNonZoomMapTool = 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;
 
    std::unique_ptr< QgsTemporaryCursorOverride > mTemporaryCursorOverride;
 
    QMap <QString, QDateTime> mRendererErrors;
 
    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