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 "qgsexpressioncontext.h"
#include "qgsfeature.h"
#include "qgsmessagebar.h"
#include "qgsrectangle.h"
#include "qgspoint.h"
#include "qgis.h"

#include <QDomDocument>
#include <QGraphicsView>
#include <QtCore>

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

#ifdef HAVE_TOUCH
#include <QGestureEvent>
#endif

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 QgsMapRenderer;
class QgsMapRendererCache;
class QgsMapRendererQImageJob;
class QgsMapSettings;
class QgsMapCanvasMap;
class QgsMapOverviewCanvas;
class QgsMapTool;
class QgsSnappingUtils;

class GUI_EXPORT QgsMapCanvasLayer
{
  public:
    QgsMapCanvasLayer( QgsMapLayer* layer, bool visible = true, bool isInOverview = false )
        : mLayer( layer ), mVisible( visible ), mInOverview( isInOverview ) {}

    void setVisible( bool visible ) { mVisible = visible; }
    void setInOverview( bool isInOverview ) { mInOverview = isInOverview; }

    bool isVisible() const { return mVisible; }
    bool isInOverview() const { return mInOverview; }

    QgsMapLayer* layer() { return mLayer; }
    const QgsMapLayer* layer() const { return mLayer; }

  private:
    QgsMapLayer* mLayer;

    bool mVisible;

    bool mInOverview;
};


Q_NOWARN_DEPRECATED_PUSH
class GUI_EXPORT QgsMapCanvas : public QGraphicsView
{
    Q_OBJECT

  public:

    enum WheelAction { WheelZoom, WheelZoomAndRecenter, WheelZoomToMouseCursor, WheelNothing };

    QgsMapCanvas( QWidget * parent = nullptr, const char *name = nullptr );

    ~QgsMapCanvas();

    void setLayerSet( QList<QgsMapCanvasLayer>& layers );

    void setCurrentLayer( QgsMapLayer* layer );

    // ### QGIS 3: make QgsMapCanvas independent from overview
    void updateOverview();

    // ### QGIS 3: make QgsMapCanvas independent from overview
    void enableOverviewMode( QgsMapOverviewCanvas* overview );

    const QgsMapSettings& mapSettings() const;

    void setCrsTransformEnabled( bool enabled );

    void setDestinationCrs( const QgsCoordinateReferenceSystem& crs );

    const QgsLabelingResults* labelingResults() const;

    void setCachingEnabled( bool enabled );

    bool isCachingEnabled() const;

    void clearCache();

    void refreshAllLayers();

    void setParallelRenderingEnabled( bool enabled );

    bool isParallelRenderingEnabled() const;

    void setMapUpdateInterval( int timeMilliseconds );

    int mapUpdateInterval() const;

    Q_DECL_DEPRECATED QgsMapCanvasMap *map();

    Q_DECL_DEPRECATED QgsMapRenderer *mapRenderer();

    Q_DECL_DEPRECATED QPaintDevice &canvasPaintDevice();

    double scale();

    Q_DECL_DEPRECATED void clear();

    double mapUnitsPerPixel() const;

    QgsRectangle extent() const;
    QgsRectangle fullExtent() const;

    void setExtent( const QgsRectangle &r );

    double rotation() const;

    void setRotation( double degrees );

    void setCenter( const QgsPoint& center );

    QgsPoint center() const;

    void zoomToFullExtent();

    void zoomToPreviousExtent();

    void zoomToNextExtent();

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

    void zoomToSelected( QgsVectorLayer* layer = nullptr );

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

    void panToSelected( QgsVectorLayer* layer = nullptr );

    void setMapTool( QgsMapTool* mapTool );

    void unsetMapTool( QgsMapTool* mapTool );

    QgsMapTool* mapTool();

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

    void setSelectionColor( const QColor& color );

    void updateScale();

    Q_DECL_DEPRECATED void updateFullExtent() {}

    QgsMapLayer *layer( int index );

    int layerCount() const;

    QList<QgsMapLayer*> layers() const;

    void freeze( bool frz = true );

    bool isFrozen();

    Q_DECL_DEPRECATED void setDirty( bool _dirty );

    Q_DECL_DEPRECATED bool isDirty() const;

    void setMapUnits( QGis::UnitType mapUnits );

    QGis::UnitType mapUnits() const;

    QMap<QString, QString> layerStyleOverrides() const;

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

    const QgsMapToPixel* getCoordinateTransform();

    bool isDrawing();

    QgsMapLayer* currentLayer();

    void setWheelAction( WheelAction action, double factor = 2 );

    void zoomIn();

    void zoomOut();

    void zoomScale( double scale );

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

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

    void enableAntiAliasing( bool theFlag );

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

    void enableMapTileRendering( bool theFlag );

    Q_DECL_DEPRECATED void useImageToRender( bool theFlag );

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

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

  public slots:

    void refresh();

    void selectionChangedSlot();

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

    void layerStateChange();

    void layerCrsChange();

    void setRenderFlag( bool theFlag );
    bool renderFlag() {return mRenderFlag;}

    bool hasCrsTransformEnabled();

    Q_DECL_DEPRECATED void updateMap();

    void stopRendering();

    Q_DECL_DEPRECATED void showError( QgsMapLayer * mapLayer );

    void readProject( const QDomDocument & );

    void writeProject( QDomDocument & );

    void getDatumTransformInfo( const QgsMapLayer* ml, const QString& srcAuthId, const QString& destAuthId );

    static bool rotationEnabled();

    static void enableRotation( bool enabled );

  private slots:
    void mapToolDestroyed();

    void rendererJobFinished();

    void mapUpdateTimeout();

    void refreshMap();

  signals:
    Q_DECL_DEPRECATED void setProgress( int, int );

    void xyCoordinates( const QgsPoint &p );

    void scaleChanged( double );

    void extentsChanged();

    void rotationChanged( double );

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

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

    // ### QGIS 3: remove the signal
    void selectionChanged( QgsMapLayer * layer );

    void zoomLastStatusChanged( bool );

    void zoomNextStatusChanged( bool );

    void hasCrsTransformEnabledChanged( bool flag );

    void destinationCrsChanged();

    void mapUnitsChanged();

    void currentLayerChanged( QgsMapLayer* layer );

    void layerStyleOverridesChanged();

    void messageEmitted( const QString& title, const QString& message, QgsMessageBar::MessageLevel = QgsMessageBar::INFO );

  protected:
#ifdef HAVE_TOUCH
    bool event( QEvent * e ) override;
#endif

    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 zoomToFeatureExtent( QgsRectangle& rect );

    void updateCanvasItemPositions();

    class CanvasProperties;

    QScopedPointer<CanvasProperties> mCanvasProperties;

#if 0

    void connectNotify( const char * signal ) override;
#endif
    void updateDatumTransformEntries();

  private:

    QgsMapCanvas( QgsMapCanvas const & );

    QgsMapSettings mSettings;

    QgsMapRenderer* mMapRenderer;

    QgsMapCanvasMap* mMap;

    QgsMapOverviewCanvas* mMapOverview;

    bool mFrozen;

    bool mRefreshScheduled;

    bool mRenderFlag;

    QgsMapLayer* mCurrentLayer;

    QGraphicsScene* mScene;

    QgsMapTool* mMapTool;

    QgsMapTool* mLastNonZoomMapTool;

    QList <QgsRectangle> mLastExtent;
    int mLastExtentIndex;

    double mWheelZoomFactor;

    WheelAction mWheelAction;

    QTimer mMapUpdateTimer;

    QgsMapRendererQImageJob* mJob;

    bool mJobCancelled;

    QgsLabelingResults* mLabelingResults;

    bool mUseParallelRendering;

    bool mDrawRenderingStats;

    QgsMapRendererCache* mCache;

    QTimer *mResizeTimer;

    QgsPreviewEffect* mPreviewEffect;

    QgsRectangle imageRect( const QImage& img, const QgsMapSettings& mapSettings );

    QgsSnappingUtils* mSnappingUtils;

    QgsExpressionContextScope mExpressionContextScope;

}; // class QgsMapCanvas
Q_NOWARN_DEPRECATED_POP




class QgsMapCanvasRendererSync : public QObject
{
    Q_OBJECT
  public:
    QgsMapCanvasRendererSync( QgsMapCanvas* canvas, QgsMapRenderer* renderer );

  protected slots:
    void onExtentC2R();
    void onExtentR2C();

    void onMapUnitsC2R();
    void onMapUnitsR2C();

    void onMapRotationC2R();
    void onMapRotationR2C();

    void onCrsTransformC2R();
    void onCrsTransformR2C();

    void onDestCrsC2R();
    void onDestCrsR2C();

    void onLayersC2R();

  protected:
    QgsMapCanvas* mCanvas;
    QgsMapRenderer* mRenderer;

    bool mSyncingExtent;
};


#endif