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 <memory>
 
#include "qgscoordinatetransform.h"
#include "qgsexpressioncontext.h"
#include "qgsfeaturefilterprovider.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"
 
class QPainter;
class QgsAbstractGeometry;
class QgsLabelingEngine;
class QgsMapSettings;
class QgsRenderedFeatureHandlerInterface;
class QgsSymbolLayer;
class QgsMaskIdProvider;
class QgsMapClippingRegion;
 
 
class CORE_EXPORT QgsRenderContext : public QgsTemporalRangeObject
{
  public:
    QgsRenderContext();
    ~QgsRenderContext() override;
 
    QgsRenderContext( const QgsRenderContext &rh );
    QgsRenderContext &operator=( const QgsRenderContext &rh );
 
    enum Flag
    {
      DrawEditingInfo          = 0x01,  
      ForceVectorOutput        = 0x02,  
      UseAdvancedEffects       = 0x04,  
      UseRenderingOptimization = 0x08,  
      DrawSelection            = 0x10,  
      DrawSymbolBounds         = 0x20,  
      RenderMapTile            = 0x40,  
      Antialiasing             = 0x80,  
      RenderPartialOutput      = 0x100, 
      RenderPreviewJob         = 0x200, 
      RenderBlocking           = 0x400, 
      RenderSymbolPreview      = 0x800, 
      LosslessImageRendering   = 0x1000, 
      ApplyScalingWorkaroundForTextRendering = 0x2000, 
      Render3DMap              = 0x4000, 
      ApplyClipAfterReprojection = 0x8000, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    enum TextRenderFormat
    {
      // refs for below dox: https://github.com/qgis/QGIS/pull/1286#issuecomment-39806854
      // https://github.com/qgis/QGIS/pull/8573#issuecomment-445585826
 
      TextFormatAlwaysOutlines,
 
      TextFormatAlwaysText,
    };
 
    void setFlags( QgsRenderContext::Flags flags );
 
    void setFlag( Flag flag, bool on = true );
 
    Flags flags() const;
 
    bool testFlag( Flag 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
 
    void setPainterFlagsUsingContext( QPainter *painter = nullptr ) const;
 
    QPainter *maskPainter( int id = 0 ) { return mMaskPainter.value( id, nullptr ); }
 
    QSet<const QgsSymbolLayer *> disabledSymbolLayers() const { return mDisabledSymbolLayers; }
 
    bool isSymbolLayerEnabled( const QgsSymbolLayer *layer ) const { return ! mDisabledSymbolLayers.contains( layer ); }
 
    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;}
 
    bool forceVectorOutput() const;
 
    bool useAdvancedEffects() const;
 
    void setUseAdvancedEffects( bool enabled );
 
    bool drawEditingInformation() const;
 
    double rendererScale() const {return mRendererScale;}
 
    QgsLabelingEngine *labelingEngine() const { return mLabelingEngine; } 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 setPainter( QPainter *p ) {mPainter = p;}
 
    void setMaskPainter( QPainter *p, int id = 0 ) { mMaskPainter[id] = p; }
 
    void setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers ) { mDisabledSymbolLayers = symbolLayers; }
 
    void setForceVectorOutput( bool force );
 
    void setLabelingEngine( QgsLabelingEngine *engine ) { mLabelingEngine = engine; } 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, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
 
    double convertToMapUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
 
    double convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const;
 
    double convertMetersToMapUnits( double meters ) const;
 
    TextRenderFormat textRenderFormat() const
    {
      return mTextRenderFormat;
    }
 
    void setTextRenderFormat( 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 );
 
    QgsDoubleRange zRange() const;
 
    void setZRange( const QgsDoubleRange &range );
 
  private:
 
    Flags mFlags;
 
    QPainter *mPainter = 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;
 
    double mScaleFactor = 1.0;
 
    double mDpiTarget = -1.0;
 
    double mRendererScale = 1.0;
 
    QgsLabelingEngine *mLabelingEngine = 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;
 
    TextRenderFormat mTextRenderFormat = TextFormatAlwaysOutlines;
    QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
    bool mHasRenderedFeatureHandlers = false;
    QVariantMap mCustomRenderingFlags;
 
    QSet<const QgsSymbolLayer *> mDisabledSymbolLayers;
 
    QList< QgsMapClippingRegion > mClippingRegions;
    QgsGeometry mFeatureClipGeometry;
 
    QPointF mTextureOrigin;
 
    QgsDoubleRange mZRange;
 
#ifdef QGISDEBUG
    bool mHasTransformContext = false;
#endif
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsRenderContext::Flags )
 
#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;
};
 
#endif
 
#endif