QGIS API Documentation  3.23.0-Master (7c4a6de034)
qgsrendercontext.h
Go to the documentation of this file.
1 /***************************************************************************
2  qgsrendercontext.h
3  ------------------
4  begin : March 16, 2008
5  copyright : (C) 2008 by Marco Hugentobler
6  email : marco dot hugentobler at karto dot baug dot ethz dot ch
7  ***************************************************************************/
8 
9 /***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
12  * it under the terms of the GNU General Public License as published by *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17 
18 #ifndef QGSRENDERCONTEXT_H
19 #define QGSRENDERCONTEXT_H
20 
21 #include "qgis_core.h"
22 #include "qgis_sip.h"
23 #include <QColor>
24 #include <QPainter>
25 #include <memory>
26 
27 #include "qgscoordinatetransform.h"
28 #include "qgsexpressioncontext.h"
30 #include "qgslabelsink.h"
31 #include "qgsmaptopixel.h"
32 #include "qgsmapunitscale.h"
33 #include "qgsrectangle.h"
35 #include "qgsdistancearea.h"
37 #include "qgspathresolver.h"
38 #include "qgstemporalrangeobject.h"
39 
40 class QPainter;
42 class QgsLabelingEngine;
43 class QgsMapSettings;
45 class QgsSymbolLayer;
46 class QgsMaskIdProvider;
48 
49 
58 class CORE_EXPORT QgsRenderContext : public QgsTemporalRangeObject
59 {
60  public:
62  ~QgsRenderContext() override;
63 
65  QgsRenderContext &operator=( const QgsRenderContext &rh );
66 
71  void setFlags( Qgis::RenderContextFlags flags );
72 
77  void setFlag( Qgis::RenderContextFlag flag, bool on = true );
78 
83  Qgis::RenderContextFlags flags() const;
84 
89  bool testFlag( Qgis::RenderContextFlag flag ) const;
90 
95  static QgsRenderContext fromMapSettings( const QgsMapSettings &mapSettings );
96 
103  static QgsRenderContext fromQPainter( QPainter *painter );
104 
105  //getters
106 
111  QPainter *painter() {return mPainter;}
112 
113 #ifndef SIP_RUN
114 
120  const QPainter *painter() const { return mPainter; }
121 #endif
122 
132  void setPainterFlagsUsingContext( QPainter *painter = nullptr ) const;
133 
143  QPainter *maskPainter( int id = 0 ) { return mMaskPainter.value( id, nullptr ); }
144 
154  QSet<const QgsSymbolLayer *> disabledSymbolLayers() const { return mDisabledSymbolLayers; }
155 
165  bool isSymbolLayerEnabled( const QgsSymbolLayer *layer ) const { return ! mDisabledSymbolLayers.contains( layer ); }
166 
177  QgsCoordinateTransform coordinateTransform() const {return mCoordTransform;}
178 
183  const QgsDistanceArea &distanceArea() const { return mDistanceArea; }
184 
193  QgsCoordinateTransformContext transformContext() const;
194 
203  void setTransformContext( const QgsCoordinateTransformContext &context );
204 
212  const QgsPathResolver &pathResolver() const { return mPathResolver; }
213 
221  void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }
222 
238  const QgsRectangle &extent() const { return mExtent; }
239 
250  QgsRectangle mapExtent() const { return mOriginalMapExtent; }
251 
257  const QgsMapToPixel &mapToPixel() const {return mMapToPixel;}
258 
265  double scaleFactor() const {return mScaleFactor;}
266 
273  double dpiTarget() const {return mDpiTarget;}
274 
284  bool renderingStopped() const {return mRenderingStopped;}
285 
297  void setFeedback( QgsFeedback *feedback );
298 
307  QgsFeedback *feedback() const;
308 
315  bool forceVectorOutput() const;
316 
322  bool useAdvancedEffects() const;
323 
329  void setUseAdvancedEffects( bool enabled );
330 
336  bool drawEditingInformation() const;
337 
343  double rendererScale() const {return mRendererScale;}
344 
345 
361  double symbologyReferenceScale() const { return mSymbologyReferenceScale; }
362 
367  QgsLabelingEngine *labelingEngine() const { return mLabelingEngine; } SIP_SKIP
368 
374  QgsLabelSink *labelSink() const { return mLabelSink; } SIP_SKIP
375 
381  QColor selectionColor() const { return mSelectionColor; }
382 
390  bool showSelection() const;
391 
392  //setters
393 
404  void setCoordinateTransform( const QgsCoordinateTransform &t );
405 
411  void setMapToPixel( const QgsMapToPixel &mtp ) {mMapToPixel = mtp;}
412 
425  void setExtent( const QgsRectangle &extent ) {mExtent = extent;}
426 
437  void setMapExtent( const QgsRectangle &extent ) { mOriginalMapExtent = extent; }
438 
444  void setDrawEditingInformation( bool b );
445 
456  void setRenderingStopped( bool stopped ) {mRenderingStopped = stopped;}
457 
463  void setDistanceArea( const QgsDistanceArea &distanceArea ) {mDistanceArea = distanceArea ;}
464 
471  void setScaleFactor( double factor ) {mScaleFactor = factor;}
472 
479  void setDpiTarget( double dpi ) {mDpiTarget = dpi;}
480 
486  void setRendererScale( double scale ) {mRendererScale = scale;}
487 
503  void setSymbologyReferenceScale( double scale ) { mSymbologyReferenceScale = scale; }
504 
511  void setPainter( QPainter *p ) {mPainter = p;}
512 
520  void setMaskPainter( QPainter *p, int id = 0 ) { mMaskPainter[id] = p; }
521 
531  void setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers ) { mDisabledSymbolLayers = symbolLayers; }
532 
539  void setForceVectorOutput( bool force );
540 
545  void setLabelingEngine( QgsLabelingEngine *engine ) { mLabelingEngine = engine; } SIP_SKIP
546 
553  void setLabelSink( QgsLabelSink *sink ) { mLabelSink = sink; } SIP_SKIP
554 
560  void setSelectionColor( const QColor &color ) { mSelectionColor = color; }
561 
569  void setShowSelection( bool showSelection );
570 
576  bool useRenderingOptimization() const;
577 
583  void setUseRenderingOptimization( bool enabled );
584 
593  const QgsVectorSimplifyMethod &vectorSimplifyMethod() const { return mVectorSimplifyMethod; }
594 
608  void setVectorSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mVectorSimplifyMethod = simplifyMethod; }
609 
616  void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
617 
624  QgsExpressionContext &expressionContext() { return mExpressionContext; }
625 
633  const QgsExpressionContext &expressionContext() const { return mExpressionContext; } SIP_SKIP
634 
636  const QgsAbstractGeometry *geometry() const { return mGeometry; }
638  void setGeometry( const QgsAbstractGeometry *geometry ) { mGeometry = geometry; }
639 
646  void setFeatureFilterProvider( const QgsFeatureFilterProvider *ffp );
647 
654  const QgsFeatureFilterProvider *featureFilterProvider() const;
655 
662  void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }
663 
668  double segmentationTolerance() const { return mSegmentationTolerance; }
669 
676  void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type ) { mSegmentationToleranceType = type; }
677 
682  QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }
683 
684  // Conversions
685 
697  double convertToPainterUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property = Qgis::RenderSubcomponentProperty::Generic ) const;
698 
705  double convertToMapUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
706 
712  double convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const;
713 
720  double convertMetersToMapUnits( double meters ) const;
721 
729  {
730  return mTextRenderFormat;
731  }
732 
740  {
741  mTextRenderFormat = format;
742  }
743 
749  QList<QgsRenderedFeatureHandlerInterface *> renderedFeatureHandlers() const;
750 
756  bool hasRenderedFeatureHandlers() const { return mHasRenderedFeatureHandlers; }
757 
766  void setMaskIdProvider( QgsMaskIdProvider *provider ) { mMaskIdProvider = provider; }
767 
773  const QgsMaskIdProvider *maskIdProvider() const { return mMaskIdProvider; }
774 
780  void setCurrentMaskId( int id ) { mCurrentMaskId = id; }
781 
788  int currentMaskId() const { return mCurrentMaskId; }
789 
799  void setIsGuiPreview( bool preview ) { mIsGuiPreview = preview; }
800 
811  bool isGuiPreview() const { return mIsGuiPreview; }
812 
819  QVariantMap customRenderingFlags() const { return mCustomRenderingFlags; }
820 
828  void setCustomRenderingFlag( const QString &flag, const QVariant &value ) { mCustomRenderingFlags[flag] = value; }
829 
836  void clearCustomRenderingFlag( const QString &flag ) { mCustomRenderingFlags.remove( flag ); }
837 
845  QList< QgsMapClippingRegion > clippingRegions() const;
846 
861  QgsGeometry featureClipGeometry() const;
862 
872  void setFeatureClipGeometry( const QgsGeometry &geometry );
873 
881  QPointF textureOrigin() const;
882 
890  void setTextureOrigin( const QPointF &origin );
891 
898  QgsDoubleRange zRange() const;
899 
906  void setZRange( const QgsDoubleRange &range );
907 
916  QSize outputSize() const;
917 
924  void setOutputSize( QSize size );
925 
934  float devicePixelRatio() const;
935 
944  void setDevicePixelRatio( float ratio );
945 
957  QSize deviceOutputSize() const;
958 
966  void setImageFormat( QImage::Format format ) { mImageFormat = format; }
967 
975  QImage::Format imageFormat() const { return mImageFormat; }
976 
983  Qgis::RendererUsage rendererUsage() const {return mRendererUsage;}
984 
994  void setRendererUsage( Qgis::RendererUsage usage ) {mRendererUsage = usage;}
995 
996  private:
997 
998  Qgis::RenderContextFlags mFlags;
999 
1001  QPainter *mPainter = nullptr;
1002 
1009  QMap<int, QPainter *> mMaskPainter;
1010 
1016  QgsMaskIdProvider *mMaskIdProvider = nullptr;
1017 
1022  int mCurrentMaskId = -1;
1023 
1028  bool mIsGuiPreview = false;
1029 
1031  QgsCoordinateTransform mCoordTransform;
1032 
1038  QgsDistanceArea mDistanceArea;
1039 
1040  QgsRectangle mExtent;
1041  QgsRectangle mOriginalMapExtent;
1042 
1043  QgsMapToPixel mMapToPixel;
1044 
1046  bool mRenderingStopped = false;
1047 
1049  QgsFeedback *mFeedback = nullptr;
1050 
1052  double mScaleFactor = 1.0;
1053 
1055  double mDpiTarget = -1.0;
1056 
1058  double mRendererScale = 1.0;
1059 
1060  double mSymbologyReferenceScale = -1;
1061 
1063  QgsLabelingEngine *mLabelingEngine = nullptr;
1064 
1066  QgsLabelSink *mLabelSink = nullptr;
1067 
1069  QColor mSelectionColor;
1070 
1072  QgsVectorSimplifyMethod mVectorSimplifyMethod;
1073 
1075  QgsExpressionContext mExpressionContext;
1076 
1078  const QgsAbstractGeometry *mGeometry = nullptr;
1079 
1081  std::unique_ptr< QgsFeatureFilterProvider > mFeatureFilterProvider;
1082 
1083  double mSegmentationTolerance = M_PI_2 / 90;
1084 
1086 
1087  QgsCoordinateTransformContext mTransformContext;
1088 
1089  QgsPathResolver mPathResolver;
1090 
1091  Qgis::TextRenderFormat mTextRenderFormat = Qgis::TextRenderFormat::AlwaysOutlines;
1092  QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
1093  bool mHasRenderedFeatureHandlers = false;
1094  QVariantMap mCustomRenderingFlags;
1095 
1096  QSet<const QgsSymbolLayer *> mDisabledSymbolLayers;
1097 
1098  QList< QgsMapClippingRegion > mClippingRegions;
1099  QgsGeometry mFeatureClipGeometry;
1100 
1101  QPointF mTextureOrigin;
1102 
1103  QgsDoubleRange mZRange;
1104 
1105  QSize mSize;
1106  float mDevicePixelRatio = 1.0;
1107  QImage::Format mImageFormat = QImage::Format_ARGB32_Premultiplied;
1108 
1110 
1111 #ifdef QGISDEBUG
1112  bool mHasTransformContext = false;
1113 #endif
1114 };
1115 
1116 #ifndef SIP_RUN
1117 
1130 {
1131  public:
1132 
1139  QgsScopedRenderContextPainterSwap( QgsRenderContext &context, QPainter *temporaryPainter )
1140  : mContext( context )
1141  , mPreviousPainter( context.painter() )
1142  {
1143  mContext.setPainter( temporaryPainter );
1144  }
1145 
1149  void reset()
1150  {
1151  if ( !mReleased )
1152  {
1153  mContext.setPainter( mPreviousPainter );
1154  mReleased = true;
1155  }
1156  }
1157 
1162  {
1163  reset();
1164  }
1165 
1166  private:
1167 
1168  QgsRenderContext &mContext;
1169  QPainter *mPreviousPainter = nullptr;
1170  bool mReleased = false;
1171 };
1172 
1173 
1186 {
1187  public:
1188 
1197  : mContext( context )
1198  {
1199  if ( mContext.painter() )
1200  mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
1201  }
1202 
1207  {
1208  if ( mContext.painter() )
1209  mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
1210  }
1211 
1212  private:
1213 
1214  QgsRenderContext &mContext;
1215 };
1216 
1217 
1230 {
1231  public:
1232 
1241  : mContext( context )
1242  {
1243  if ( mContext.painter() )
1244  mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
1245  }
1246 
1251  {
1252  if ( mContext.painter() )
1253  mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
1254  }
1255 
1256  private:
1257 
1258  QgsRenderContext &mContext;
1259 };
1260 
1261 
1274 {
1275  public:
1276 
1282  QgsScopedQPainterState( QPainter *painter )
1283  : mPainter( painter )
1284  {
1285  mPainter->save();
1286  }
1287 
1292  {
1293  mPainter->restore();
1294  }
1295 
1296  private:
1297 
1298  QPainter *mPainter = nullptr;
1299 };
1300 
1301 
1313 {
1314  public:
1315 
1322  : mContext( &context )
1323  , mOriginalScale( context.symbologyReferenceScale() )
1324  {
1325  mContext->setSymbologyReferenceScale( scale );
1326  }
1327 
1332  : mContext( o.mContext )
1333  , mOriginalScale( o.mOriginalScale )
1334  {
1335  o.mContext = nullptr;
1336  }
1337 
1342  {
1343  if ( mContext )
1344  mContext->setSymbologyReferenceScale( mOriginalScale );
1345  }
1346 
1347  private:
1348 
1349  QgsRenderContext *mContext = nullptr;
1350  double mOriginalScale = 0;
1351 };
1352 
1353 
1354 #endif
1355 
1356 #endif
RenderSubcomponentProperty
Rendering subcomponent properties.
Definition: qgis.h:995
@ Generic
Generic subcomponent property.
TextRenderFormat
Options for rendering text.
Definition: qgis.h:983
RenderContextFlag
Flags which affect rendering operations.
Definition: qgis.h:950
RendererUsage
Usage of the renderer.
Definition: qgis.h:1259
@ Unknown
Renderer used for unknown usage.
Abstract base class for all geometries.
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle.
@ MaximumAngle
Maximum angle between generating radii (lines from arc center to output vertices)
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
QgsRange which stores a range of double values.
Definition: qgsrange.h:203
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Abstract interface for use by classes that filter the features or attributes of a layer.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:125
Abstract base class that can be used to intercept rendered labels from a labeling / rendering job.
Definition: qgslabelsink.h:38
The QgsLabelingEngine class provides map labeling functionality.
A map clipping region (in map coordinates and CRS).
The QgsMapSettings class contains configuration for rendering of the map.
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:39
Struct for storing maximum and minimum scales for measurements in map units.
This class allows the creation of mask ids based on the different label layers and to give a mask id ...
Resolves relative paths into absolute paths and vice versa.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
Contains information about the context of a rendering operation.
void setMapExtent(const QgsRectangle &extent)
Sets the original extent of the map being rendered.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
void setRenderingStopped(bool stopped)
Sets whether the rendering operation has been stopped and any ongoing rendering should be canceled im...
void setDistanceArea(const QgsDistanceArea &distanceArea)
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
Qgis::RendererUsage rendererUsage() const
Returns the renderer usage.
QPainter * maskPainter(int id=0)
Returns a mask QPainter for the render operation.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
bool hasRenderedFeatureHandlers() const
Returns true if the context has any rendered feature handlers.
void setImageFormat(QImage::Format format)
Sets QImage format which should be used for QImages created during rendering.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
double symbologyReferenceScale() const
Returns the symbology reference scale.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
const QgsAbstractGeometry * geometry() const
Returns pointer to the unsegmentized geometry.
void clearCustomRenderingFlag(const QString &flag)
Clears the specified custom rendering flag.
QPainter * painter()
Returns the destination QPainter for the render operation.
double rendererScale() const
Returns the renderer map scale.
QgsExpressionContext & expressionContext()
Gets the expression context.
QgsLabelSink * labelSink() const
Returns the associated label sink, or nullptr if not set.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
void setTextRenderFormat(Qgis::TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
void setGeometry(const QgsAbstractGeometry *geometry)
Sets pointer to original (unsegmentized) geometry.
void setVectorSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification setting to use when rendering vector layers.
QVariantMap customRenderingFlags() const
Gets custom rendering flags.
bool isGuiPreview() const
Returns the Gui preview mode.
void setCurrentMaskId(int id)
Stores a mask id as the "current" one.
void setDisabledSymbolLayers(const QSet< const QgsSymbolLayer * > &symbolLayers)
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setDpiTarget(double dpi)
Sets the targeted dpi for rendering.
~QgsRenderContext() override
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
void setIsGuiPreview(bool preview)
Sets GUI preview mode.
void setLabelSink(QgsLabelSink *sink)
Assigns the label sink which will take over responsibility for handling labels.
Qgis::TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
QgsRectangle mapExtent() const
Returns the original extent of the map being rendered.
void setSymbologyReferenceScale(double scale)
Sets the symbology reference scale.
double dpiTarget() const
Returns the targeted DPI for rendering.
QSet< const QgsSymbolLayer * > disabledSymbolLayers() const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setMaskIdProvider(QgsMaskIdProvider *provider)
Attaches a mask id provider to the context.
const QPainter * painter() const
Returns the const destination QPainter for the render operation.
QColor selectionColor() const
Returns the color to use when rendering selected features.
const QgsExpressionContext & expressionContext() const
Gets the expression context (const version).
void setExtent(const QgsRectangle &extent)
When rendering a map layer, calling this method sets the "clipping" extent for the layer (in the laye...
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr).
void setMapToPixel(const QgsMapToPixel &mtp)
Sets the context's map to pixel transform, which transforms between map coordinates and device coordi...
int currentMaskId() const
Returns the current mask id, which can be used with maskPainter()
void setCustomRenderingFlag(const QString &flag, const QVariant &value)
Sets a custom rendering flag.
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
bool isSymbolLayerEnabled(const QgsSymbolLayer *layer) const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setMaskPainter(QPainter *p, int id=0)
Sets a mask QPainter for the render operation.
const QgsDistanceArea & distanceArea() const
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
void setLabelingEngine(QgsLabelingEngine *engine)
Assigns the labeling engine.
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
void setRendererScale(double scale)
Sets the renderer map scale.
void setRendererUsage(Qgis::RendererUsage usage)
Sets the renderer usage.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
const QgsVectorSimplifyMethod & vectorSimplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
const QgsMaskIdProvider * maskIdProvider() const
Returns the mask id provider attached to the context.
QImage::Format imageFormat() const
Returns the QImage format which should be used for QImages created during rendering.
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
void setSelectionColor(const QColor &color)
Sets the color to use when rendering selected features.
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
An interface for classes which provider custom handlers for features rendered as part of a map render...
Scoped object for saving and restoring a QPainter object's state.
QgsScopedQPainterState(QPainter *painter)
Constructor for QgsScopedQPainterState.
~QgsScopedQPainterState()
Restores the painter back to its original state.
Scoped object for temporary replacement of a QgsRenderContext destination painter.
QgsScopedRenderContextPainterSwap(QgsRenderContext &context, QPainter *temporaryPainter)
Constructor for QgsScopedRenderContextPainterSwap.
~QgsScopedRenderContextPainterSwap()
Returns the destination painter for the context back to the original QPainter object.
void reset()
Resets the destination painter for the context back to the original QPainter object.
Scoped object for temporary override of the symbologyReferenceScale property of a QgsRenderContext.
QgsScopedRenderContextReferenceScaleOverride(QgsScopedRenderContextReferenceScaleOverride &&o) noexcept
Move constructor.
~QgsScopedRenderContextReferenceScaleOverride()
Returns the render context back to the original reference scale.
QgsScopedRenderContextReferenceScaleOverride(QgsRenderContext &context, double scale)
Constructor for QgsScopedRenderContextReferenceScaleOverride.
Scoped object for temporary scaling of a QgsRenderContext for millimeter based rendering.
~QgsScopedRenderContextScaleToMm()
Returns the destination painter back to pixel based units.
QgsScopedRenderContextScaleToMm(QgsRenderContext &context)
Constructor for QgsScopedRenderContextScaleToMm.
Scoped object for temporary scaling of a QgsRenderContext for pixel based rendering.
QgsScopedRenderContextScaleToPixels(QgsRenderContext &context)
Constructor for QgsScopedRenderContextScaleToPixels.
~QgsScopedRenderContextScaleToPixels()
Returns the destination painter back to millimeter based units.
Base class for objects with an associated (optional) temporal range.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
This class contains information how to simplify geometries fetched from a vector layer.
#define SIP_SKIP
Definition: qgis_sip.h:126