qgslayoutitemmap.h

Go to the documentation of this file.

/***************************************************************************
                              qgslayoutitemmap.h
                             -------------------
    begin                : July 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson at gmail dot 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 QGSLAYOUTITEMMAP_H
#define QGSLAYOUTITEMMAP_H

#include "qgis_core.h"
#include "qgslayoutitem.h"
#include "qgslayoutitemregistry.h"
#include "qgsmaplayerref.h"
#include "qgsmaprenderercustompainterjob.h"
#include "qgslayoutitemmapgrid.h"
#include "qgslayoutitemmapoverview.h"

class QgsAnnotation;

class CORE_EXPORT QgsLayoutItemMap : public QgsLayoutItem
{

    Q_OBJECT

  public:

    enum AtlasScalingMode
    {
      Fixed,      

      Predefined,

      Auto
    };

    explicit QgsLayoutItemMap( QgsLayout *layout );
    ~QgsLayoutItemMap() override;

    int type() const override;
    QIcon icon() const override;

    void assignFreeId();

    //overridden to show "Map 1" type names
    QString displayName() const override;

    static QgsLayoutItemMap *create( QgsLayout *layout ) SIP_FACTORY;

    // for now, map items behave a bit differently and don't implement draw. TODO - see if we can avoid this
    void paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget ) override;
    int numberExportLayers() const override;
    void setFrameStrokeWidth( const QgsLayoutMeasurement &width ) override;

    double scale() const;

    void setScale( double scale, bool forceUpdate = true );

    void setExtent( const QgsRectangle &extent );

    void zoomToExtent( const QgsRectangle &extent );

    QgsRectangle extent() const;


    QPolygonF visibleExtentPolygon() const;

    QgsCoordinateReferenceSystem crs() const;

    QgsCoordinateReferenceSystem presetCrs() const { return mCrs; }

    void setCrs( const QgsCoordinateReferenceSystem &crs );

    bool keepLayerSet() const { return mKeepLayerSet; }

    void setKeepLayerSet( bool enabled ) { mKeepLayerSet = enabled; }

    QList<QgsMapLayer *> layers() const;

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

    bool keepLayerStyles() const { return mKeepLayerStyles; }

    void setKeepLayerStyles( bool enabled ) { mKeepLayerStyles = enabled; }

    QMap<QString, QString> layerStyleOverrides() const { return mLayerStyleOverrides; }

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

    void storeCurrentLayerStyles();

    bool followVisibilityPreset() const { return mFollowVisibilityPreset; }

    void setFollowVisibilityPreset( bool follow ) { mFollowVisibilityPreset = follow; }

    QString followVisibilityPresetName() const { return mFollowVisibilityPresetName; }

    void setFollowVisibilityPresetName( const QString &name ) { mFollowVisibilityPresetName = name; }

    void moveContent( double dx, double dy ) override;
    void setMoveContentPreviewOffset( double dx, double dy ) override;

    void zoomContent( double factor, QPointF point ) override;


    bool containsWmsLayer() const;

    bool requiresRasterization() const override;
    bool containsAdvancedEffects() const override;

    void setMapRotation( double rotation );

    double mapRotation( QgsLayoutObject::PropertyValueType valueType = QgsLayoutObject::EvaluatedValue ) const;

    void setDrawAnnotations( bool draw ) { mDrawAnnotations = draw; }

    bool drawAnnotations() const { return mDrawAnnotations; }


    bool atlasDriven() const { return mAtlasDriven; }

    void setAtlasDriven( bool enabled );

    AtlasScalingMode atlasScalingMode() const { return mAtlasScalingMode; }

    void setAtlasScalingMode( AtlasScalingMode mode ) { mAtlasScalingMode = mode; }

    double atlasMargin( QgsLayoutObject::PropertyValueType valueType = QgsLayoutObject::EvaluatedValue );

    void setAtlasMargin( double margin ) { mAtlasMargin = margin; }

    QgsLayoutItemMapGridStack *grids() { return mGridStack.get(); }

    QgsLayoutItemMapGrid *grid();

    QgsLayoutItemMapOverviewStack *overviews() { return mOverviewStack.get(); }

    QgsLayoutItemMapOverview *overview();

    QgsExpressionContext createExpressionContext() const override;

    double mapUnitsToLayoutUnits() const;

    QgsMapSettings mapSettings( const QgsRectangle &extent, QSizeF size, double dpi, bool includeLayerSettings ) const;

    void finalizeRestoreFromXml() override;

  protected:

    void draw( QgsLayoutItemRenderContext &context ) override;
    bool writePropertiesToElement( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const override;
    bool readPropertiesFromElement( const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context ) override;

    bool isDrawing() const {return mDrawing;}

    // In case of annotations, the bounding rectangle can be larger than the map item rectangle
    QRectF boundingRect() const override;

    QPolygonF transformedMapPolygon() const;

    QPointF mapToItemCoords( QPointF mapCoords ) const;

    QgsRectangle requestedExtent() const;

  signals:

    void extentChanged();

    void mapRotationChanged( double newRotation );

    void preparedForAtlas();

    void layerStyleOverridesChanged();

  public slots:

    void refresh() override;

    void invalidateCache() override;

    void updateBoundingRect();

    void refreshDataDefinedProperty( QgsLayoutObject::DataDefinedProperty property = QgsLayoutObject::AllProperties ) override;

  private slots:
    void layersAboutToBeRemoved( const QList<QgsMapLayer *> &layers );

    void painterJobFinished();

    void shapeChanged();

    void mapThemeChanged( const QString &theme );

    void recreateCachedImageInBackground();

  private:


    int mMapId = 1;

    std::unique_ptr< QgsLayoutItemMapGridStack > mGridStack;
    std::unique_ptr< QgsLayoutItemMapOverviewStack > mOverviewStack;

    // Map region in map units really used for rendering
    // It can be the same as mUserExtent, but it can be bigger in on dimension if mCalculate==Scale,
    // so that full rectangle in paper is used.
    QgsRectangle mExtent;

    QgsCoordinateReferenceSystem mCrs;

    // Current temporary map region in map units. This is overwritten when atlas feature changes. It's also
    // used when the user changes the map extent and an atlas preview is enabled. This allows the user
    // to manually tweak each atlas preview page without affecting the actual original map extent.
    QgsRectangle mAtlasFeatureExtent;

    // We have two images used for rendering/storing cached map images.
    // the first (mCacheFinalImage) is used ONLY for storing the most recent completed map render. It's always
    // used when drawing map item previews. The second (mCacheRenderingImage) is used temporarily while
    // rendering a new preview image in the background. If (and only if) the background render completes, then
    // mCacheRenderingImage is pushed into mCacheFinalImage, and used from then on when drawing the item preview.
    // This ensures that something is always shown in the map item, even while refreshing the preview image in the
    // background
    std::unique_ptr< QImage > mCacheFinalImage;
    std::unique_ptr< QImage > mCacheRenderingImage;
    bool mUpdatesEnabled = true;

    bool mCacheInvalidated = true;

    int mNumCachedLayers;

    // Set to true if in state of drawing. Concurrent requests to draw method are returned if set to true
    bool mDrawing = false;

    QTimer *mBackgroundUpdateTimer = nullptr;
    double mPreviewScaleFactor = 0;

    bool mDrawingPreview = false;

    double mXOffset = 0.0;
    double mYOffset = 0.0;

    double mLastRenderedImageOffsetX = 0.0;
    double mLastRenderedImageOffsetY = 0.0;

    double mMapRotation = 0;

    double mEvaluatedMapRotation = 0;

    bool mKeepLayerSet = false;

    QList< QgsMapLayerRef > mLayers;

    bool mKeepLayerStyles = false;
    QMap<QString, QString> mLayerStyleOverrides;

    mutable QString mCachedLayerStyleOverridesPresetName;
    mutable QMap<QString, QString> mCachedPresetLayerStyleOverrides;

    bool mFollowVisibilityPreset = false;

    QString mFollowVisibilityPresetName;

    void drawMap( QPainter *painter, const QgsRectangle &extent, QSizeF size, double dpi );

    void connectUpdateSlot();

    void syncLayerSet();

    const QgsLayoutItemMapGrid *constFirstMapGrid() const;

    const QgsLayoutItemMapOverview *constFirstMapOverview() const;

    QRectF mCurrentRectangle;
    bool mDrawAnnotations = true;

    bool mAtlasDriven = false;
    AtlasScalingMode mAtlasScalingMode = Auto;
    double mAtlasMargin = 0.10;

    std::unique_ptr< QPainter > mPainter;
    std::unique_ptr< QgsMapRendererCustomPainterJob > mPainterJob;
    bool mPainterCancelWait = false;

    void init();

    void updateToolTip();

    QList<QgsMapLayer *> layersToRender( const QgsExpressionContext *context = nullptr ) const;

    QMap<QString, QString> layerStyleOverridesToRender( const QgsExpressionContext &context ) const;

    QgsRectangle transformedExtent() const;

    void mapPolygon( const QgsRectangle &extent, QPolygonF &poly ) const;

    void transformShift( double &xShift, double &yShift ) const;

    void drawAnnotations( QPainter *painter );
    void drawAnnotation( const QgsAnnotation *item, QgsRenderContext &context );
    QPointF layoutMapPosForItem( const QgsAnnotation *item ) const;

    void drawMapFrame( QPainter *p );
    void drawMapBackground( QPainter *p );

    enum PartType
    {
      Background,
      Layer,
      Grid,
      OverviewMapExtent,
      Frame,
      SelectionBoxes
    };

    bool shouldDrawPart( PartType part ) const;

    void refreshMapExtents( const QgsExpressionContext *context = nullptr );

    void updateAtlasFeature();

    QgsRectangle computeAtlasRectangle();

    friend class QgsLayoutItemMapGrid;
    friend class QgsLayoutItemMapOverview;
    friend class QgsLayoutItemLegend;
    friend class TestQgsLayoutMap;
    friend class QgsCompositionConverter;

};

#endif //QGSLAYOUTITEMMAP_H