QGIS API Documentation 3.41.0-Master (d5b93354e9c)
Loading...
Searching...
No Matches
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 "qgsexpressionutils.h"
18#include "qgsgeometry.h"
19#include "qgsmarkersymbol.h"
20#include "qgslinesymbol.h"
21#include "qgsfillsymbol.h"
22#include "qgspolygon.h"
23#include "qgslegendpatchshape.h"
24#include "qgsstyle.h"
25#include "qgsunittypes.h"
26
28
30
32{
33 QString expression = properties.value( QStringLiteral( "geometryModifier" ) ).toString();
34 if ( expression.isEmpty() )
35 {
36 expression = QStringLiteral( "@geometry" );
37 }
39
40 if ( properties.value( QStringLiteral( "SymbolType" ) ) == QLatin1String( "Marker" ) )
41 {
43 }
44 else if ( properties.value( QStringLiteral( "SymbolType" ) ) == QLatin1String( "Line" ) )
45 {
47 }
48 else
49 {
51 }
52 symbolLayer->setUnits( QgsUnitTypes::decodeRenderUnit( properties.value( QStringLiteral( "units" ), QStringLiteral( "mapunits" ) ).toString() ) );
53
55
56 return symbolLayer;
57}
58
59QgsGeometryGeneratorSymbolLayer::QgsGeometryGeneratorSymbolLayer( const QString &expression )
60 : QgsSymbolLayer( Qgis::SymbolType::Hybrid )
61 , mExpression( new QgsExpression( expression ) )
62 , mSymbolType( Qgis::SymbolType::Marker )
63{
64
65}
66
68{
69 return QStringLiteral( "GeometryGenerator" );
70}
71
73{
75 {
76 if ( !mFillSymbol )
77 mFillSymbol.reset( QgsFillSymbol::createSimple( QVariantMap() ) );
78 mSymbol = mFillSymbol.get();
79 }
81 {
82 if ( !mLineSymbol )
83 mLineSymbol.reset( QgsLineSymbol::createSimple( QVariantMap() ) );
84 mSymbol = mLineSymbol.get();
85 }
87 {
88 if ( !mMarkerSymbol )
89 mMarkerSymbol.reset( QgsMarkerSymbol::createSimple( QVariantMap() ) );
90 mSymbol = mMarkerSymbol.get();
91 }
92 else
93 Q_ASSERT( false );
94
95 mSymbolType = symbolType;
96}
97
99{
100 mExpression->prepare( &context.renderContext().expressionContext() );
101
103
104 subSymbol()->startRender( context.renderContext(), context.fields() );
105}
106
108{
109 if ( mSymbol )
110 mSymbol->stopRender( context.renderContext() );
111}
112
114{
116 return;
117
118 mRenderingFeature = true;
119 mHasRenderedFeature = false;
120}
121
123{
124 mRenderingFeature = false;
125}
126
128{
129 if ( mFillSymbol )
130 return mFillSymbol->usesMapUnits();
131 else if ( mLineSymbol )
132 return mLineSymbol->usesMapUnits();
133 else if ( mMarkerSymbol )
134 return mMarkerSymbol->usesMapUnits();
135 return false;
136}
137
139{
140 if ( mFillSymbol )
141 return mFillSymbol->color();
142 else if ( mLineSymbol )
143 return mLineSymbol->color();
144 else if ( mMarkerSymbol )
145 return mMarkerSymbol->color();
146 return QColor();
147}
148
150{
151 if ( mFillSymbol )
152 return mFillSymbol->outputUnit();
153 else if ( mLineSymbol )
154 return mLineSymbol->outputUnit();
155 else if ( mMarkerSymbol )
156 return mMarkerSymbol->outputUnit();
158}
159
161{
162 if ( mFillSymbol )
163 mFillSymbol->setOutputUnit( unit );
164 else if ( mLineSymbol )
165 mLineSymbol->setOutputUnit( unit );
166 else if ( mMarkerSymbol )
167 mMarkerSymbol->setOutputUnit( unit );
168}
169
171{
172 if ( mFillSymbol )
173 return mFillSymbol->mapUnitScale();
174 else if ( mLineSymbol )
175 return mLineSymbol->mapUnitScale();
176 else if ( mMarkerSymbol )
177 return mMarkerSymbol->mapUnitScale();
178 return QgsMapUnitScale();
179}
180
182{
184
185 if ( mFillSymbol )
186 clone->mFillSymbol.reset( mFillSymbol->clone() );
187 if ( mLineSymbol )
188 clone->mLineSymbol.reset( mLineSymbol->clone() );
189 if ( mMarkerSymbol )
190 clone->mMarkerSymbol.reset( mMarkerSymbol->clone() );
191
192 clone->setSymbolType( mSymbolType );
193 clone->setUnits( mUnits );
194
197
198 return clone;
199}
200
202{
203 QVariantMap props;
204 props.insert( QStringLiteral( "geometryModifier" ), mExpression->expression() );
205 switch ( mSymbolType )
206 {
208 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Marker" ) );
209 break;
211 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Line" ) );
212 break;
213 default:
214 props.insert( QStringLiteral( "SymbolType" ), QStringLiteral( "Fill" ) );
215 break;
216 }
217 props.insert( QStringLiteral( "units" ), QgsUnitTypes::encodeUnit( mUnits ) );
218
219 return props;
220}
221
223{
224 if ( mSymbol )
225 {
226 // evaluate expression
227 QgsGeometry patchShapeGeometry;
228
229 if ( context.patchShape() && !context.patchShape()->isNull() )
230 {
231 patchShapeGeometry = context.patchShape()->scaledGeometry( size );
232 }
233 if ( patchShapeGeometry.isEmpty() )
234 {
235 Qgis::SymbolType originalSymbolType = Qgis::SymbolType::Hybrid;
236 switch ( context.originalGeometryType() )
237 {
239 originalSymbolType = Qgis::SymbolType::Marker;
240 break;
242 originalSymbolType = Qgis::SymbolType::Line;
243 break;
245 originalSymbolType = Qgis::SymbolType::Fill;
246 break;
249 originalSymbolType = mSymbol->type();
250 break;
251 }
252 patchShapeGeometry = QgsStyle::defaultStyle()->defaultPatch( originalSymbolType, size ).scaledGeometry( size );
253 }
254
255 // evaluate geometry expression
256 QgsFeature feature;
257 if ( context.feature() )
258 feature = *context.feature();
259 else
260 feature.setGeometry( patchShapeGeometry );
261 const QgsGeometry iconGeometry = evaluateGeometryInPainterUnits( patchShapeGeometry, feature, context.renderContext(), context.renderContext().expressionContext() );
262
263 QgsLegendPatchShape evaluatedPatchShape( mSymbol->type(), coerceToExpectedType( iconGeometry ) );
264 // we don't want to rescale the patch shape to fit the legend symbol size -- we've already considered that here,
265 // and we don't want to undo the effects of a geometry generator which modifies the symbol bounds
266 evaluatedPatchShape.setScaleToOutputSize( false );
267 mSymbol->drawPreviewIcon( context.renderContext().painter(), size, &context.renderContext(), false, &context.renderContext().expressionContext(), &evaluatedPatchShape );
268 }
269}
270
272{
273 mExpression.reset( new QgsExpression( exp ) );
274}
275
277{
278 return mExpression->expression();
279}
280
282{
283 switch ( symbol->type() )
284 {
286 mMarkerSymbol.reset( static_cast<QgsMarkerSymbol *>( symbol ) );
287 break;
288
290 mLineSymbol.reset( static_cast<QgsLineSymbol *>( symbol ) );
291 break;
292
294 mFillSymbol.reset( static_cast<QgsFillSymbol *>( symbol ) );
295 break;
296
297 default:
298 break;
299 }
300
301 setSymbolType( symbol->type() );
302
303 return true;
304}
305
307{
308 return QgsSymbolLayer::usedAttributes( context )
309 + mSymbol->usedAttributes( context )
310 + mExpression->referencedColumns();
311}
312
314{
315 // we treat geometry generator layers like they have data defined properties,
316 // since the WHOLE layer is based on expressions and requires the full expression
317 // context
318 return true;
319}
320
322{
323 Q_UNUSED( symbol )
324 return true;
325}
326
327QgsGeometry QgsGeometryGeneratorSymbolLayer::evaluateGeometryInPainterUnits( const QgsGeometry &input, const QgsFeature &, const QgsRenderContext &renderContext, QgsExpressionContext &expressionContext ) const
328{
329 QgsGeometry drawGeometry( input );
330 // step 1 - scale the draw geometry from PAINTER units to target units (e.g. millimeters)
331 const double scale = 1 / renderContext.convertToPainterUnits( 1, mUnits );
332 const QTransform painterToTargetUnits = QTransform::fromScale( scale, scale );
333 drawGeometry.transform( painterToTargetUnits );
334
335 // step 2 - set the feature to use the new scaled geometry, and inject it into the expression context
337 QgsExpressionContextScopePopper popper( expressionContext, generatorScope );
338 generatorScope->setGeometry( drawGeometry );
339
340 // step 3 - evaluate the new generated geometry.
341 QVariant value = mExpression->evaluate( &expressionContext );
342 QgsGeometry geom = QgsExpressionUtils::getGeometry( value, mExpression.get() );
343
344 // step 4 - transform geometry back from target units to painter units
345 geom.transform( painterToTargetUnits.inverted( ) );
346
347 return geom;
348}
349
350QgsGeometry QgsGeometryGeneratorSymbolLayer::coerceToExpectedType( const QgsGeometry &geometry ) const
351{
352 switch ( mSymbolType )
353 {
355 if ( geometry.type() != Qgis::GeometryType::Point )
356 {
357 QVector< QgsGeometry > geoms = geometry.coerceToType( Qgis::WkbType::MultiPoint );
358 if ( !geoms.empty() )
359 return geoms.at( 0 );
360 }
361 break;
363 if ( geometry.type() != Qgis::GeometryType::Line )
364 {
365 QVector< QgsGeometry > geoms = geometry.coerceToType( Qgis::WkbType::MultiLineString );
366 if ( !geoms.empty() )
367 return geoms.at( 0 );
368 }
369 break;
371 if ( geometry.type() != Qgis::GeometryType::Polygon )
372 {
373 QVector< QgsGeometry > geoms = geometry.coerceToType( Qgis::WkbType::MultiPolygon );
374 if ( !geoms.empty() )
375 return geoms.at( 0 );
376 }
377 break;
379 break;
380 }
381 return geometry;
382}
383
384void QgsGeometryGeneratorSymbolLayer::render( QgsSymbolRenderContext &context, Qgis::GeometryType geometryType, const QPolygonF *points, const QVector<QPolygonF> *rings )
385{
386 if ( mRenderingFeature && mHasRenderedFeature )
387 return;
388
389 QgsExpressionContext &expressionContext = context.renderContext().expressionContext();
390 QgsFeature f = expressionContext.feature();
391
392 if ( ( !context.feature() || context.renderContext().flags() & Qgis::RenderContextFlag::RenderingSubSymbol ) && points )
393 {
394 // 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!
395 // in this case we need to build up a feature which represents the points being rendered.
396 // note that we also do this same logic when we are rendering a subsymbol. In that case the $geometry part of the
397 // expression should refer to the shape of the subsymbol being rendered, NOT the feature's original geometry
398 QgsGeometry drawGeometry;
399
400 // step 1 - convert points and rings to geometry
401 switch ( geometryType )
402 {
404 {
405 Q_ASSERT( points->size() == 1 );
406 drawGeometry = QgsGeometry::fromPointXY( points->at( 0 ) );
407 break;
408 }
410 {
411 Q_ASSERT( !rings );
412 std::unique_ptr < QgsLineString > ring( QgsLineString::fromQPolygonF( *points ) );
413 drawGeometry = QgsGeometry( std::move( ring ) );
414 break;
415 }
417 {
418 std::unique_ptr < QgsLineString > exterior( QgsLineString::fromQPolygonF( *points ) );
419 std::unique_ptr< QgsPolygon > polygon = std::make_unique< QgsPolygon >();
420 polygon->setExteriorRing( exterior.release() );
421 if ( rings )
422 {
423 for ( const QPolygonF &ring : *rings )
424 {
425 std::unique_ptr< QgsLineString > fromRing = QgsLineString::fromQPolygonF( ring );
426 polygon->addInteriorRing( fromRing.release() );
427 }
428 }
429 drawGeometry = QgsGeometry( std::move( polygon ) );
430 break;
431 }
432
435 return; // unreachable
436 }
437
438 // step 2 - evaluate the result
439 QgsGeometry result = evaluateGeometryInPainterUnits( drawGeometry, f, context.renderContext(), expressionContext );
440
441 // We transform back to map units here (from painter units)
442 // as we'll ultimately be calling renderFeature, which excepts the feature has a geometry in map units.
443 // Here we also scale the transform by the target unit to painter units factor to reverse that conversion
444 QTransform mapToPixel = context.renderContext().mapToPixel().transform();
445 result.transform( mapToPixel.inverted() );
446 // also need to apply the coordinate transform from the render context
447 try
448 {
450 }
451 catch ( QgsCsException & )
452 {
453 QgsDebugError( QStringLiteral( "Could no transform generated geometry to layer CRS" ) );
454 }
455
456 f.setGeometry( coerceToExpectedType( result ) );
457 }
458 else if ( context.feature() )
459 {
460 switch ( mUnits )
461 {
463 case Qgis::RenderUnit::Unknown: // unsupported, not exposed as an option
464 case Qgis::RenderUnit::MetersInMapUnits: // unsupported, not exposed as an option
465 case Qgis::RenderUnit::Percentage: // unsupported, not exposed as an option
466 {
467 QVariant value = mExpression->evaluate( &expressionContext );
468 f.setGeometry( coerceToExpectedType( QgsExpressionUtils::getGeometry( value, mExpression.get() ) ) );
469 break;
470 }
471
476 {
477 // convert feature geometry to painter units
478 QgsGeometry transformed = f.geometry();
479 transformed.transform( context.renderContext().coordinateTransform() );
480 const QTransform mapToPixel = context.renderContext().mapToPixel().transform();
481 transformed.transform( mapToPixel );
482
483 QgsGeometry result = evaluateGeometryInPainterUnits( transformed, f, context.renderContext(), expressionContext );
484
485 // We transform back to map units here (from painter units)
486 // as we'll ultimately be calling renderFeature, which excepts the feature has a geometry in map units.
487 // Here we also scale the transform by the target unit to painter units factor to reverse that conversion
488 result.transform( mapToPixel.inverted() );
489 // also need to apply the coordinate transform from the render context
490 try
491 {
493 }
494 catch ( QgsCsException & )
495 {
496 QgsDebugError( QStringLiteral( "Could no transform generated geometry to layer CRS" ) );
497 }
498 f.setGeometry( coerceToExpectedType( result ) );
499 break;
500 }
501 }
502 }
503
504 QgsExpressionContextScope *subSymbolExpressionContextScope = mSymbol->symbolRenderContext()->expressionContextScope();
505 // override the $geometry value for all subsymbols -- this should be the generated geometry
506 subSymbolExpressionContextScope->setGeometry( f.geometry() );
507
508 const bool prevIsSubsymbol = context.renderContext().flags() & Qgis::RenderContextFlag::RenderingSubSymbol;
510
511 const bool useSelectedColor = shouldRenderUsingSelectionColor( context );
512 mSymbol->renderFeature( f, context.renderContext(), -1, useSelectedColor );
513
515
516 if ( mRenderingFeature )
517 mHasRenderedFeature = true;
518}
519
521{
522 mSymbol->setColor( color );
523}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ IsSymbolLayerSubSymbol
Symbol is being rendered as a sub-symbol of a QgsSymbolLayer.
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:337
@ Polygon
Polygons.
@ Unknown
Unknown types.
@ Null
No geometry.
RenderUnit
Rendering size units.
Definition qgis.h:4892
@ Percentage
Percentage of another measurement (e.g., canvas size, feature size)
@ Millimeters
Millimeters.
@ Points
Points (e.g., for font sizes)
@ Unknown
Mixed or unknown units.
@ MapUnits
Map units.
@ MetersInMapUnits
Meters value as Map units.
@ 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:574
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
@ Hybrid
Hybrid symbol.
@ MultiPoint
MultiPoint.
@ MultiPolygon
MultiPolygon.
@ MultiLineString
MultiLineString.
@ Reverse
Reverse/inverse transform (from destination to source)
Custom exception class for Coordinate Reference System related exceptions.
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:58
QgsGeometry geometry
Definition qgsfeature.h:69
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
static QgsFillSymbol * createSimple(const QVariantMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
A symbol layer subclass which alters rendered feature shapes through the use of QGIS expressions.
bool usesMapUnits() const override
Returns true if the symbol layer has any components which use map unit based sizes.
QgsMapUnitScale mapUnitScale() const override
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 setUnits(Qgis::RenderUnit units)
Sets the units for the geometry expression.
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.
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.
static QgsSymbolLayer * create(const QVariantMap &properties)
Creates the symbol layer.
void setOutputUnit(Qgis::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 render(QgsSymbolRenderContext &context, Qgis::GeometryType geometryType=Qgis::GeometryType::Unknown, const QPolygonF *points=nullptr, const QVector< QPolygonF > *rings=nullptr)
Will render this symbol layer using the context.
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.
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
A geometry is the spatial representation of a feature.
QVector< QgsGeometry > coerceToType(Qgis::WkbType 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)
Transforms this geometry as described by the coordinate transform ct.
static QgsGeometry fromPointXY(const QgsPointXY &point)
Creates a new geometry from a QgsPointXY object.
Qgis::GeometryType type
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 std::unique_ptr< QgsLineString > fromQPolygonF(const QPolygonF &polygon)
Returns a new linestring from a QPolygonF polygon input.
A line symbol type, for rendering LineString and MultiLineString geometries.
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.
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.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
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.
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:146
bool shouldRenderUsingSelectionColor(const QgsSymbolRenderContext &context) const
Returns true if the symbol layer should be rendered using the selection color from the render context...
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.
Qgis::GeometryType originalGeometryType() const
Returns the geometry type for the original feature geometry being rendered.
QgsFields fields() const
Fields of the layer.
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:231
QgsSymbolRenderContext * symbolRenderContext()
Returns the symbol render context.
void setRenderHints(Qgis::SymbolRenderHints hints)
Sets rendering hint flags for the symbol.
Definition qgssymbol.h:645
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)
Render a feature.
void stopRender(QgsRenderContext &context)
Ends the rendering process.
void setColor(const QColor &color) const
Sets the color for the symbol.
QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns a list of attributes required to render this feature.
void drawPreviewIcon(QPainter *painter, QSize size, QgsRenderContext *customContext=nullptr, bool selected=false, const QgsExpressionContext *expressionContext=nullptr, const QgsLegendPatchShape *patchShape=nullptr, const QgsScreenProperties &screen=QgsScreenProperties())
Draws an icon of the symbol that occupies an area given by size using the specified painter.
Qgis::SymbolType type() const
Returns the symbol's type.
Definition qgssymbol.h:293
void startRender(QgsRenderContext &context, const QgsFields &fields=QgsFields())
Begins the rendering process for the symbol.
static Q_INVOKABLE Qgis::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
static Q_INVOKABLE QString encodeUnit(Qgis::DistanceUnit unit)
Encodes a distance unit to a string.
#define QgsDebugError(str)
Definition qgslogger.h:38