QGIS API Documentation  3.10.0-A Coruña (6c816b4204)
qgsrendercontext.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsrendercontext.cpp
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 
19 #include "qgsrendercontext.h"
20 
21 #include "qgsmapsettings.h"
22 #include "qgsexpression.h"
23 #include "qgsvectorlayer.h"
25 #include "qgslogger.h"
26 #include "qgspoint.h"
27 
28 #define POINTS_TO_MM 2.83464567
29 #define INCH_TO_MM 25.4
30 
32  : mFlags( DrawEditingInfo | UseAdvancedEffects | DrawSelection | UseRenderingOptimization )
33 {
35  // For RenderMetersInMapUnits support, when rendering in Degrees, the Ellipsoid must be set
36  // - for Previews/Icons the default Extent can be used
37  mDistanceArea.setEllipsoid( mDistanceArea.sourceCrs().ellipsoidAcronym() );
38 }
39 
41  : mFlags( rh.mFlags )
42  , mPainter( rh.mPainter )
43  , mCoordTransform( rh.mCoordTransform )
44  , mDistanceArea( rh.mDistanceArea )
45  , mExtent( rh.mExtent )
46  , mOriginalMapExtent( rh.mOriginalMapExtent )
47  , mMapToPixel( rh.mMapToPixel )
48  , mRenderingStopped( rh.mRenderingStopped )
49  , mScaleFactor( rh.mScaleFactor )
50  , mRendererScale( rh.mRendererScale )
51  , mLabelingEngine( rh.mLabelingEngine )
52  , mSelectionColor( rh.mSelectionColor )
53  , mVectorSimplifyMethod( rh.mVectorSimplifyMethod )
54  , mExpressionContext( rh.mExpressionContext )
55  , mGeometry( rh.mGeometry )
56  , mFeatureFilterProvider( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr )
57  , mSegmentationTolerance( rh.mSegmentationTolerance )
58  , mSegmentationToleranceType( rh.mSegmentationToleranceType )
59  , mTransformContext( rh.mTransformContext )
60  , mPathResolver( rh.mPathResolver )
61  , mTextRenderFormat( rh.mTextRenderFormat )
62  , mRenderedFeatureHandlers( rh.mRenderedFeatureHandlers )
63  , mHasRenderedFeatureHandlers( rh.mHasRenderedFeatureHandlers )
64 #ifdef QGISDEBUG
65  , mHasTransformContext( rh.mHasTransformContext )
66 #endif
67 {
68 }
69 
71 {
72  mFlags = rh.mFlags;
73  mPainter = rh.mPainter;
74  mCoordTransform = rh.mCoordTransform;
75  mExtent = rh.mExtent;
76  mOriginalMapExtent = rh.mOriginalMapExtent;
77  mMapToPixel = rh.mMapToPixel;
78  mRenderingStopped = rh.mRenderingStopped;
79  mScaleFactor = rh.mScaleFactor;
80  mRendererScale = rh.mRendererScale;
81  mLabelingEngine = rh.mLabelingEngine;
82  mSelectionColor = rh.mSelectionColor;
83  mVectorSimplifyMethod = rh.mVectorSimplifyMethod;
84  mExpressionContext = rh.mExpressionContext;
85  mGeometry = rh.mGeometry;
86  mFeatureFilterProvider.reset( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr );
87  mSegmentationTolerance = rh.mSegmentationTolerance;
88  mSegmentationToleranceType = rh.mSegmentationToleranceType;
89  mDistanceArea = rh.mDistanceArea;
90  mTransformContext = rh.mTransformContext;
91  mPathResolver = rh.mPathResolver;
92  mTextRenderFormat = rh.mTextRenderFormat;
93  mRenderedFeatureHandlers = rh.mRenderedFeatureHandlers;
94  mHasRenderedFeatureHandlers = rh.mHasRenderedFeatureHandlers;
95 #ifdef QGISDEBUG
96  mHasTransformContext = rh.mHasTransformContext;
97 #endif
98 
99  return *this;
100 }
101 
103 {
104  QgsRenderContext context;
105  context.setPainter( painter );
106  if ( painter && painter->device() )
107  {
108  context.setScaleFactor( painter->device()->logicalDpiX() / 25.4 );
109  }
110  else
111  {
112  context.setScaleFactor( 3.465 ); //assume 88 dpi as standard value
113  }
114  if ( painter && painter->renderHints() & QPainter::Antialiasing )
115  {
116  context.setFlag( QgsRenderContext::Antialiasing, true );
117  }
118  return context;
119 }
120 
122 {
123 #ifdef QGISDEBUG
124  if ( !mHasTransformContext )
125  QgsDebugMsgLevel( QStringLiteral( "No QgsCoordinateTransformContext context set for transform" ), 4 );
126 #endif
127  return mTransformContext;
128 }
129 
131 {
132  mTransformContext = context;
133 #ifdef QGISDEBUG
134  mHasTransformContext = true;
135 #endif
136 }
137 
138 void QgsRenderContext::setFlags( QgsRenderContext::Flags flags )
139 {
140  mFlags = flags;
141 }
142 
144 {
145  if ( on )
146  mFlags |= flag;
147  else
148  mFlags &= ~flag;
149 }
150 
151 QgsRenderContext::Flags QgsRenderContext::flags() const
152 {
153  return mFlags;
154 }
155 
157 {
158  return mFlags.testFlag( flag );
159 }
160 
162 {
163  QgsRenderContext ctx;
164  QgsRectangle extent = mapSettings.visibleExtent();
165  extent.grow( mapSettings.extentBuffer() );
166  ctx.setMapToPixel( mapSettings.mapToPixel() );
167  ctx.setExtent( extent );
168  ctx.setMapExtent( mapSettings.visibleExtent() );
174  ctx.setSelectionColor( mapSettings.selectionColor() );
182  ctx.setScaleFactor( mapSettings.outputDpi() / 25.4 ); // = pixels per mm
183  ctx.setRendererScale( mapSettings.scale() );
184  ctx.setExpressionContext( mapSettings.expressionContext() );
185  ctx.setSegmentationTolerance( mapSettings.segmentationTolerance() );
187  ctx.mDistanceArea.setSourceCrs( mapSettings.destinationCrs(), mapSettings.transformContext() );
188  ctx.mDistanceArea.setEllipsoid( mapSettings.ellipsoid() );
189  ctx.setTransformContext( mapSettings.transformContext() );
190  ctx.setPathResolver( mapSettings.pathResolver() );
191  ctx.setTextRenderFormat( mapSettings.textRenderFormat() );
192  ctx.setVectorSimplifyMethod( mapSettings.simplifyMethod() );
193  ctx.mRenderedFeatureHandlers = mapSettings.renderedFeatureHandlers();
194  ctx.mHasRenderedFeatureHandlers = !mapSettings.renderedFeatureHandlers().isEmpty();
195  //this flag is only for stopping during the current rendering progress,
196  //so must be false at every new render operation
197  ctx.setRenderingStopped( false );
198 
199  return ctx;
200 }
201 
203 {
204  return mFlags.testFlag( ForceVectorOutput );
205 }
206 
208 {
209  return mFlags.testFlag( UseAdvancedEffects );
210 }
211 
213 {
214  setFlag( UseAdvancedEffects, enabled );
215 }
216 
218 {
219  return mFlags.testFlag( DrawEditingInfo );
220 }
221 
223 {
224  return mFlags.testFlag( DrawSelection );
225 }
226 
228 {
229  mCoordTransform = t;
230 }
231 
233 {
234  setFlag( DrawEditingInfo, b );
235 }
236 
238 {
239  setFlag( ForceVectorOutput, force );
240 }
241 
243 {
244  setFlag( DrawSelection, showSelection );
245 }
246 
248 {
249  return mFlags.testFlag( UseRenderingOptimization );
250 }
251 
253 {
254  setFlag( UseRenderingOptimization, enabled );
255 }
256 
258 {
259  if ( ffp )
260  {
261  mFeatureFilterProvider.reset( ffp->clone() );
262  }
263  else
264  {
265  mFeatureFilterProvider.reset( nullptr );
266  }
267 }
268 
270 {
271  return mFeatureFilterProvider.get();
272 }
273 
275 {
276  double conversionFactor = 1.0;
277  switch ( unit )
278  {
280  conversionFactor = mScaleFactor;
281  break;
282 
284  conversionFactor = mScaleFactor / POINTS_TO_MM;
285  break;
286 
288  conversionFactor = mScaleFactor * INCH_TO_MM;
289  break;
290 
292  {
293  size = convertMetersToMapUnits( size );
295  // Fall through to RenderMapUnits with size in meters converted to size in MapUnits
297  }
299  {
300  double mup = scale.computeMapUnitsPerPixel( *this );
301  if ( mup > 0 )
302  {
303  conversionFactor = 1.0 / mup;
304  }
305  else
306  {
307  conversionFactor = 1.0;
308  }
309  break;
310  }
312  conversionFactor = 1.0;
313  break;
314 
317  //no sensible value
318  conversionFactor = 1.0;
319  break;
320  }
321 
322  double convertedSize = size * conversionFactor;
323 
324  if ( unit == QgsUnitTypes::RenderMapUnits )
325  {
326  //check max/min size
327  if ( scale.minSizeMMEnabled )
328  convertedSize = std::max( convertedSize, scale.minSizeMM * mScaleFactor );
329  if ( scale.maxSizeMMEnabled )
330  convertedSize = std::min( convertedSize, scale.maxSizeMM * mScaleFactor );
331  }
332 
333  return convertedSize;
334 }
335 
336 double QgsRenderContext::convertToMapUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale ) const
337 {
338  double mup = mMapToPixel.mapUnitsPerPixel();
339 
340  switch ( unit )
341  {
343  {
344  size = convertMetersToMapUnits( size );
345  // Fall through to RenderMapUnits with values of meters converted to MapUnits
347  }
349  {
350  // check scale
351  double minSizeMU = std::numeric_limits<double>::lowest();
352  if ( scale.minSizeMMEnabled )
353  {
354  minSizeMU = scale.minSizeMM * mScaleFactor * mup;
355  }
356  if ( !qgsDoubleNear( scale.minScale, 0.0 ) )
357  {
358  minSizeMU = std::max( minSizeMU, size * ( mRendererScale / scale.minScale ) );
359  }
360  size = std::max( size, minSizeMU );
361 
362  double maxSizeMU = std::numeric_limits<double>::max();
363  if ( scale.maxSizeMMEnabled )
364  {
365  maxSizeMU = scale.maxSizeMM * mScaleFactor * mup;
366  }
367  if ( !qgsDoubleNear( scale.maxScale, 0.0 ) )
368  {
369  maxSizeMU = std::min( maxSizeMU, size * ( mRendererScale / scale.maxScale ) );
370  }
371  size = std::min( size, maxSizeMU );
372 
373  return size;
374  }
376  {
377  return size * mScaleFactor * mup;
378  }
380  {
381  return size * mScaleFactor * mup / POINTS_TO_MM;
382  }
384  {
385  return size * mScaleFactor * mup * INCH_TO_MM;
386  }
388  {
389  return size * mup;
390  }
391 
394  //no sensible value
395  return 0.0;
396  }
397  return 0.0;
398 }
399 
400 double QgsRenderContext::convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const
401 {
402  double mup = mMapToPixel.mapUnitsPerPixel();
403 
404  switch ( outputUnit )
405  {
407  {
408  return sizeInMapUnits / convertMetersToMapUnits( 1.0 );
409  }
411  {
412  return sizeInMapUnits;
413  }
415  {
416  return sizeInMapUnits / ( mScaleFactor * mup );
417  }
419  {
420  return sizeInMapUnits / ( mScaleFactor * mup / POINTS_TO_MM );
421  }
423  {
424  return sizeInMapUnits / ( mScaleFactor * mup * INCH_TO_MM );
425  }
427  {
428  return sizeInMapUnits / mup;
429  }
430 
433  //no sensible value
434  return 0.0;
435  }
436  return 0.0;
437 }
438 
439 double QgsRenderContext::convertMetersToMapUnits( double meters ) const
440 {
441  switch ( mDistanceArea.sourceCrs().mapUnits() )
442  {
444  return meters;
446  {
447  QgsPointXY pointCenter = mExtent.center();
448  // The Extent is in the sourceCrs(), when different from destinationCrs()
449  // - the point must be transformed, since DistanceArea uses the destinationCrs()
450  // Note: the default QgsCoordinateTransform() : authid() will return an empty String
451  if ( !mCoordTransform.isShortCircuited() )
452  {
453  pointCenter = mCoordTransform.transform( pointCenter );
454  }
455  return mDistanceArea.measureLineProjected( pointCenter, meters );
456  }
465  return ( meters * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::DistanceMeters, mDistanceArea.sourceCrs().mapUnits() ) );
466  }
467  return meters;
468 }
469 
470 QList<QgsRenderedFeatureHandlerInterface *> QgsRenderContext::renderedFeatureHandlers() const
471 {
472  return mRenderedFeatureHandlers;
473 }
474 
475 
void setForceVectorOutput(bool force)
Sets whether rendering operations should use vector operations instead of any faster raster shortcuts...
Meters value as Map units.
Definition: qgsunittypes.h:154
double convertToMapUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to map units.
Enable layer opacity and blending effects.
void setRenderingStopped(bool stopped)
Sets whether the rendering operation has been stopped and any ongoing rendering should be canceled im...
A rectangle specified with double values.
Definition: qgsrectangle.h:41
double minSizeMM
The minimum size in millimeters, or 0.0 if unset.
Enable vector simplification and other rendering optimizations.
virtual QgsFeatureFilterProvider * clone() const =0
Create a clone of the feature filter provider.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
const QgsExpressionContext & expressionContext() const
Gets the expression context.
QgsCoordinateTransformContext transformContext() const
Returns the context&#39;s coordinate transform context, which stores various information regarding which ...
void setFlags(QgsRenderContext::Flags flags)
Set combination of flags that will be used for rendering.
Use antialiasing while drawing.
double convertFromMapUnits(double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit) const
Converts a size from map units to the specified units.
void setCoordinateTransform(const QgsCoordinateTransform &t)
Sets the current coordinate transform for the context.
QgsPointXY transform(const QgsPointXY &point, TransformDirection direction=ForwardTransform) const SIP_THROW(QgsCsException)
Transform the point from the source CRS to the destination CRS.
A class to represent a 2D point.
Definition: qgspointxy.h:43
QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const
Returns the list of rendered feature handlers to use while rendering map layers.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:280
void setSimplifyHints(SimplifyHints simplifyHints)
Sets the simplification hints of the vector layer managed.
void setRendererScale(double scale)
Sets the renderer map scale.
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the context&#39;s coordinate transform context, which stores various information regarding which dat...
double computeMapUnitsPerPixel(const QgsRenderContext &c) const
Computes a map units per pixel scaling factor, respecting the minimum and maximum scales set for the ...
void setVectorSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification setting to use when rendering vector layers.
Mixed or unknown units.
Definition: qgsunittypes.h:153
Flags flags() const
Returns combination of flags used for rendering.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
Percentage of another measurement (e.g., canvas size, feature size)
Definition: qgsunittypes.h:150
Enable layer opacity and blending effects.
void setTextRenderFormat(TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
Whether vector selections should be shown in the rendered map.
void setExtent(const QgsRectangle &extent)
When rendering a map layer, calling this method sets the "clipping" extent for the layer (in the laye...
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes takes output image size into accou...
double maxScale
The maximum scale, or 0.0 if unset.
const QgsFeatureFilterProvider * featureFilterProvider() const
Gets the filter feature provider used for additional filtering of rendered features.
void setMapExtent(const QgsRectangle &extent)
Sets the original extent of the map being rendered.
bool minSizeMMEnabled
Whether the minimum size in mm should be respected.
QgsCoordinateReferenceSystem destinationCrs() const
returns CRS of destination coordinate reference system
Vector graphics should not be cached and drawn as raster images.
The QgsMapSettings class contains configuration for rendering of the map.
double convertMetersToMapUnits(double meters) const
Convert meter distances to active MapUnit values for QgsUnitTypes::RenderMetersInMapUnits.
void setSelectionColor(const QColor &color)
Sets the color to use when rendering selected features.
No simplification can be applied.
QString ellipsoidAcronym() const
Returns the ellipsoid acronym for the ellipsoid used by the CRS.
void setUseAdvancedEffects(bool enabled)
Used to enable or disable advanced effects such as blend modes.
const QgsVectorSimplifyMethod & simplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
#define FALLTHROUGH
Definition: qgis.h:681
QgsRenderContext & operator=(const QgsRenderContext &rh)
#define INCH_TO_MM
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
void grow(double delta)
Grows the rectangle in place by the specified amount.
Definition: qgsrectangle.h:275
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent...
Whether vector selections should be shown in the rendered map.
double scale() const
Returns the calculated map scale.
void setDrawEditingInformation(bool b)
Sets whether edit markers should be drawn during the render operation.
Enable anti-aliasing for map rendering.
static QgsRenderContext fromQPainter(QPainter *painter)
Creates a default render context given a pixel based QPainter destination.
QList< QgsRenderedFeatureHandlerInterface *> renderedFeatureHandlers() const
Returns the list of rendered feature handlers to use while rendering the map settings.
bool drawEditingInformation() const
Returns true if edit markers should be drawn during the render operation.
double extentBuffer() const
Returns the buffer in map units to use around the visible extent for rendering symbols whose correspo...
Draw bounds of symbols (for debugging/testing)
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:74
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
Abstract interface for use by classes that filter the features of a layer.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
Contains information about the context in which a coordinate transform is executed.
double mapUnitsPerPixel() const
Returns current map units per pixel.
const QgsMapToPixel & mapToPixel() const
Draw bounds of symbols (for debugging/testing)
Vector graphics should not be cached and drawn as raster images.
Enable drawing of vertex markers for layers in editing mode.
Render and load remote sources in the same thread to ensure rendering remote sources (svg and images)...
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
bool forceVectorOutput() const
Returns true if rendering operations should use vector operations instead of any faster raster shortc...
QgsCoordinateReferenceSystem sourceCrs() const
Returns the source spatial reference system.
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
bool useRenderingOptimization() const
Returns true if the rendering optimization (geometry simplification) can be executed.
Draw map such that there are no problems between adjacent tiles.
Unknown distance unit.
Definition: qgsunittypes.h:77
Render is a &#39;canvas preview&#39; render, and shortcuts should be taken to ensure fast rendering...
double outputDpi() const
Returns DPI used for conversion between real world units (e.g.
Render is a &#39;canvas preview&#39; render, and shortcuts should be taken to ensure fast rendering...
Contains information about the context of a rendering operation.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to painter units (pixels).
#define POINTS_TO_MM
QString ellipsoid() const
Returns ellipsoid&#39;s acronym.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
QPainter * painter()
Returns the destination QPainter for the render operation.
double maxSizeMM
The maximum size in millimeters, or 0.0 if unset.
Points (e.g., for font sizes)
Definition: qgsunittypes.h:151
void setShowSelection(bool showSelection)
Sets whether vector selections should be shown in the rendered map.
Struct for storing maximum and minimum scales for measurements in map units.
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
double measureLineProjected(const QgsPointXY &p1, double distance=1, double azimuth=M_PI_2, QgsPointXY *projectedPoint=nullptr) const
Calculates the distance from one point with distance in meters and azimuth (direction) When the sourc...
bool useAdvancedEffects() const
Returns true if advanced effects such as blend modes such be used.
void setMapToPixel(const QgsMapToPixel &mtp)
Sets the context&#39;s map to pixel transform, which transforms between map coordinates and device coordi...
Class for doing transforms between two map coordinate systems.
void setUseRenderingOptimization(bool enabled)
bool showSelection() const
Returns true if vector selections should be shown in the rendered map.
void setFlag(Flag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
void setFeatureFilterProvider(const QgsFeatureFilterProvider *ffp)
Set a filter feature provider used for additional filtering of rendered features. ...
Enable vector simplification and other rendering optimizations.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
bool testFlag(Flag flag) const
Check whether a particular flag is enabled.
QgsRenderContext::TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
QColor selectionColor() const
Gets color that is used for drawing of selected vector features.
QgsPointXY center() const
Returns the center point of the rectangle.
Definition: qgsrectangle.h:230
Render and load remote sources in the same thread to ensure rendering remote sources (svg and images)...
bool testFlag(Flag flag) const
Check whether a particular flag is enabled.
Terrestrial miles.
Definition: qgsunittypes.h:73
Draw map such that there are no problems between adjacent tiles.
Flag
Enumeration of flags that affect rendering operations.
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
Enable drawing of vertex markers for layers in editing mode.
double minScale
The minimum scale, or 0.0 if unset.
bool maxSizeMMEnabled
Whether the maximum size in mm should be respected.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:145
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.