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 "qgsgrouplayer.h"
#include "qgslayoutitem.h"
#include "qgslayoutitemmapgrid.h"
#include "qgslayoutitemmapoverview.h"
#include "qgslayoutitemregistry.h"
#include "qgsmaplayerref.h"
#include "qgsmaprenderercustompainterjob.h"
#include "qgsmaprendererstagedrenderjob.h"
#include "qgstemporalrangeobject.h"
 
class QgsAnnotation;
class QgsRenderedFeatureHandlerInterface;
class QgsGroupedFeatureFilterProvider;

class CORE_EXPORT QgsLayoutItemMapAtlasClippingSettings : public QObject
{
    Q_OBJECT
 
  public:

    QgsLayoutItemMapAtlasClippingSettings( QgsLayoutItemMap *map SIP_TRANSFERTHIS = nullptr );

    bool enabled() const;

    void setEnabled( bool enabled );

    QgsMapClippingRegion::FeatureClippingType featureClippingType() const;

    void setFeatureClippingType( QgsMapClippingRegion::FeatureClippingType type );

    bool forceLabelsInsideFeature() const;

    void setForceLabelsInsideFeature( bool forceInside );

    bool clipItemShape() const;

    void setClipItemShape( bool clipItemShape );

    bool restrictToLayers() const;

    void setRestrictToLayers( bool enabled );

    QList< QgsMapLayer * > layersToClip() const;

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

    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;

    bool readXml( const QDomElement &element, const QDomDocument &doc, const QgsReadWriteContext &context );
 
  signals:

    void changed();
 
  private slots:
    void layersAboutToBeRemoved( const QList<QgsMapLayer *> &layers );
 
  private:
 
    QgsLayoutItemMap *mMap = nullptr;
    bool mClipToAtlasFeature = false;
    bool mRestrictToLayers = false;
    QList< QgsMapLayerRef > mLayersToClip;
    QgsMapClippingRegion::FeatureClippingType mFeatureClippingType = QgsMapClippingRegion::FeatureClippingType::ClipPainterOnly;
    bool mForceLabelsInsideFeature = false;
    bool mClipItemShape = false;
};
 

class CORE_EXPORT QgsLayoutItemMapItemClipPathSettings : public QObject
{
    Q_OBJECT
 
  public:

    QgsLayoutItemMapItemClipPathSettings( QgsLayoutItemMap *map SIP_TRANSFERTHIS = nullptr );

    bool isActive() const;

    bool enabled() const;

    void setEnabled( bool enabled );

    QgsGeometry clippedMapExtent() const;

    QgsGeometry clipPathInMapItemCoordinates() const;

    QgsMapClippingRegion toMapClippingRegion() const;

    void setSourceItem( QgsLayoutItem *item );

    QgsLayoutItem *sourceItem();

    QgsMapClippingRegion::FeatureClippingType featureClippingType() const;

    void setFeatureClippingType( QgsMapClippingRegion::FeatureClippingType type );

    bool forceLabelsInsideClipPath() const;

    void setForceLabelsInsideClipPath( bool forceInside );

    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;

    bool readXml( const QDomElement &element, const QDomDocument &doc, const QgsReadWriteContext &context );

    void finalizeRestoreFromXml();
 
  signals:

    void changed();
 
  private:
 
    QgsLayoutItemMap *mMap = nullptr;
    bool mEnabled = false;
    QgsMapClippingRegion::FeatureClippingType mFeatureClippingType = QgsMapClippingRegion::FeatureClippingType::ClipPainterOnly;
    bool mForceLabelsInsideClipPath = false;
 
    QPointer< QgsLayoutItem > mClipPathSource;
    QString mClipPathUuid;
 
};
 

class CORE_EXPORT QgsLayoutItemMap : public QgsLayoutItem, public QgsTemporalRangeObject
{
 
    Q_OBJECT
 
  public:

    static const QgsSettingsEntryBool *settingForceRasterMasks SIP_SKIP;

    enum AtlasScalingMode
    {
      Fixed,      

      Predefined,

      Auto
    };

    enum MapItemFlag SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowPartialLabels  = 1 << 0, 
      ShowUnplacedLabels = 1 << 1, 
    };
    Q_DECLARE_FLAGS( MapItemFlags, MapItemFlag )
 
    
    explicit QgsLayoutItemMap( QgsLayout *layout );
    ~QgsLayoutItemMap() override;
 
    int type() const override;
    QIcon icon() const override;
    QgsLayoutItem::Flags itemFlags() const override;

    QgsLayoutItemMap::MapItemFlags mapFlags() const;

    void setMapFlags( QgsLayoutItemMap::MapItemFlags flags );

    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;

    Q_DECL_DEPRECATED int numberExportLayers() const override SIP_DEPRECATED;
 
    void startLayeredExport() override;
    void stopLayeredExport() override;
    bool nextExportPart() override;
    ExportLayerBehavior exportLayerBehavior() const override;
    QgsLayoutItem::ExportLayerDetail exportLayerDetails() const override;
    void setFrameStrokeWidth( 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 );

    QString followVisibilityPresetName() const { return mFollowVisibilityPresetName; }

    void setFollowVisibilityPresetName( const QString &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();

    QgsLayoutMeasurement labelMargin() const;

    void setLabelMargin( const QgsLayoutMeasurement &margin );
 
    QgsExpressionContext createExpressionContext() const override;

    double mapUnitsToLayoutUnits() const;

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

    QList<QgsMapLayer *> layersToRender( const QgsExpressionContext *context = nullptr, bool includeInvalidLayers = false ) const;

    void addLabelBlockingItem( QgsLayoutItem *item );

    void removeLabelBlockingItem( QgsLayoutItem *item );

    bool isLabelBlockingItem( QgsLayoutItem *item ) const;

    QgsMapRendererJob::Errors renderingErrors() const { return mRenderingErrors; }

    QgsLabelingResults *previewLabelingResults() const;
 
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;

    void addRenderedFeatureHandler( QgsRenderedFeatureHandlerInterface *handler );

    void removeRenderedFeatureHandler( QgsRenderedFeatureHandlerInterface *handler );

    QTransform layoutToMapCoordsTransform() const;

    QgsLayoutItemMapAtlasClippingSettings *atlasClippingSettings() { return mAtlasClippingSettings; }

    QgsLayoutItemMapItemClipPathSettings *itemClippingSettings() { return mItemClippingSettings; }

    void setZRangeEnabled( bool enabled );

    bool zRangeEnabled() const;

    QgsDoubleRange zRange() const;

    void setZRange( const QgsDoubleRange &range );
 
    // Reimplement estimatedFrameBleed to take the grid frame into account
    double estimatedFrameBleed() const 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;
    QPainterPath framePath() const 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();

    void themeChanged( const QString &theme );

    void crsChanged();

    void previewRefreshed();
 
  public slots:
 
    void refresh() override;
 
    void invalidateCache() override;

    void updateBoundingRect();
 
    void refreshDataDefinedProperty( QgsLayoutObject::DataDefinedProperty property = QgsLayoutObject::DataDefinedProperty::AllProperties ) override;
 
  private slots:
    void layersAboutToBeRemoved( const QList<QgsMapLayer *> &layers );
 
    void painterJobFinished();
 
    void shapeChanged();
 
    void mapThemeChanged( const QString &theme );

    void currentMapThemeRenamed( const QString &theme, const QString &newTheme );

    void recreateCachedImageInBackground();
 
    void updateAtlasFeature();
  private:
 
    QgsLayoutItemMap::MapItemFlags mMapFlags = QgsLayoutItemMap::MapItemFlags();

    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;
    double mPreviewDevicePixelRatio = 1.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 mZRangeEnabled = false;
    QgsDoubleRange mZRange;

    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;

    QString mLastEvaluatedThemeName;

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

    void connectUpdateSlot();

    void syncLayerSet();

    const QgsLayoutItemMapGrid *constFirstMapGrid() const;

    const QgsLayoutItemMapOverview *constFirstMapOverview() const;

    QList< QgsLabelBlockingRegion > createLabelBlockingRegions( const QgsMapSettings &mapSettings ) 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;
 
    QgsLayoutMeasurement mLabelMargin{ 0 };
    QgsLayoutMeasurement mEvaluatedLabelMargin{ 0 };
 
    QStringList mBlockingLabelItemUuids;
    QList< QPointer< QgsLayoutItem > > mBlockingLabelItems;

    QgsMapRendererJob::Errors mRenderingErrors;
 
    QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
 
    std::unique_ptr< QgsMapRendererStagedRenderJob > mStagedRendererJob;
 
    std::unique_ptr< QgsLabelingResults > mPreviewLabelingResults;
    std::unique_ptr< QgsLabelingResults > mExportLabelingResults;
 
    void init();

    void updateToolTip();
 
    QString themeToRender( const QgsExpressionContext &context ) 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
    {
      Start,
      Background,
      Layer,
      Grid,
      OverviewMapExtent,
      Frame,
      SelectionBoxes,
      End,
      NotLayered,
    };

    bool shouldDrawPart( PartType part ) const;
 
    PartType mCurrentExportPart = NotLayered;
    QStringList mExportThemes;
    QStringList::iterator mExportThemeIt;
 
    QgsLayoutItemMapAtlasClippingSettings *mAtlasClippingSettings = nullptr;
    QgsLayoutItemMapItemClipPathSettings *mItemClippingSettings = nullptr;
 
    std::unique_ptr<QgsGroupedFeatureFilterProvider> mAtlasFeatureFilterProvider;

    void refreshMapExtents( const QgsExpressionContext *context = nullptr );
 
    void refreshLabelMargin( bool updateItem );
 
    QgsRectangle computeAtlasRectangle();
 
    void createStagedRenderJob( const QgsRectangle &extent, const QSizeF size, double dpi );
 
    QPolygonF calculateVisibleExtentPolygon( bool includeClipping ) const;

    std::map<QString, std::unique_ptr<QgsGroupLayer>> mGroupLayers;

    bool hasCustomFramePath() const;
 
    friend class QgsLayoutItemMapGrid;
    friend class QgsLayoutItemMapOverview;
    friend class QgsLayoutItemLegend;
    friend class TestQgsLayoutMap;
    friend class QgsCompositionConverter;
    friend class QgsGeospatialPdfRenderedFeatureHandler;
    friend class QgsLayoutExporter;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayoutItemMap::MapItemFlags )
 
#endif //QGSLAYOUTITEMMAP_H