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 <QDomDocument>
#include <QGraphicsView>
#include <QtCore>

#include "qgsmapsettings.h" // TEMPORARY
#include "qgsprevieweffect.h" //for QgsPreviewEffect::PreviewMode

#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 GUI_EXPORT QgsMapCanvas : public QGraphicsView
{

#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 setDestinationCrs( const QgsCoordinateReferenceSystem &crs );

    void setMapSettingsFlags( QgsMapSettings::Flags flags );

    const QgsLabelingResults *labelingResults() const;

    void setCachingEnabled( bool enabled );

    bool isCachingEnabled() const;

    void clearCache();

    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;

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

    void zoomToNextExtent();

    // ! Clears the list of extents and sets current extent as first item
    void clearExtentHistory();


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

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

    void panToSelected( QgsVectorLayer *layer = nullptr );

    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 setCanvasColor( const QColor &_newVal );
    QColor canvasColor() const;

    void setSelectionColor( const QColor &color );

    QColor selectionColor() const;

    void updateScale();

    QgsMapLayer *layer( int index );

    int layerCount() const;

    QList<QgsMapLayer *> layers() 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 );

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

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

    void zoomToFeatureExtent( QgsRectangle &rect );

    bool scaleLocked() const { return mScaleLocked;}

    void enableAntiAliasing( bool flag );

    bool antiAliasingEnabled() const { return mSettings.testFlag( QgsMapSettings::Antialiasing ); }

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

    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;

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

    void setScaleLocked( bool isLocked );

    void zoomIn();

    void zoomOut();

    void zoomToSelected( QgsVectorLayer *layer = nullptr );

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

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

  private slots:
    void mapToolDestroyed();

    void rendererJobFinished();

    void previewJobFinished();

    void mapUpdateTimeout();

    void refreshMap();

    void mapThemeChanged( const QString &theme );

  signals:

    void xyCoordinates( const QgsPointXY &p );

    void scaleChanged( double );

    void extentsChanged();

    void rotationChanged( double );

    void magnificationChanged( double );

    void canvasColorChanged();

    void renderComplete( QPainter * );

    // ### QGIS 3: renamte to mapRefreshFinished()
    void mapCanvasRefreshed();

    // ### QGIS 3: rename to mapRefreshStarted()
    void renderStarting();

    void layersChanged();

    void keyPressed( QKeyEvent *e );

    void keyReleased( QKeyEvent *e );

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


    void selectionChanged( QgsVectorLayer *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::Info );

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

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

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

  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;

    void moveCanvasContents( bool reset = false );

    void dropEvent( QDropEvent *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 );

  private:

    QgsMapSettings mSettings;

    QgsMapCanvasMap *mMap = nullptr;

    bool mFrozen = false;

    bool mRefreshScheduled = false;

    bool mRenderFlag = true;

    QPointer< QgsMapLayer > mCurrentLayer;

    QGraphicsScene *mScene = nullptr;

    QgsMapTool *mMapTool = nullptr;

    QgsMapTool *mLastNonZoomMapTool = nullptr;

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

    double mWheelZoomFactor = 2.0;

    QTimer mMapUpdateTimer;

    QgsMapRendererQImageJob *mJob = nullptr;

    bool mJobCanceled = false;

    QgsLabelingResults *mLabelingResults = nullptr;

    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;

    QgsPointXY cursorPoint() const;

    void updateMapSize();

    void beginZoomRect( QPoint pos );

    void endZoomRect( QPoint pos );

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

    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;
    double zoomInFactor() const;
    double zoomOutFactor() const;

    friend class TestQgsMapCanvas;

}; // class QgsMapCanvas

// clazy:excludeall=qstring-allocations

#endif