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 "qgis_core.h"
#include "qgis_sip.h"
#include <QColor>
#include <QPainter>
#include <QPainterPath>
#include <memory>
 
#include "qgscoordinatetransform.h"
#include "qgsexpressioncontext.h"
#include "qgsfeaturefilterprovider.h"
#include "qgslabelsink.h"
#include "qgsmaptopixel.h"
#include "qgsmapunitscale.h"
#include "qgsrectangle.h"
#include "qgsvectorsimplifymethod.h"
#include "qgsdistancearea.h"
#include "qgscoordinatetransformcontext.h"
#include "qgspathresolver.h"
#include "qgstemporalrangeobject.h"
#include "qgsmaskrendersettings.h"
 
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 );
    QgsRenderContext &operator=( const 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;
 
    bool forceVectorOutput() const;
 
    bool useAdvancedEffects() const;
 
    void setUseAdvancedEffects( bool enabled );
 
    bool drawEditingInformation() const;
 
    double rendererScale() const {return mRendererScale;}
 
 
    double symbologyReferenceScale() const { return mSymbologyReferenceScale; }
 
    QgsLabelingEngine *labelingEngine() const { return mLabelingEngine; } SIP_SKIP
 
    QgsLabelSink *labelSink() const { return mLabelSink; } SIP_SKIP
 
    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; }
 
    void setForceVectorOutput( bool force );
 
    void setLabelingEngine( QgsLabelingEngine *engine ) { mLabelingEngine = engine; } SIP_SKIP
 
    void setLabelSink( QgsLabelSink *sink ) { mLabelSink = sink; } SIP_SKIP
 
    void setSelectionColor( const QColor &color ) { mSelectionColor = color; }
 
    void setShowSelection( bool showSelection );
 
    bool useRenderingOptimization() const;
 
    void setUseRenderingOptimization( bool enabled );
 
    const QgsVectorSimplifyMethod &vectorSimplifyMethod() const { return mVectorSimplifyMethod; }
 
    void setVectorSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mVectorSimplifyMethod = simplifyMethod; }
 
    void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
 
    QgsExpressionContext &expressionContext() { return mExpressionContext; }
 
    const QgsExpressionContext &expressionContext() const { return mExpressionContext; } SIP_SKIP
 
    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 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; }
 
    QVariantMap customRenderingFlags() const { return mCustomRenderingFlags; }
 
    void setCustomRenderingFlag( const QString &flag, const QVariant &value ) { mCustomRenderingFlags[flag] = value; }
 
    void clearCustomRenderingFlag( const QString &flag ) { mCustomRenderingFlags.remove( flag ); }
 
    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::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:
 
    Qgis::RenderContextFlags mFlags;
 
    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 mCustomRenderingFlags;
 
    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