QGIS API Documentation 3.29.0-Master (ade4f0cf0f)
qgsgeometrygeneratorsymbollayer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsgeometrygeneratorsymbollayer.cpp
3 ---------------------
4 begin : November 2015
5 copyright : (C) 2015 by Matthias Kuhn
6 email : matthias at opengis dot ch
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17#include "qgsgeometry.h"
18#include "qgsmarkersymbol.h"
19#include "qgslinesymbol.h"
20#include "qgsfillsymbol.h"
21#include "qgspolygon.h"
22#include "qgslegendpatchshape.h"
23#include "qgsstyle.h"
24
26
28
30{
31 QString expression = properties.value( QStringLiteral( "geometryModifier" ) ).toString();
32 if ( expression.isEmpty() )
33 {
34 expression = QStringLiteral( "$geometry" );
35 }
37
38 if ( properties.value( QStringLiteral( "SymbolType" ) ) == QLatin1String( "Marker" ) )
39 {
41 }
42 else if ( properties.value( QStringLiteral( "SymbolType" ) ) == QLatin1String( "Line" ) )
43 {
45 }
46 else
47 {
49 }
50 symbolLayer->setUnits( QgsUnitTypes::decodeRenderUnit( properties.value( QStringLiteral( "units" ), QStringLiteral( "mapunits" ) ).toString() ) );
51
53
54 return symbolLayer;
55}
56
57QgsGeometryGeneratorSymbolLayer::QgsGeometryGeneratorSymbolLayer( const QString &expression )
58 : QgsSymbolLayer( Qgis::SymbolType::Hybrid )
59 , mExpression( new QgsExpression( expression ) )
60 , mSymbolType( Qgis::SymbolType::Marker )
61{
62
63}
64
66{
67 return QStringLiteral( "GeometryGenerator" );
68}
69
71{
73 {
74 if ( !mFillSymbol )
75 mFillSymbol.reset( QgsFillSymbol::createSimple( QVariantMap() ) );
76 mSymbol = mFillSymbol.get();
77 }
79 {
80 if ( !mLineSymbol )
81 mLineSymbol.reset( QgsLineSymbol::createSimple( QVariantMap() ) );
82 mSymbol = mLineSymbol.get();
83 }
85 {
86 if ( !mMarkerSymbol )
87 mMarkerSymbol.reset( QgsMarkerSymbol::createSimple( QVariantMap() ) );
88 mSymbol = mMarkerSymbol.get();
89 }
90 else
91 Q_ASSERT( false );
92
93 mSymbolType = symbolType;
94}
95
97{
98 mExpression->prepare( &context.renderContext().expressionContext() );
99
100 subSymbol()->startRender( context.renderContext() );
101}
102
104{
105 if ( mSymbol )
106 mSymbol->stopRender( context.renderContext() );
107}
108
110{
112 return;
113
114 mRenderingFeature = true;
115 mHasRenderedFeature = false;
116}
117
119{
120 mRenderingFeature = false;
121}
122
124{
125 if ( mFillSymbol )
126 return mFillSymbol->usesMapUnits();
127 else if ( mLineSymbol )
128 return mLineSymbol->usesMapUnits();
129 else if ( mMarkerSymbol )
130 return mMarkerSymbol->usesMapUnits();
131 return false;
132}
133
135{
136 if ( mFillSymbol )
137 return mFillSymbol->color();
138 else if ( mLineSymbol )
139 return mLineSymbol->color();
140 else if ( mMarkerSymbol )
141 return mMarkerSymbol->color();
142 return QColor();
143}
144
146{
147 if ( mFillSymbol )
148 return mFillSymbol->outputUnit();
149 else if ( mLineSymbol )
150 return mLineSymbol->outputUnit();
151 else if ( mMarkerSymbol )
152 return mMarkerSymbol->outputUnit();
154}
155
157{
158 if ( mFillSymbol )
159 mFillSymbol->setOutputUnit( unit );
160 else if ( mLineSymbol )
161 mLineSymbol->setOutputUnit( unit );
162 else if ( mMarkerSymbol )
163 mMarkerSymbol->setOutputUnit( unit );
164}
165
167{
168 if ( mFillSymbol )
169 return mFillSymbol->mapUnitScale();
170 else if ( mLineSymbol )
171 return mLineSymbol->mapUnitScale();
172 else if ( mMarkerSymbol )
173 return mMarkerSymbol->mapUnitScale();
174 return QgsMapUnitScale();
175}
176
178{
180
181 if ( mFillSymbol )
182 clone->mFillSymbol.reset( mFillSymbol->clone() );
183 if ( mLineSymbol )
184 clone->mLineSymbol.reset( mLineSymbol->clone() );
185 if ( mMarkerSymbol )
186 clone->mMarkerSymbol.reset( mMarkerSymbol->clone() );
187
188 clone->setSymbolType( mSymbolType );
189 clone->setUnits( mUnits );
190
193
194 return clone;
195}
196
198{
199 QVariantMap props;
200 props.insert( QStringLiteral( "geometryModifier" ), mExpression->expression() );
201 switch ( mSymbolType )
202 {
204 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Marker" ) );
205 break;
207 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Line" ) );
208 break;
209 default:
210 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Fill" ) );
211 break;
212 }
213 props.insert( QStringLiteral( "units" ), QgsUnitTypes::encodeUnit( mUnits ) );
214
215 return props;
216}
217
219{
220 if ( mSymbol )
221 {
222 // evaluate expression
223 QgsGeometry patchShapeGeometry;
224
225 if ( context.patchShape() && !context.patchShape()->isNull() )
226 {
227 patchShapeGeometry = context.patchShape()->scaledGeometry( size );
228 }
229 if ( patchShapeGeometry.isEmpty() )
230 {
231 Qgis::SymbolType originalSymbolType = Qgis::SymbolType::Hybrid;
232 switch ( context.originalGeometryType() )
233 {
235 originalSymbolType = Qgis::SymbolType::Marker;
236 break;
238 originalSymbolType = Qgis::SymbolType::Line;
239 break;
241 originalSymbolType = Qgis::SymbolType::Fill;
242 break;
245 originalSymbolType = mSymbol->type();
246 break;
247 }
248 patchShapeGeometry = QgsStyle::defaultStyle()->defaultPatch( originalSymbolType, size ).scaledGeometry( size );
249 }
250
251 // evaluate geometry expression
252 QgsFeature feature;
253 if ( context.feature() )
254 feature = *context.feature();
255 else
256 feature.setGeometry( patchShapeGeometry );
257 const QgsGeometry iconGeometry = evaluateGeometryInPainterUnits( patchShapeGeometry, feature, context.renderContext(), context.renderContext().expressionContext() );
258
259 QgsLegendPatchShape evaluatedPatchShape( mSymbol->type(), coerceToExpectedType( iconGeometry ) );
260 // we don't want to rescale the patch shape to fit the legend symbol size -- we've already considered that here,
261 // and we don't want to undo the effects of a geometry generator which modifies the symbol bounds
262 evaluatedPatchShape.setScaleToOutputSize( false );
263 mSymbol->drawPreviewIcon( context.renderContext().painter(), size, &context.renderContext(), false, &context.renderContext().expressionContext(), &evaluatedPatchShape );
264 }
265}
266
268{
269 mExpression.reset( new QgsExpression( exp ) );
270}
271
273{
274 return mExpression->expression();
275}
276
278{
279 switch ( symbol->type() )
280 {
282 mMarkerSymbol.reset( static_cast<QgsMarkerSymbol *>( symbol ) );
283 break;
284
286 mLineSymbol.reset( static_cast<QgsLineSymbol *>( symbol ) );
287 break;
288
290 mFillSymbol.reset( static_cast<QgsFillSymbol *>( symbol ) );
291 break;
292
293 default:
294 break;
295 }
296
297 setSymbolType( symbol->type() );
298
299 return true;
300}
301
303{
304 return QgsSymbolLayer::usedAttributes( context )
305 + mSymbol->usedAttributes( context )
306 + mExpression->referencedColumns();
307}
308
310{
311 // we treat geometry generator layers like they have data defined properties,
312 // since the WHOLE layer is based on expressions and requires the full expression
313 // context
314 return true;
315}
316
318{
319 Q_UNUSED( symbol )
320 return true;
321}
322
323QgsGeometry QgsGeometryGeneratorSymbolLayer::evaluateGeometryInPainterUnits( const QgsGeometry &input, const QgsFeature &, const QgsRenderContext &renderContext, QgsExpressionContext &expressionContext ) const
324{
325 QgsGeometry drawGeometry( input );
326 // step 1 - scale the draw geometry from PAINTER units to target units (e.g. millimeters)
327 const double scale = 1 / renderContext.convertToPainterUnits( 1, mUnits );
328 const QTransform painterToTargetUnits = QTransform::fromScale( scale, scale );
329 drawGeometry.transform( painterToTargetUnits );
330
331 // step 2 - set the feature to use the new scaled geometry, and inject it into the expression context
333 QgsExpressionContextScopePopper popper( expressionContext, generatorScope );
334 generatorScope->setGeometry( drawGeometry );
335
336 // step 3 - evaluate the new generated geometry.
337 QgsGeometry geom = mExpression->evaluate( &expressionContext ).value<QgsGeometry>();
338
339 // step 4 - transform geometry back from target units to painter units
340 geom.transform( painterToTargetUnits.inverted( ) );
341
342 return geom;
343}
344
345QgsGeometry QgsGeometryGeneratorSymbolLayer::coerceToExpectedType( const QgsGeometry &geometry ) const
346{
347 switch ( mSymbolType )
348 {
350 if ( geometry.type() != QgsWkbTypes::PointGeometry )
351 {
352 QVector< QgsGeometry > geoms = geometry.coerceToType( QgsWkbTypes::MultiPoint );
353 if ( !geoms.empty() )
354 return geoms.at( 0 );
355 }
356 break;
358 if ( geometry.type() != QgsWkbTypes::LineGeometry )
359 {
360 QVector< QgsGeometry > geoms = geometry.coerceToType( QgsWkbTypes::MultiLineString );
361 if ( !geoms.empty() )
362 return geoms.at( 0 );
363 }
364 break;
366 if ( geometry.type() != QgsWkbTypes::PolygonGeometry )
367 {
368 QVector< QgsGeometry > geoms = geometry.coerceToType( QgsWkbTypes::MultiPolygon );
369 if ( !geoms.empty() )
370 return geoms.at( 0 );
371 }
372 break;
374 break;
375 }
376 return geometry;
377}
378
379void QgsGeometryGeneratorSymbolLayer::render( QgsSymbolRenderContext &context, QgsWkbTypes::GeometryType geometryType, const QPolygonF *points, const QVector<QPolygonF> *rings )
380{
381 if ( mRenderingFeature && mHasRenderedFeature )
382 return;
383
384 QgsExpressionContext &expressionContext = context.renderContext().expressionContext();
385 QgsFeature f = expressionContext.feature();
386
387 if ( ( !context.feature() || context.renderContext().flags() & Qgis::RenderContextFlag::RenderingSubSymbol ) && points )
388 {
389 // oh dear, we don't have a feature to work from... but that's ok, we are probably being rendered as a plain old symbol!
390 // in this case we need to build up a feature which represents the points being rendered.
391 // note that we also do this same logic when we are rendering a subsymbol. In that case the $geometry part of the
392 // expression should refer to the shape of the subsymbol being rendered, NOT the feature's original geometry
393 QgsGeometry drawGeometry;
394
395 // step 1 - convert points and rings to geometry
396 switch ( geometryType )
397 {
399 {
400 Q_ASSERT( points->size() == 1 );
401 drawGeometry = QgsGeometry::fromPointXY( points->at( 0 ) );
402 break;
403 }
405 {
406 Q_ASSERT( !rings );
407 std::unique_ptr < QgsLineString > ring( QgsLineString::fromQPolygonF( *points ) );
408 drawGeometry = QgsGeometry( std::move( ring ) );
409 break;
410 }
412 {
413 std::unique_ptr < QgsLineString > exterior( QgsLineString::fromQPolygonF( *points ) );
414 std::unique_ptr< QgsPolygon > polygon = std::make_unique< QgsPolygon >();
415 polygon->setExteriorRing( exterior.release() );
416 if ( rings )
417 {
418 for ( const QPolygonF &ring : *rings )
419 {
420 polygon->addInteriorRing( QgsLineString::fromQPolygonF( ring ) );
421 }
422 }
423 drawGeometry = QgsGeometry( std::move( polygon ) );
424 break;
425 }
426
429 return; // unreachable
430 }
431
432 // step 2 - evaluate the result
433 QgsGeometry result = evaluateGeometryInPainterUnits( drawGeometry, f, context.renderContext(), expressionContext );
434
435 // We transform back to map units here (from painter units)
436 // as we'll ultimately be calling renderFeature, which excepts the feature has a geometry in map units.
437 // Here we also scale the transform by the target unit to painter units factor to reverse that conversion
438 QTransform mapToPixel = context.renderContext().mapToPixel().transform();
439 result.transform( mapToPixel.inverted() );
440 // also need to apply the coordinate transform from the render context
441 try
442 {
443 result.transform( context.renderContext().coordinateTransform(), Qgis::TransformDirection::Reverse );
444 }
445 catch ( QgsCsException & )
446 {
447 QgsDebugMsg( QStringLiteral( "Could no transform generated geometry to layer CRS" ) );
448 }
449
450 f.setGeometry( coerceToExpectedType( result ) );
451 }
452 else if ( context.feature() )
453 {
454 switch ( mUnits )
455 {
457 case QgsUnitTypes::RenderUnknownUnit: // unsupported, not exposed as an option
458 case QgsUnitTypes::RenderMetersInMapUnits: // unsupported, not exposed as an option
459 case QgsUnitTypes::RenderPercentage: // unsupported, not exposed as an option
460 {
461 QgsGeometry geom = mExpression->evaluate( &expressionContext ).value<QgsGeometry>();
462 f.setGeometry( coerceToExpectedType( geom ) );
463 break;
464 }
465
470 {
471 // convert feature geometry to painter units
472 QgsGeometry transformed = f.geometry();
473 transformed.transform( context.renderContext().coordinateTransform() );
474 const QTransform mapToPixel = context.renderContext().mapToPixel().transform();
475 transformed.transform( mapToPixel );
476
477 QgsGeometry result = evaluateGeometryInPainterUnits( transformed, f, context.renderContext(), expressionContext );
478
479 // We transform back to map units here (from painter units)
480 // as we'll ultimately be calling renderFeature, which excepts the feature has a geometry in map units.
481 // Here we also scale the transform by the target unit to painter units factor to reverse that conversion
482 result.transform( mapToPixel.inverted() );
483 // also need to apply the coordinate transform from the render context
484 try
485 {
486 result.transform( context.renderContext().coordinateTransform(), Qgis::TransformDirection::Reverse );
487 }
488 catch ( QgsCsException & )
489 {
490 QgsDebugMsg( QStringLiteral( "Could no transform generated geometry to layer CRS" ) );
491 }
492 f.setGeometry( coerceToExpectedType( result ) );
493 break;
494 }
495 }
496 }
497
498 QgsExpressionContextScope *subSymbolExpressionContextScope = mSymbol->symbolRenderContext()->expressionContextScope();
499 // override the $geometry value for all subsymbols -- this should be the generated geometry
500 subSymbolExpressionContextScope->setGeometry( f.geometry() );
501
502 const bool prevIsSubsymbol = context.renderContext().flags() & Qgis::RenderContextFlag::RenderingSubSymbol;
504
505 mSymbol->renderFeature( f, context.renderContext(), -1, context.selected() );
506
508
509 if ( mRenderingFeature )
510 mHasRenderedFeature = true;
511}
512
514{
515 mSymbol->setColor( color );
516}
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:72
@ RenderingSubSymbol
Set whenever a sub-symbol of a parent symbol is currently being rendered. Can be used during symbol a...
SymbolType
Symbol types.
Definition: qgis.h:206
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
@ Hybrid
Hybrid symbol.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
RAII class to pop scope from an expression context on destruction.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setGeometry(const QgsGeometry &geometry)
Convenience function for setting a geometry for the scope.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QgsFeature feature() const
Convenience function for retrieving the feature for the context, if set.
Class for parsing and evaluation of expressions (formerly called "search strings").
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
QgsGeometry geometry
Definition: qgsfeature.h:67
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:170
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
static QgsFillSymbol * createSimple(const QVariantMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
bool usesMapUnits() const override
Returns true if the symbol layer has any components which use map unit based sizes.
QgsMapUnitScale mapUnitScale() const override
void render(QgsSymbolRenderContext &context, QgsWkbTypes::GeometryType geometryType=QgsWkbTypes::GeometryType::UnknownGeometry, const QPolygonF *points=nullptr, const QVector< QPolygonF > *rings=nullptr)
Will render this symbol layer using the context.
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QString geometryExpression() const
Gets the expression to generate this geometry.
bool hasDataDefinedProperties() const override
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
void setGeometryExpression(const QString &exp)
Set the expression to generate this geometry.
void setSymbolType(Qgis::SymbolType symbolType)
Set the type of symbol which should be created.
QString layerType() const override
Returns a string that represents this layer type.
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
bool isCompatibleWithSymbol(QgsSymbol *symbol) const override
Will always return true.
Qgis::SymbolType symbolType() const
Access the symbol type.
QVariantMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
void startRender(QgsSymbolRenderContext &context) override
Called before a set of rendering operations commences on the supplied render context.
QgsSymbol * subSymbol() override
Returns the symbol's sub symbol, if present.
void setUnits(QgsUnitTypes::RenderUnit units)
Sets the units for the geometry expression.
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
void setColor(const QColor &color) override
Sets the "representative" color for the symbol layer.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
static QgsSymbolLayer * create(const QVariantMap &properties)
Creates the symbol layer.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context) override
Called after the layer has been rendered for a particular feature.
QgsSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void stopRender(QgsSymbolRenderContext &context) override
Called after a set of rendering operations has finished on the supplied render context.
QColor color() const override
Returns the "representative" color of the symbol layer.
void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context) override
Called before the layer will be rendered for a particular feature.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
QVector< QgsGeometry > coerceToType(QgsWkbTypes::Type type, double defaultZ=0, double defaultM=0) const
Attempts to coerce this geometry into the specified destination type.
Qgis::GeometryOperationResult transform(const QgsCoordinateTransform &ct, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool transformZ=false) SIP_THROW(QgsCsException)
Transforms this geometry as described by the coordinate transform ct.
static QgsGeometry fromPointXY(const QgsPointXY &point) SIP_HOLDGIL
Creates a new geometry from a QgsPointXY object.
QgsWkbTypes::GeometryType type
Definition: qgsgeometry.h:167
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
Represents a patch shape for use in map legends.
QgsGeometry scaledGeometry(QSizeF size) const
Returns the patch shape's geometry, scaled to the given size.
bool isNull() const
Returns true if the patch shape is a null QgsLegendPatchShape, which indicates that the default legen...
void setScaleToOutputSize(bool scale)
Sets whether the patch shape should by resized to the desired target size when rendering.
static QgsLineString * fromQPolygonF(const QPolygonF &polygon)
Returns a new linestring from a QPolygonF polygon input.
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30
static QgsLineSymbol * createSimple(const QVariantMap &properties)
Create a line symbol with one symbol layer: SimpleLine with specified properties.
QgsPointXY transform(const QgsPointXY &p) const
Transforms a point p from map (world) coordinates to device coordinates.
Definition: qgsmaptopixel.h:90
Struct for storing maximum and minimum scales for measurements in map units.
A marker symbol type, for rendering Point and MultiPoint geometries.
static QgsMarkerSymbol * createSimple(const QVariantMap &properties)
Create a marker symbol with one symbol layer: SimpleMarker with specified properties.
Contains information about the context of a rendering operation.
QPainter * painter()
Returns the destination QPainter for the render operation.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QgsExpressionContext & expressionContext()
Gets the expression context.
void setFlag(Qgis::RenderContextFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
QgsLegendPatchShape defaultPatch(Qgis::SymbolType type, QSizeF size) const
Returns the default legend patch shape for the given symbol type.
Definition: qgsstyle.cpp:1157
static QgsStyle * defaultStyle()
Returns default application-wide style.
Definition: qgsstyle.cpp:145
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
void copyDataDefinedProperties(QgsSymbolLayer *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
void restoreOldDataDefinedProperties(const QVariantMap &stringMap)
Restores older data defined properties from string map.
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
const QgsFeature * feature() const
Returns the current feature being rendered.
bool selected() const
Returns true if symbols should be rendered using the selected symbol coloring and style.
QgsWkbTypes::GeometryType originalGeometryType() const
Returns the geometry type for the original feature geometry being rendered.
QgsExpressionContextScope * expressionContextScope()
This scope is always available when a symbol of this type is being rendered.
const QgsLegendPatchShape * patchShape() const
Returns the symbol patch shape, to use if rendering symbol preview icons.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:93
QgsSymbolRenderContext * symbolRenderContext()
Returns the symbol render context.
Definition: qgssymbol.cpp:1824
void stopRender(QgsRenderContext &context)
Ends the rendering process.
Definition: qgssymbol.cpp:873
void drawPreviewIcon(QPainter *painter, QSize size, QgsRenderContext *customContext=nullptr, bool selected=false, const QgsExpressionContext *expressionContext=nullptr, const QgsLegendPatchShape *patchShape=nullptr)
Draws an icon of the symbol that occupies an area given by size using the specified painter.
Definition: qgssymbol.cpp:923
void setColor(const QColor &color) const
Sets the color for the symbol.
Definition: qgssymbol.cpp:898
QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns a list of attributes required to render this feature.
Definition: qgssymbol.cpp:1182
void renderFeature(const QgsFeature &feature, QgsRenderContext &context, int layer=-1, bool selected=false, bool drawVertexMarker=false, Qgis::VertexMarkerType currentVertexMarkerType=Qgis::VertexMarkerType::SemiTransparentCircle, double currentVertexMarkerSize=0.0) SIP_THROW(QgsCsException)
Render a feature.
Definition: qgssymbol.cpp:1283
Qgis::SymbolType type() const
Returns the symbol's type.
Definition: qgssymbol.h:152
void startRender(QgsRenderContext &context, const QgsFields &fields=QgsFields())
Begins the rendering process for the symbol.
Definition: qgssymbol.cpp:825
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
static Q_INVOKABLE QgsUnitTypes::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
@ RenderUnknownUnit
Mixed or unknown units.
Definition: qgsunittypes.h:175
@ RenderMetersInMapUnits
Meters value as Map units.
Definition: qgsunittypes.h:176
@ RenderPercentage
Percentage of another measurement (e.g., canvas size, feature size)
Definition: qgsunittypes.h:172
@ RenderPoints
Points (e.g., for font sizes)
Definition: qgsunittypes.h:173
@ RenderPixels
Pixels.
Definition: qgsunittypes.h:171
@ RenderInches
Inches.
Definition: qgsunittypes.h:174
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
@ RenderMapUnits
Map units.
Definition: qgsunittypes.h:170
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:141
#define QgsDebugMsg(str)
Definition: qgslogger.h:38