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"
#include "qgsmaprendererstagedrenderjob.h"
#include "qgstemporalrangeobject.h"
 
class QgsAnnotation;
class QgsRenderedFeatureHandlerInterface;
 
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 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;
};
 
 
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:
 
    enum AtlasScalingMode
    {
      Fixed,      
 
      Predefined,
 
      Auto
    };
 
    enum MapItemFlag
    {
      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 ) const;
 
    void addLabelBlockingItem( QgsLayoutItem *item );
 
    void removeLabelBlockingItem( QgsLayoutItem *item );
 
    bool isLabelBlockingItem( QgsLayoutItem *item ) const;
 
    QgsMapRendererJob::Errors renderingErrors() const { return mRenderingErrors; }
 
    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; }
 
  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 );
 
  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 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;
 
    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;
 
    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;
 
    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;
 
    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;
 
    friend class QgsLayoutItemMapGrid;
    friend class QgsLayoutItemMapOverview;
    friend class QgsLayoutItemLegend;
    friend class TestQgsLayoutMap;
    friend class QgsCompositionConverter;
    friend class QgsGeoPdfRenderedFeatureHandler;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayoutItemMap::MapItemFlags )
 
#endif //QGSLAYOUTITEMMAP_H