qgsrendercontext.h

Go to the documentation of this file.

/***************************************************************************
                              qgsrendercontext.h
                              ------------------
  begin                : March 16, 2008
  copyright            : (C) 2008 by Marco Hugentobler
  email                : marco dot hugentobler at karto dot baug dot ethz dot ch
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 QGSRENDERCONTEXT_H
#define QGSRENDERCONTEXT_H
 
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscoordinatetransform.h"
#include "qgscoordinatetransformcontext.h"
#include "qgsdistancearea.h"
#include "qgsexpressioncontext.h"
#include "qgsfeaturefilterprovider.h"
#include "qgslabelsink.h"
#include "qgsmaptopixel.h"
#include "qgsmapunitscale.h"
#include "qgsmaskrendersettings.h"
#include "qgspathresolver.h"
#include "qgsrectangle.h"
#include "qgstemporalrangeobject.h"
#include "qgsvectorsimplifymethod.h"
 
#include <QColor>
#include <QPainter>
#include <QPainterPath>
 
class QPainter;
class QgsAbstractGeometry;
class QgsLabelingEngine;
class QgsMapSettings;
class QgsRenderedFeatureHandlerInterface;
class QgsSymbolLayer;
class QgsMaskIdProvider;
class QgsMapClippingRegion;
class QgsElevationMap;
 

class CORE_EXPORT QgsRenderContext : public QgsTemporalRangeObject
{
  public:
    QgsRenderContext();
    ~QgsRenderContext() override;
 
    QgsRenderContext( const QgsRenderContext &rh );
    SIP_SKIP QgsRenderContext( QgsRenderContext &&rh );
    QgsRenderContext &operator=( const QgsRenderContext &rh );
    QgsRenderContext &operator=( QgsRenderContext &&rh );

    void setFlags( Qgis::RenderContextFlags flags );

    void setFlag( Qgis::RenderContextFlag flag, bool on = true );

    Qgis::RenderContextFlags flags() const;

    bool testFlag( Qgis::RenderContextFlag flag ) const;

    static QgsRenderContext fromMapSettings( const QgsMapSettings &mapSettings );

    static QgsRenderContext fromQPainter( QPainter *painter );
 
    //getters

    QPainter *painter() {return mPainter;}
 
#ifndef SIP_RUN

    const QPainter *painter() const { return mPainter; }
#endif

    QPainter *previewRenderPainter() {return mPreviewRenderPainter;}
 
#ifndef SIP_RUN

    const QPainter *previewRenderPainter() const { return mPreviewRenderPainter; }
#endif

    void setPainterFlagsUsingContext( QPainter *painter = nullptr ) const;

    QPainter *maskPainter( int id = 0 ) { return mMaskPainter.value( id, nullptr ); }
 
    // TODO QGIS 4 : remove the V2 from method name

    Q_DECL_DEPRECATED void setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers ) SIP_DEPRECATED;

    void setDisabledSymbolLayersV2( const QSet<QString> &symbolLayers );

    Q_DECL_DEPRECATED QSet<const QgsSymbolLayer *> disabledSymbolLayers() const SIP_DEPRECATED;

    QSet<QString> disabledSymbolLayersV2() const;

    bool isSymbolLayerEnabled( const QgsSymbolLayer *layer ) const;

    QgsCoordinateTransform coordinateTransform() const {return mCoordTransform;}

    const QgsDistanceArea &distanceArea() const { return mDistanceArea; }

    QgsCoordinateTransformContext transformContext() const;

    void setTransformContext( const QgsCoordinateTransformContext &context );

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

    void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }

    const QgsRectangle &extent() const { return mExtent; }

    QgsRectangle mapExtent() const { return mOriginalMapExtent; }

    const QgsMapToPixel &mapToPixel() const {return mMapToPixel;}

    double scaleFactor() const {return mScaleFactor;}

    double dpiTarget() const {return mDpiTarget;}

    bool renderingStopped() const {return mRenderingStopped;}

    void setFeedback( QgsFeedback *feedback );

    QgsFeedback *feedback() const;

    Q_DECL_DEPRECATED bool forceVectorOutput() const SIP_DEPRECATED;

    Q_DECL_DEPRECATED bool useAdvancedEffects() const SIP_DEPRECATED;

    Q_DECL_DEPRECATED void setUseAdvancedEffects( bool enabled ) SIP_DEPRECATED;

    bool drawEditingInformation() const;

    double rendererScale() const {return mRendererScale;}
 

    double symbologyReferenceScale() const { return mSymbologyReferenceScale; }

    QgsLabelingEngine *labelingEngine() const SIP_SKIP { return mLabelingEngine; }

    QgsLabelSink *labelSink() const SIP_SKIP { return mLabelSink; }

    QColor selectionColor() const { return mSelectionColor; }

    bool showSelection() const;
 
    //setters

    void setCoordinateTransform( const QgsCoordinateTransform &t );

    void setMapToPixel( const QgsMapToPixel &mtp ) {mMapToPixel = mtp;}

    void setExtent( const QgsRectangle &extent ) {mExtent = extent;}

    void setMapExtent( const QgsRectangle &extent ) { mOriginalMapExtent = extent; }

    void setDrawEditingInformation( bool b );

    void setRenderingStopped( bool stopped ) {mRenderingStopped = stopped;}

    void setDistanceArea( const QgsDistanceArea &distanceArea ) {mDistanceArea = distanceArea ;}

    void setScaleFactor( double factor ) {mScaleFactor = factor;}

    void setDpiTarget( double dpi ) {mDpiTarget = dpi;}

    void setRendererScale( double scale ) {mRendererScale = scale;}

    void setSymbologyReferenceScale( double scale ) { mSymbologyReferenceScale = scale; }

    void setPainter( QPainter *p ) {mPainter = p;}

    void setPreviewRenderPainter( QPainter *painter ) { mPreviewRenderPainter = painter; }

    void setMaskPainter( QPainter *p, int id = 0 ) { mMaskPainter[id] = p; }

    Q_DECL_DEPRECATED void setForceVectorOutput( bool force ) SIP_DEPRECATED;

    void setLabelingEngine( QgsLabelingEngine *engine ) SIP_SKIP { mLabelingEngine = engine; }

    void setLabelSink( QgsLabelSink *sink ) SIP_SKIP { mLabelSink = sink; }

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

    void setShowSelection( bool showSelection );

    bool useRenderingOptimization() const;

    void setUseRenderingOptimization( bool enabled );

    QgsVectorSimplifyMethod &vectorSimplifyMethod() { return mVectorSimplifyMethod; }

    const QgsVectorSimplifyMethod &vectorSimplifyMethod() const SIP_SKIP { return mVectorSimplifyMethod; }

    void setVectorSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mVectorSimplifyMethod = simplifyMethod; }

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

    QgsExpressionContext &expressionContext() { return mExpressionContext; }

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

    const QgsAbstractGeometry *geometry() const { return mGeometry; }
    void setGeometry( const QgsAbstractGeometry *geometry ) { mGeometry = geometry; }

    void setFeatureFilterProvider( const QgsFeatureFilterProvider *ffp );

    const QgsFeatureFilterProvider *featureFilterProvider() const;

    void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }

    double segmentationTolerance() const { return mSegmentationTolerance; }

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

    QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }
 
    // Conversions

    double convertToPainterUnits( double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property = Qgis::RenderSubcomponentProperty::Generic ) const;

    double convertFromPainterUnits( double size, Qgis::RenderUnit unit ) const;

    double convertToMapUnits( double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;

    double convertFromMapUnits( double sizeInMapUnits, Qgis::RenderUnit outputUnit ) const;

    double convertMetersToMapUnits( double meters ) const;

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

    void setTextRenderFormat( Qgis::TextRenderFormat format )
    {
      mTextRenderFormat = format;
    }

    QList<QgsRenderedFeatureHandlerInterface *> renderedFeatureHandlers() const;

    bool hasRenderedFeatureHandlers() const { return mHasRenderedFeatureHandlers; }

    void setMaskIdProvider( QgsMaskIdProvider *provider ) { mMaskIdProvider = provider; }

    const QgsMaskIdProvider *maskIdProvider() const { return mMaskIdProvider; }

    void setCurrentMaskId( int id ) { mCurrentMaskId = id; }

    int currentMaskId() const { return mCurrentMaskId; }

    void setIsGuiPreview( bool preview ) { mIsGuiPreview = preview; }

    bool isGuiPreview() const { return mIsGuiPreview; }

    Q_DECL_DEPRECATED QVariantMap customRenderingFlags() const SIP_DEPRECATED { return mCustomProperties; }

    QVariantMap customProperties() const { return mCustomProperties; }

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

    void setCustomProperty( const QString &property, const QVariant &value ) { mCustomProperties[property] = value; }

    Q_DECL_DEPRECATED void clearCustomRenderingFlag( const QString &flag ) SIP_DEPRECATED { mCustomProperties.remove( flag ); }

    void clearCustomProperty( const QString &property ) { mCustomProperties.remove( property ); }

    QList< QgsMapClippingRegion > clippingRegions() const;

    QgsGeometry featureClipGeometry() const;

    void setFeatureClipGeometry( const QgsGeometry &geometry );

    QPointF textureOrigin() const;

    void setTextureOrigin( const QPointF &origin );

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

    QgsMaskRenderSettings &maskSettings() { return mMaskRenderSettings; }

    void setMaskSettings( const QgsMaskRenderSettings &settings );

    Q_DECL_DEPRECATED void addSymbolLayerClipPath( const QString &symbolLayerId, QPainterPath path ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED QList<QPainterPath> symbolLayerClipPaths( const QString &symbolLayerId ) const SIP_DEPRECATED;

    void addSymbolLayerClipGeometry( const QString &symbolLayerId, const QgsGeometry &geometry );

    bool symbolLayerHasClipGeometries( const QString &symbolLayerId ) const;

    QVector<QgsGeometry> symbolLayerClipGeometries( const QString &symbolLayerId ) const;

    QgsDoubleRange zRange() const;

    void setZRange( const QgsDoubleRange &range );

    QSize outputSize() const;

    void setOutputSize( QSize size );

    float devicePixelRatio() const;

    void setDevicePixelRatio( float ratio );

    QSize deviceOutputSize() const;

    void setImageFormat( QImage::Format format ) { mImageFormat = format; }

    QImage::Format imageFormat() const { return mImageFormat; }

    Qgis::RasterizedRenderingPolicy rasterizedRenderingPolicy() const;

    void setRasterizedRenderingPolicy( Qgis::RasterizedRenderingPolicy policy );

    Qgis::RendererUsage rendererUsage() const {return mRendererUsage;}

    void setRendererUsage( Qgis::RendererUsage usage ) {mRendererUsage = usage;}

    double frameRate() const;

    void setFrameRate( double rate );

    long long currentFrame() const;

    void setCurrentFrame( long long frame );
 

    QgsElevationMap *elevationMap() const;

    void setElevationMap( QgsElevationMap *map );
 
  private:
 
    void matchRasterizedRenderingPolicyToFlags();
 
    Qgis::RenderContextFlags mFlags;
    Qgis::RasterizedRenderingPolicy mRasterizedRenderingPolicy = Qgis::RasterizedRenderingPolicy::Default;

    QPainter *mPainter = nullptr;

    QPainter *mPreviewRenderPainter = nullptr;

    QMap<int, QPainter *> mMaskPainter;

    QgsMaskIdProvider *mMaskIdProvider = nullptr;

    int mCurrentMaskId = -1;

    bool mIsGuiPreview = false;

    QgsCoordinateTransform mCoordTransform;

    QgsDistanceArea mDistanceArea;
 
    QgsRectangle mExtent;
    QgsRectangle mOriginalMapExtent;
 
    QgsMapToPixel mMapToPixel;

    bool mRenderingStopped = false;

    QgsFeedback *mFeedback = nullptr;

    double mScaleFactor = 1.0;

    double mDpiTarget = -1.0;

    double mRendererScale = 1.0;
 
    double mSymbologyReferenceScale = -1;

    QgsLabelingEngine *mLabelingEngine = nullptr;

    QgsLabelSink *mLabelSink = nullptr;

    QColor mSelectionColor;

    QgsVectorSimplifyMethod mVectorSimplifyMethod;

    QgsExpressionContext mExpressionContext;

    const QgsAbstractGeometry *mGeometry = nullptr;

    std::unique_ptr< QgsFeatureFilterProvider > mFeatureFilterProvider;
 
    double mSegmentationTolerance = M_PI_2 / 90;
 
    QgsAbstractGeometry::SegmentationToleranceType mSegmentationToleranceType = QgsAbstractGeometry::MaximumAngle;
 
    QgsCoordinateTransformContext mTransformContext;
 
    QgsPathResolver mPathResolver;
 
    Qgis::TextRenderFormat mTextRenderFormat = Qgis::TextRenderFormat::AlwaysOutlines;
    QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
    bool mHasRenderedFeatureHandlers = false;
    QVariantMap mCustomProperties;
 
    QSet<QString> mDisabledSymbolLayers;
 
    QList< QgsMapClippingRegion > mClippingRegions;
    QgsGeometry mFeatureClipGeometry;
 
    QPointF mTextureOrigin;
 
    QgsDoubleRange mZRange;
 
    QSize mSize;
    float mDevicePixelRatio = 1.0;
    QImage::Format mImageFormat = QImage::Format_ARGB32_Premultiplied;
 
    Qgis::RendererUsage mRendererUsage = Qgis::RendererUsage::Unknown;
 
    double mFrameRate = -1;
    long long mCurrentFrame = -1;

    QMap< QString, QVector<QgsGeometry> > mSymbolLayerClippingGeometries;
 
    QgsMaskRenderSettings mMaskRenderSettings;
 
#ifdef QGISDEBUG
    bool mHasTransformContext = false;
#endif
 
    QgsElevationMap *mElevationMap = nullptr;
};
 
#ifndef SIP_RUN

class QgsScopedRenderContextPainterSwap
{
  public:

    QgsScopedRenderContextPainterSwap( QgsRenderContext &context, QPainter *temporaryPainter )
      : mContext( context )
      , mPreviousPainter( context.painter() )
    {
      mContext.setPainter( temporaryPainter );
    }

    void reset()
    {
      if ( !mReleased )
      {
        mContext.setPainter( mPreviousPainter );
        mReleased = true;
      }
    }

    ~QgsScopedRenderContextPainterSwap()
    {
      reset();
    }
 
  private:
 
    QgsRenderContext &mContext;
    QPainter *mPreviousPainter = nullptr;
    bool mReleased = false;
};
 

class QgsScopedRenderContextScaleToMm
{
  public:

    QgsScopedRenderContextScaleToMm( QgsRenderContext &context )
      : mContext( context )
    {
      if ( mContext.painter() )
        mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
    }

    ~QgsScopedRenderContextScaleToMm()
    {
      if ( mContext.painter() )
        mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
    }
 
  private:
 
    QgsRenderContext &mContext;
};
 

class QgsScopedRenderContextScaleToPixels
{
  public:

    QgsScopedRenderContextScaleToPixels( QgsRenderContext &context )
      : mContext( context )
    {
      if ( mContext.painter() )
        mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
    }

    ~QgsScopedRenderContextScaleToPixels()
    {
      if ( mContext.painter() )
        mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
    }
 
  private:
 
    QgsRenderContext &mContext;
};
 

class QgsScopedQPainterState
{
  public:

    QgsScopedQPainterState( QPainter *painter )
      : mPainter( painter )
    {
      mPainter->save();
    }

    ~QgsScopedQPainterState()
    {
      mPainter->restore();
    }
 
  private:
 
    QPainter *mPainter = nullptr;
};
 

class QgsScopedRenderContextReferenceScaleOverride
{
  public:

    QgsScopedRenderContextReferenceScaleOverride( QgsRenderContext &context, double scale )
      : mContext( &context )
      , mOriginalScale( context.symbologyReferenceScale() )
    {
      mContext->setSymbologyReferenceScale( scale );
    }

    QgsScopedRenderContextReferenceScaleOverride( QgsScopedRenderContextReferenceScaleOverride &&o ) noexcept
      : mContext( o.mContext )
      , mOriginalScale( o.mOriginalScale )
    {
      o.mContext = nullptr;
    }

    ~QgsScopedRenderContextReferenceScaleOverride()
    {
      if ( mContext )
        mContext->setSymbologyReferenceScale( mOriginalScale );
    }
 
  private:
 
    QgsRenderContext *mContext = nullptr;
    double mOriginalScale = 0;
};
 
 
#endif
 
#endif