qgsmapsettings.h

Go to the documentation of this file.

/***************************************************************************
  qgsmapsettings.h
  --------------------------------------
  Date                 : December 2013
  Copyright            : (C) 2013 by Martin Dobias
  Email                : wonder dot sk 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 QGSMAPSETTINGS_H
#define QGSMAPSETTINGS_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscoordinatereferencesystem.h"
#include "qgselevationshadingrenderer.h"
#include "qgsexpressioncontext.h"
#include "qgsgeometry.h"
#include "qgslabelingenginesettings.h"
#include "qgsmapclippingregion.h"
#include "qgsmaplayer.h"
#include "qgsmaptopixel.h"
#include "qgsmaskrendersettings.h"
#include "qgsrectangle.h"
#include "qgsscalecalculator.h"
#include "qgstemporalrangeobject.h"
#include "qgsvectorsimplifymethod.h"
 
#include <QColor>
#include <QImage>
#include <QPointer>
#include <QSize>
#include <QStringList>
 
class QPainter;
 
class QgsCoordinateTransform;
class QgsScaleCalculator;
class QgsMapRendererJob;
class QgsRenderedFeatureHandlerInterface;

class CORE_EXPORT QgsLabelBlockingRegion
{
  public:

    explicit QgsLabelBlockingRegion( const QgsGeometry &geometry )
      : geometry( geometry )
    {}

    QgsGeometry geometry;
 
};
 

class CORE_EXPORT QgsMapSettings : public QgsTemporalRangeObject
{
  public:
    QgsMapSettings();

    QgsRectangle extent() const;

    void setExtent( const QgsRectangle &rect, bool magnified = true );

    double extentBuffer() const;

    void setExtentBuffer( double buffer );

    QSize outputSize() const;

    void setOutputSize( QSize size );

    float devicePixelRatio() const;

    void setDevicePixelRatio( float dpr );

    QSize deviceOutputSize() const;

    double rotation() const;

    void setRotation( double rotation );

    double outputDpi() const;

    void setOutputDpi( double dpi );

    double dpiTarget() const;

    void setDpiTarget( double dpi );

    void setMagnificationFactor( double factor, const QgsPointXY *center = nullptr );

    double magnificationFactor() const;

    QStringList layerIds( bool expandGroupLayers = false ) const;

    QList<QgsMapLayer *> layers( bool expandGroupLayers = false ) const;
 
 
#ifndef SIP_RUN
    template <typename T>
    QVector<T> layers() const;
#endif

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

    QMap<QString, QString> layerStyleOverrides() const;

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

    Q_DECL_DEPRECATED QString customRenderFlags() const { return mCustomRenderFlags; }

    Q_DECL_DEPRECATED void setCustomRenderFlags( const QString &customRenderFlags ) { mCustomRenderFlags = customRenderFlags; }

    QVariantMap customRenderingFlags() const { return mCustomRenderingFlags; }

    void setCustomRenderingFlag( const QString &flag, const QVariant &value ) { mCustomRenderingFlags[flag] = value; }

    void clearCustomRenderingFlag( const QString &flag ) { mCustomRenderingFlags.remove( flag ); }

    void setDestinationCrs( const QgsCoordinateReferenceSystem &crs );

    QgsCoordinateReferenceSystem destinationCrs() const;

    Qgis::DistanceUnit mapUnits() const;

    Qgis::ScaleCalculationMethod scaleMethod() const;

    void setScaleMethod( Qgis::ScaleCalculationMethod method );

    bool setEllipsoid( const QString &ellipsoid );

    QString ellipsoid() const { return mEllipsoid; }

    void setBackgroundColor( const QColor &color ) { mBackgroundColor = color; }

    QColor backgroundColor() const { return mBackgroundColor; }

    void setSelectionColor( const QColor &color ) { mSelectionColor = color; }

    QColor selectionColor() const { return mSelectionColor; }

    void setFlags( Qgis::MapSettingsFlags flags );
    void setFlag( Qgis::MapSettingsFlag flag, bool on = true );
    Qgis::MapSettingsFlags flags() const;
    bool testFlag( Qgis::MapSettingsFlag flag ) const;

    Qgis::TextRenderFormat textRenderFormat() const
    {
      return mTextRenderFormat;
    }

    void setTextRenderFormat( Qgis::TextRenderFormat format )
    {
      mTextRenderFormat = format;
      // ensure labeling engine setting is also kept in sync, just in case anyone accesses QgsMapSettings::labelingEngineSettings().defaultTextRenderFormat()
      // instead of correctly calling QgsMapSettings::textRenderFormat(). It can't hurt to be consistent!
      mLabelingEngineSettings.setDefaultTextRenderFormat( format );
    }

    void setOutputImageFormat( QImage::Format format ) { mImageFormat = format; }
    QImage::Format outputImageFormat() const { return mImageFormat; }

    bool hasValidSettings() const;
    QgsRectangle visibleExtent() const;

    QPolygonF visiblePolygon() const;

    QPolygonF visiblePolygonWithBuffer() const;

    double mapUnitsPerPixel() const;

    double scale() const;

    void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }

    const QgsExpressionContext &expressionContext() const { return mExpressionContext; }

    QgsCoordinateTransformContext transformContext() const;

    void setTransformContext( const QgsCoordinateTransformContext &context );

    const QgsPathResolver &pathResolver() const { return mPathResolver; }

    void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }
 
    const QgsMapToPixel &mapToPixel() const { return mMapToPixel; }

    double layerToMapUnits( const QgsMapLayer *layer, const QgsRectangle &referenceExtent = QgsRectangle() ) const;

    QgsRectangle layerExtentToOutputExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;

    QgsRectangle outputExtentToLayerExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;

    QgsPointXY layerToMapCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;

    QgsPoint layerToMapCoordinates( const QgsMapLayer *layer, const QgsPoint &point ) const;

    QgsRectangle layerToMapCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;

    QgsPointXY mapToLayerCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;

    QgsPoint mapToLayerCoordinates( const QgsMapLayer *layer, const QgsPoint &point ) const;

    QgsRectangle mapToLayerCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;

    QgsCoordinateTransform layerTransform( const QgsMapLayer *layer ) const;

    QgsRectangle computeExtentForScale( const QgsPointXY &center, double scale ) const;

    double computeScaleForExtent( const QgsRectangle &extent ) const;

    QgsRectangle fullExtent() const;

    void readXml( QDomNode &node );

    void writeXml( QDomNode &node, QDomDocument &doc );

    void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }
    double segmentationTolerance() const { return mSegmentationTolerance; }

    void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type ) { mSegmentationToleranceType = type; }
    QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }

    void setLabelingEngineSettings( const QgsLabelingEngineSettings &settings )
    {
      mLabelingEngineSettings = settings;
      mTextRenderFormat = settings.defaultTextRenderFormat();
    }

    const QgsLabelingEngineSettings &labelingEngineSettings() const { return mLabelingEngineSettings; }

    QgsGeometry labelBoundaryGeometry() const;

    void setLabelBoundaryGeometry( const QgsGeometry &boundary );

    void setLabelBlockingRegions( const QList< QgsLabelBlockingRegion > &regions ) { mLabelBlockingRegions = regions; }

    QList< QgsLabelBlockingRegion > labelBlockingRegions() const { return mLabelBlockingRegions; }

    void addClippingRegion( const QgsMapClippingRegion &region );

    void setClippingRegions( const QList< QgsMapClippingRegion > &regions );

    QList< QgsMapClippingRegion > clippingRegions() const;

    void setSimplifyMethod( const QgsVectorSimplifyMethod &method ) { mSimplifyMethod = method; }

    const QgsVectorSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }

    const QgsMaskRenderSettings &maskSettings() const SIP_SKIP { return mMaskRenderSettings; }

    QgsMaskRenderSettings &maskSettings() { return mMaskRenderSettings; }

    void setMaskSettings( const QgsMaskRenderSettings &settings );

    void addRenderedFeatureHandler( QgsRenderedFeatureHandlerInterface *handler );

    QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const;

    QgsDoubleRange zRange() const;

    void setZRange( const QgsDoubleRange &range );

    Qgis::RendererUsage rendererUsage() const;

    void setRendererUsage( Qgis::RendererUsage rendererUsage );

    double frameRate() const;

    void setFrameRate( double rate );

    long long currentFrame() const;

    void setCurrentFrame( long long frame );

    const QgsElevationShadingRenderer &elevationShadingRenderer() const;

    void setElevationShadingRenderer( const QgsElevationShadingRenderer &renderer );

    Qgis::RasterizedRenderingPolicy rasterizedRenderingPolicy() const;

    void setRasterizedRenderingPolicy( Qgis::RasterizedRenderingPolicy policy );
 
  protected:
 
    double mDpi = 96.0;
    double mDpiTarget = -1;
 
    QSize mSize;
    float mDevicePixelRatio = 1.0;
 
    QgsRectangle mExtent;
    double mExtentBuffer = 0.0;
 
    double mRotation = 0.0;
    double mMagnificationFactor = 1.0;

    QgsWeakMapLayerPointerList mLayers;
    QStringList mLayerIds;
    bool mHasGroupLayers = false;
 
    QMap<QString, QString> mLayerStyleOverrides;
    QString mCustomRenderFlags;
    QVariantMap mCustomRenderingFlags;
    QgsExpressionContext mExpressionContext;
 
    QgsCoordinateReferenceSystem mDestCRS;
    QString mEllipsoid;
 
    QColor mBackgroundColor;
    QColor mSelectionColor;
 
    Qgis::MapSettingsFlags mFlags;
    Qgis::RasterizedRenderingPolicy mRasterizedRenderingPolicy = Qgis::RasterizedRenderingPolicy::Default;
    QImage::Format mImageFormat = QImage::Format_ARGB32_Premultiplied;
 
    double mSegmentationTolerance;
    QgsAbstractGeometry::SegmentationToleranceType mSegmentationToleranceType = QgsAbstractGeometry::MaximumAngle;
 
    QgsLabelingEngineSettings mLabelingEngineSettings;
 
    // derived properties
    bool mValid = false;
    QgsRectangle mVisibleExtent;
    double mMapUnitsPerPixel = 1;
    double mScale = 1;
 
    // utiity stuff
    QgsScaleCalculator mScaleCalculator;
    QgsMapToPixel mMapToPixel;
 
    QgsCoordinateTransformContext mTransformContext;
 
    QgsPathResolver mPathResolver;
 
    Qgis::TextRenderFormat mTextRenderFormat = Qgis::TextRenderFormat::AlwaysOutlines;
 
    QgsGeometry mLabelBoundaryGeometry;
 
    QgsVectorSimplifyMethod mSimplifyMethod;
 
    Qgis::RendererUsage mRendererUsage = Qgis::RendererUsage::Unknown;
 
    QgsElevationShadingRenderer mShadingRenderer;
 
    double mFrameRate = -1;
    long long mCurrentFrame = -1;
 
    QgsMaskRenderSettings mMaskRenderSettings;
 
#ifdef QGISDEBUG
    bool mHasTransformContext = false;
#endif
 
    void updateDerived();
 
  private:
    void matchRasterizedRenderingPolicyToFlags();
 
    QList< QgsLabelBlockingRegion > mLabelBlockingRegions;
    QList< QgsMapClippingRegion > mClippingRegions;
    QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
 
    QgsDoubleRange mZRange;
 
};
 
#endif // QGSMAPSETTINGS_H