QGIS API Documentation 3.29.0-Master (ade4f0cf0f)
qgsrenderer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsrenderer.cpp
3 ---------------------
4 begin : November 2009
5 copyright : (C) 2009 by Martin Dobias
6 email : wonder dot sk at gmail dot com
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
16#include "qgsrenderer.h"
17#include "qgssymbol.h"
18#include "qgssymbollayerutils.h"
20
21#include "qgssinglesymbolrenderer.h" // for default renderer
22
23#include "qgsrendererregistry.h"
24
25#include "qgsrendercontext.h"
26#include "qgsclipper.h"
27#include "qgsgeometry.h"
29#include "qgsfeature.h"
30#include "qgslogger.h"
31#include "qgsvectorlayer.h"
32#include "qgspainteffect.h"
33#include "qgseffectstack.h"
35#include "qgswkbptr.h"
36#include "qgspoint.h"
37#include "qgsproperty.h"
38#include "qgsapplication.h"
39#include "qgsmarkersymbol.h"
40#include "qgslinesymbol.h"
41
42#include <QDomElement>
43#include <QDomDocument>
44#include <QPolygonF>
45#include <QThread>
46
48{
49 return QgsSymbol::_getPoint( context, point );
50}
51
53{
54 if ( !destRenderer )
55 return;
56
57 if ( mPaintEffect )
58 destRenderer->setPaintEffect( mPaintEffect->clone() );
59
60 destRenderer->setForceRasterRender( mForceRaster );
62 destRenderer->mOrderBy = mOrderBy;
63 destRenderer->mOrderByEnabled = mOrderByEnabled;
64 destRenderer->mReferenceScale = mReferenceScale;
65}
66
68 : mType( type )
69{
71 mPaintEffect->setEnabled( false );
72}
73
75{
76 delete mPaintEffect;
77}
78
80{
81 return new QgsSingleSymbolRenderer( QgsSymbol::defaultSymbol( geomType ) );
82}
83
85{
86 return symbolForFeature( feature, context );
87}
88
89QSet< QString > QgsFeatureRenderer::legendKeysForFeature( const QgsFeature &feature, QgsRenderContext &context ) const
90{
91 Q_UNUSED( feature )
92 Q_UNUSED( context )
93 return QSet< QString >();
94}
95
97{
98#ifdef QGISDEBUG
99 if ( !mThread )
100 {
101 mThread = QThread::currentThread();
102 }
103 else
104 {
105 Q_ASSERT_X( mThread == QThread::currentThread(), "QgsFeatureRenderer::startRender", "startRender called in a different thread - use a cloned renderer instead" );
106 }
107#endif
108}
109
111{
112#ifdef QGISDEBUG
113 Q_ASSERT_X( mThread == QThread::currentThread(), "QgsFeatureRenderer::stopRender", "stopRender called in a different thread - use a cloned renderer instead" );
114#endif
115}
116
118{
119 return false;
120}
121
123{
124 return false;
125}
126
127bool QgsFeatureRenderer::renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer, bool selected, bool drawVertexMarker )
128{
129#ifdef QGISDEBUG
130 Q_ASSERT_X( mThread == QThread::currentThread(), "QgsFeatureRenderer::renderFeature", "renderFeature called in a different thread - use a cloned renderer instead" );
131#endif
132
133 QgsSymbol *symbol = symbolForFeature( feature, context );
134 if ( !symbol )
135 return false;
136
137 renderFeatureWithSymbol( feature, symbol, context, layer, selected, drawVertexMarker );
138 return true;
139}
140
141void QgsFeatureRenderer::renderFeatureWithSymbol( const QgsFeature &feature, QgsSymbol *symbol, QgsRenderContext &context, int layer, bool selected, bool drawVertexMarker )
142{
143 symbol->renderFeature( feature, context, layer, selected, drawVertexMarker, mCurrentVertexMarkerType, mCurrentVertexMarkerSize );
144}
145
147{
148 return QStringLiteral( "UNKNOWN RENDERER\n" );
149}
150
152{
153 Q_UNUSED( context )
154 return QgsSymbolList();
155}
156
158{
159 // <renderer-v2 type=""> ... </renderer-v2>
160
161 if ( element.isNull() )
162 return nullptr;
163
164 // load renderer
165 const QString rendererType = element.attribute( QStringLiteral( "type" ) );
166
168 if ( !m )
169 return nullptr;
170
171 QgsFeatureRenderer *r = m->createRenderer( element, context );
172 if ( r )
173 {
174 r->setUsingSymbolLevels( element.attribute( QStringLiteral( "symbollevels" ), QStringLiteral( "0" ) ).toInt() );
175 r->setForceRasterRender( element.attribute( QStringLiteral( "forceraster" ), QStringLiteral( "0" ) ).toInt() );
176 r->setReferenceScale( element.attribute( QStringLiteral( "referencescale" ), QStringLiteral( "-1" ) ).toDouble() );
177
178 //restore layer effect
179 const QDomElement effectElem = element.firstChildElement( QStringLiteral( "effect" ) );
180 if ( !effectElem.isNull() )
181 {
182 r->setPaintEffect( QgsApplication::paintEffectRegistry()->createEffect( effectElem ) );
183 }
184
185 // restore order by
186 const QDomElement orderByElem = element.firstChildElement( QStringLiteral( "orderby" ) );
187 r->mOrderBy.load( orderByElem );
188 r->setOrderByEnabled( element.attribute( QStringLiteral( "enableorderby" ), QStringLiteral( "0" ) ).toInt() );
189 }
190 return r;
191}
192
193QDomElement QgsFeatureRenderer::save( QDomDocument &doc, const QgsReadWriteContext &context )
194{
195 Q_UNUSED( context )
196 // create empty renderer element
197 QDomElement rendererElem = doc.createElement( RENDERER_TAG_NAME );
198
199 saveRendererData( doc, rendererElem, context );
200
201 return rendererElem;
202}
203
204void QgsFeatureRenderer::saveRendererData( QDomDocument &doc, QDomElement &rendererElem, const QgsReadWriteContext & )
205{
206 rendererElem.setAttribute( QStringLiteral( "forceraster" ), ( mForceRaster ? QStringLiteral( "1" ) : QStringLiteral( "0" ) ) );
207 rendererElem.setAttribute( QStringLiteral( "symbollevels" ), ( mUsingSymbolLevels ? QStringLiteral( "1" ) : QStringLiteral( "0" ) ) );
208 rendererElem.setAttribute( QStringLiteral( "referencescale" ), mReferenceScale );
209
211 mPaintEffect->saveProperties( doc, rendererElem );
212
213 if ( !mOrderBy.isEmpty() )
214 {
215 QDomElement orderBy = doc.createElement( QStringLiteral( "orderby" ) );
217 rendererElem.appendChild( orderBy );
218 }
219 rendererElem.setAttribute( QStringLiteral( "enableorderby" ), ( mOrderByEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) ) );
220}
221
222QgsFeatureRenderer *QgsFeatureRenderer::loadSld( const QDomNode &node, QgsWkbTypes::GeometryType geomType, QString &errorMessage )
223{
224 const QDomElement element = node.toElement();
225 if ( element.isNull() )
226 return nullptr;
227
228 // get the UserStyle element
229 const QDomElement userStyleElem = element.firstChildElement( QStringLiteral( "UserStyle" ) );
230 if ( userStyleElem.isNull() )
231 {
232 // UserStyle element not found, nothing will be rendered
233 errorMessage = QStringLiteral( "Info: UserStyle element not found." );
234 return nullptr;
235 }
236
237 // get the FeatureTypeStyle element
238 QDomElement featTypeStyleElem = userStyleElem.firstChildElement( QStringLiteral( "FeatureTypeStyle" ) );
239 if ( featTypeStyleElem.isNull() )
240 {
241 errorMessage = QStringLiteral( "Info: FeatureTypeStyle element not found." );
242 return nullptr;
243 }
244
245 // create empty FeatureTypeStyle element to merge Rule's from all FeatureTypeStyle's
246 QDomElement mergedFeatTypeStyle = featTypeStyleElem.cloneNode( false ).toElement();
247
248 // use the RuleRenderer when more rules are present or the rule
249 // has filters or min/max scale denominators set,
250 // otherwise use the SingleSymbol renderer
251 bool needRuleRenderer = false;
252 int ruleCount = 0;
253
254 while ( !featTypeStyleElem.isNull() )
255 {
256 QDomElement ruleElem = featTypeStyleElem.firstChildElement( QStringLiteral( "Rule" ) );
257 while ( !ruleElem.isNull() )
258 {
259 // test rule children element to check if we need to create RuleRenderer
260 // and if the rule has a symbolizer
261 bool hasRendererSymbolizer = false;
262 bool hasRuleRenderer = false;
263 QDomElement ruleChildElem = ruleElem.firstChildElement();
264 while ( !ruleChildElem.isNull() )
265 {
266 // rule has filter or min/max scale denominator, use the RuleRenderer
267 if ( ruleChildElem.localName() == QLatin1String( "Filter" ) ||
268 ruleChildElem.localName() == QLatin1String( "MinScaleDenominator" ) ||
269 ruleChildElem.localName() == QLatin1String( "MaxScaleDenominator" ) )
270 {
271 hasRuleRenderer = true;
272 }
273 // rule has a renderer symbolizer, not a text symbolizer
274 else if ( ruleChildElem.localName().endsWith( QLatin1String( "Symbolizer" ) ) &&
275 ruleChildElem.localName() != QLatin1String( "TextSymbolizer" ) )
276 {
277 QgsDebugMsgLevel( QStringLiteral( "Symbolizer element found and not a TextSymbolizer" ), 2 );
278 hasRendererSymbolizer = true;
279 }
280
281 ruleChildElem = ruleChildElem.nextSiblingElement();
282 }
283
284 if ( hasRendererSymbolizer )
285 {
286 ruleCount++;
287
288 // append a clone of all Rules to the merged FeatureTypeStyle element
289 mergedFeatTypeStyle.appendChild( ruleElem.cloneNode().toElement() );
290
291 if ( hasRuleRenderer )
292 {
293 QgsDebugMsgLevel( QStringLiteral( "Filter or Min/MaxScaleDenominator element found: need a RuleRenderer" ), 2 );
294 needRuleRenderer = true;
295 }
296 }
297
298 // more rules present, use the RuleRenderer
299 if ( ruleCount > 1 )
300 {
301 QgsDebugMsgLevel( QStringLiteral( "more Rule elements found: need a RuleRenderer" ), 2 );
302 needRuleRenderer = true;
303 }
304
305 ruleElem = ruleElem.nextSiblingElement( QStringLiteral( "Rule" ) );
306 }
307 featTypeStyleElem = featTypeStyleElem.nextSiblingElement( QStringLiteral( "FeatureTypeStyle" ) );
308 }
309
310 QString rendererType;
311 if ( needRuleRenderer )
312 {
313 rendererType = QStringLiteral( "RuleRenderer" );
314 }
315 else
316 {
317 rendererType = QStringLiteral( "singleSymbol" );
318 }
319 QgsDebugMsgLevel( QStringLiteral( "Instantiating a '%1' renderer..." ).arg( rendererType ), 2 );
320
321 // create the renderer and return it
323 if ( !m )
324 {
325 errorMessage = QStringLiteral( "Error: Unable to get metadata for '%1' renderer." ).arg( rendererType );
326 return nullptr;
327 }
328
329 QgsFeatureRenderer *r = m->createRendererFromSld( mergedFeatTypeStyle, geomType );
330 return r;
331}
332
333QDomElement QgsFeatureRenderer::writeSld( QDomDocument &doc, const QString &styleName, const QVariantMap &props ) const
334{
335 QDomElement userStyleElem = doc.createElement( QStringLiteral( "UserStyle" ) );
336
337 QDomElement nameElem = doc.createElement( QStringLiteral( "se:Name" ) );
338 nameElem.appendChild( doc.createTextNode( styleName ) );
339 userStyleElem.appendChild( nameElem );
340
341 QDomElement featureTypeStyleElem = doc.createElement( QStringLiteral( "se:FeatureTypeStyle" ) );
342 toSld( doc, featureTypeStyleElem, props );
343 userStyleElem.appendChild( featureTypeStyleElem );
344
345 return userStyleElem;
346}
347
349{
350 return false;
351}
352
354{
355 Q_UNUSED( key )
356 return false;
357}
358
359void QgsFeatureRenderer::checkLegendSymbolItem( const QString &key, bool state )
360{
361 Q_UNUSED( key )
362 Q_UNUSED( state )
363}
364
365void QgsFeatureRenderer::setLegendSymbolItem( const QString &key, QgsSymbol *symbol )
366{
367 Q_UNUSED( key )
368 delete symbol;
369}
370
371QString QgsFeatureRenderer::legendKeyToExpression( const QString &, QgsVectorLayer *, bool &ok ) const
372{
373 ok = false;
374 return QString();
375}
376
378{
379 return QgsLegendSymbolList();
380}
381
383{
386}
387
389{
390 return nullptr != symbolForFeature( feature, context );
391}
392
394{
396 QgsSymbolLayerUtils::drawVertexMarker( pt.x(), pt.y(), *context.painter(),
398 markerSize );
399}
400
402{
403 const auto constPts = pts;
404 for ( const QPointF pt : constPts )
405 renderVertexMarker( pt, context );
406}
407
408void QgsFeatureRenderer::renderVertexMarkerPolygon( QPolygonF &pts, QList<QPolygonF> *rings, QgsRenderContext &context )
409{
410 const auto constPts = pts;
411 for ( const QPointF pt : constPts )
412 renderVertexMarker( pt, context );
413
414 if ( rings )
415 {
416 const auto constRings = *rings;
417 for ( const QPolygonF &ring : constRings )
418 {
419 const auto constRing = ring;
420 for ( const QPointF pt : constRing )
421 renderVertexMarker( pt, context );
422 }
423 }
424}
425
427{
428 QgsSymbolList lst;
429 QgsSymbol *s = symbolForFeature( feature, context );
430 if ( s ) lst.append( s );
431 return lst;
432}
433
435{
436 Q_UNUSED( extent )
437 Q_UNUSED( context )
438}
439
441{
442 QgsSymbolList lst;
443 QgsSymbol *s = originalSymbolForFeature( feature, context );
444 if ( s ) lst.append( s );
445 return lst;
446}
447
449{
450 return mPaintEffect;
451}
452
454{
455 delete mPaintEffect;
456 mPaintEffect = effect;
457}
458
460{
461 return mOrderBy;
462}
463
465{
467}
468
470{
471 return mOrderByEnabled;
472}
473
475{
476 mOrderByEnabled = enabled;
477}
478
480{
481 delete subRenderer;
482}
483
485{
486 return nullptr;
487}
488
490{
491 return true;
492}
493
495{
496 if ( symbol->type() == Qgis:: SymbolType::Marker )
497 {
498 QgsMarkerSymbol *s = static_cast<QgsMarkerSymbol *>( symbol );
499 if ( Qgis::ScaleMethod::ScaleArea == method )
500 {
501 s->setDataDefinedSize( QgsProperty::fromExpression( "coalesce(sqrt(" + QString::number( s->size() ) + " * (" + field + ")),0)" ) );
502 }
503 else
504 {
505 s->setDataDefinedSize( QgsProperty::fromExpression( "coalesce(" + QString::number( s->size() ) + " * (" + field + "),0)" ) );
506 }
508 }
509 else if ( symbol->type() == Qgis::SymbolType::Line )
510 {
511 QgsLineSymbol *s = static_cast<QgsLineSymbol *>( symbol );
512 s->setDataDefinedWidth( QgsProperty::fromExpression( "coalesce(" + QString::number( s->width() ) + " * (" + field + "),0)" ) );
513 }
514}
515
517{
518 if ( symbol->type() == Qgis::SymbolType::Marker )
519 {
520 QgsMarkerSymbol *s = static_cast<QgsMarkerSymbol *>( symbol );
522 ? QString::number( s->angle() ) + " + "
523 : QString() ) + field );
524 s->setDataDefinedAngle( dd );
525 }
526}
527
529{
530 return mSymbol;
531}
532
534{
535 return mLayer;
536}
ScaleMethod
Scale methods.
Definition: qgis.h:220
@ ScaleDiameter
Calculate scale by the diameter.
@ ScaleArea
Calculate scale by the area.
VertexMarkerType
Editing vertex markers, used for showing vertices during a edit operation.
Definition: qgis.h:901
@ Marker
Marker symbol.
@ Line
Line symbol.
static QgsPaintEffectRegistry * paintEffectRegistry()
Returns the application's paint effect registry, used for managing paint effects.
static QgsRendererRegistry * rendererRegistry()
Returns the application's renderer registry, used for managing vector layer renderers.
void setOrderBy(const QgsFeatureRequest::OrderBy &orderBy)
Define the order in which features shall be processed by this renderer.
void renderVertexMarkerPolyline(QPolygonF &pts, QgsRenderContext &context)
render editing vertex marker for a polyline
static QPointF _getPoint(QgsRenderContext &context, const QgsPoint &point)
Creates a point in screen coordinates from a wkb string in map coordinates.
Definition: qgsrenderer.cpp:47
virtual QDomElement writeSld(QDomDocument &doc, const QString &styleName, const QVariantMap &props=QVariantMap()) const
create the SLD UserStyle element following the SLD v1.1 specs with the given name
virtual QgsLegendSymbolList legendSymbolItems() const
Returns a list of symbology items for the legend.
static QgsFeatureRenderer * defaultRenderer(QgsWkbTypes::GeometryType geomType)
Returns a new renderer - used by default in vector layers.
Definition: qgsrenderer.cpp:79
void setOrderByEnabled(bool enabled)
Sets whether custom ordering should be applied before features are processed by this renderer.
virtual bool legendSymbolItemsCheckable() const
items of symbology items in legend should be checkable
virtual void modifyRequestExtent(QgsRectangle &extent, QgsRenderContext &context)
Allows for a renderer to modify the extent of a feature request prior to rendering.
void renderFeatureWithSymbol(const QgsFeature &feature, QgsSymbol *symbol, QgsRenderContext &context, int layer, bool selected, bool drawVertexMarker) SIP_THROW(QgsCsException)
Render the feature with the symbol using context.
virtual bool legendSymbolItemChecked(const QString &key)
items of symbology items in legend is checked
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the renderer.
void setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the renderer.
virtual void setLegendSymbolItem(const QString &key, QgsSymbol *symbol)
Sets the symbol to be used for a legend symbol item.
virtual void setEmbeddedRenderer(QgsFeatureRenderer *subRenderer)
Sets an embedded renderer (subrenderer) for this feature renderer.
QgsFeatureRenderer(const QString &type)
Definition: qgsrenderer.cpp:67
virtual QgsSymbolList symbolsForFeature(const QgsFeature &feature, QgsRenderContext &context) const
Returns list of symbols used for rendering the feature.
void setForceRasterRender(bool forceRaster)
Sets whether the renderer should be rendered to a raster destination.
Definition: qgsrenderer.h:450
virtual QgsSymbolList symbols(QgsRenderContext &context) const
Returns list of symbols used by the renderer.
virtual void stopRender(QgsRenderContext &context)
Must be called when a render cycle has finished, to allow the renderer to clean up.
virtual void toSld(QDomDocument &doc, QDomElement &element, const QVariantMap &props=QVariantMap()) const
used from subclasses to create SLD Rule elements following SLD v1.1 specs
Definition: qgsrenderer.h:326
virtual QSet< QString > legendKeysForFeature(const QgsFeature &feature, QgsRenderContext &context) const
Returns legend keys matching a specified feature.
Definition: qgsrenderer.cpp:89
QgsPaintEffect * mPaintEffect
Definition: qgsrenderer.h:605
QString type() const
Definition: qgsrenderer.h:142
virtual bool usesEmbeddedSymbols() const
Returns true if the renderer uses embedded symbols for features.
void copyRendererData(QgsFeatureRenderer *destRenderer) const
Clones generic renderer data to another renderer.
Definition: qgsrenderer.cpp:52
virtual QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context)
Stores renderer properties to an XML element.
static QgsFeatureRenderer * loadSld(const QDomNode &node, QgsWkbTypes::GeometryType geomType, QString &errorMessage)
Create a new renderer according to the information contained in the UserStyle element of a SLD style ...
void setReferenceScale(double scale)
Sets the symbology reference scale.
Definition: qgsrenderer.h:482
virtual QString dump() const
Returns debug information about this renderer.
void setUsingSymbolLevels(bool usingSymbolLevels)
Definition: qgsrenderer.h:293
virtual ~QgsFeatureRenderer()
Definition: qgsrenderer.cpp:74
virtual QgsSymbol * symbolForFeature(const QgsFeature &feature, QgsRenderContext &context) const =0
To be overridden.
virtual void checkLegendSymbolItem(const QString &key, bool state=true)
item in symbology was checked
virtual QString legendKeyToExpression(const QString &key, QgsVectorLayer *layer, bool &ok) const
Attempts to convert the specified legend rule key to a QGIS expression matching the features displaye...
bool orderByEnabled() const
Returns whether custom ordering will be applied before features are processed by this renderer.
virtual bool filterNeedsGeometry() const
Returns true if this renderer requires the geometry to apply the filter.
static void convertSymbolRotation(QgsSymbol *symbol, const QString &field)
static QgsFeatureRenderer * load(QDomElement &symbologyElem, const QgsReadWriteContext &context)
create a renderer from XML element
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the renderer...
QgsFeatureRequest::OrderBy mOrderBy
Definition: qgsrenderer.h:623
virtual QgsSymbol * originalSymbolForFeature(const QgsFeature &feature, QgsRenderContext &context) const
Returns symbol for feature.
Definition: qgsrenderer.cpp:84
Qgis::VertexMarkerType mCurrentVertexMarkerType
The current type of editing marker.
Definition: qgsrenderer.h:600
virtual bool willRenderFeature(const QgsFeature &feature, QgsRenderContext &context) const
Returns whether the renderer will render a feature or not.
void saveRendererData(QDomDocument &doc, QDomElement &element, const QgsReadWriteContext &context)
Saves generic renderer data into the specified element.
void renderVertexMarker(QPointF pt, QgsRenderContext &context)
render editing vertex marker at specified point
void renderVertexMarkerPolygon(QPolygonF &pts, QList< QPolygonF > *rings, QgsRenderContext &context)
render editing vertex marker for a polygon
virtual const QgsFeatureRenderer * embeddedRenderer() const
Returns the current embedded renderer (subrenderer) for this feature renderer.
double mCurrentVertexMarkerSize
The current size of editing marker.
Definition: qgsrenderer.h:603
virtual void startRender(QgsRenderContext &context, const QgsFields &fields)
Must be called when a new render cycle is started.
Definition: qgsrenderer.cpp:96
virtual bool renderFeature(const QgsFeature &feature, QgsRenderContext &context, int layer=-1, bool selected=false, bool drawVertexMarker=false) SIP_THROW(QgsCsException)
Render a feature using this renderer in the given context.
static void convertSymbolSizeScale(QgsSymbol *symbol, Qgis::ScaleMethod method, const QString &field)
void setVertexMarkerAppearance(Qgis::VertexMarkerType type, double size)
Sets type and size of editing vertex markers for subsequent rendering.
QgsFeatureRequest::OrderBy orderBy() const
Gets the order in which features shall be processed by this renderer.
virtual QgsSymbolList originalSymbolsForFeature(const QgsFeature &feature, QgsRenderContext &context) const
Equivalent of originalSymbolsForFeature() call extended to support renderers that may use more symbol...
Represents a list of OrderByClauses, with the most important first and the least important last.
void CORE_EXPORT load(const QDomElement &elem)
Deserialize from XML.
void CORE_EXPORT save(QDomElement &elem) const
Serialize to XML.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
Container of fields for a vector layer.
Definition: qgsfields.h:45
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30
void setDataDefinedWidth(const QgsProperty &property) const
Set data defined width for whole symbol (including all symbol layers).
double width() const
Returns the estimated width for the whole symbol, which is the maximum width of all marker symbol lay...
A marker symbol type, for rendering Point and MultiPoint geometries.
void setScaleMethod(Qgis::ScaleMethod scaleMethod) const
Sets the method to use for scaling the marker's size.
double size() const
Returns the estimated size for the whole symbol, which is the maximum size of all marker symbol layer...
double angle() const
Returns the marker angle for the whole symbol.
void setDataDefinedSize(const QgsProperty &property) const
Set data defined size for whole symbol (including all symbol layers).
void setDataDefinedAngle(const QgsProperty &property)
Set data defined angle for whole symbol (including all symbol layers).
static QgsPaintEffect * defaultStack()
Returns a new effect stack consisting of a sensible selection of default effects.
static bool isDefaultStack(QgsPaintEffect *effect)
Tests whether a paint effect matches the default effects stack.
Base class for visual effects which can be applied to QPicture drawings.
void setEnabled(bool enabled)
Sets whether the effect is enabled.
virtual bool saveProperties(QDomDocument &doc, QDomElement &element) const
Saves the current state of the effect to a DOM element.
virtual QgsPaintEffect * clone() const =0
Duplicates an effect by creating a deep copy of the effect.
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:49
A store for object properties.
Definition: qgsproperty.h:230
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
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).
Stores metadata about one renderer class.
virtual QgsFeatureRenderer * createRenderer(QDomElement &elem, const QgsReadWriteContext &context)=0
Returns new instance of the renderer given the DOM element.
virtual QgsFeatureRenderer * createRendererFromSld(QDomElement &elem, QgsWkbTypes::GeometryType geomType)
QgsRendererAbstractMetadata * rendererMetadata(const QString &rendererName)
Returns the metadata for a specified renderer.
An interface for classes which can visit style entity (e.g.
static void drawVertexMarker(double x, double y, QPainter &p, Qgis::VertexMarkerType type, int markerSize)
Draws a vertex symbol at (painter) coordinates x, y.
int layer() const
The layer of this symbol level.
QgsSymbol * mSymbol
Definition: qgsrenderer.h:79
QgsSymbol * symbol() const
The symbol of this symbol level.
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:93
static QPointF _getPoint(QgsRenderContext &context, const QgsPoint &point)
Creates a point in screen coordinates from a QgsPoint in map coordinates.
Definition: qgssymbol.h:718
static QgsSymbol * defaultSymbol(QgsWkbTypes::GeometryType geomType)
Returns a new default symbol for the specified geometry type.
Definition: qgssymbol.cpp:704
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
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
Represents a vector layer which manages a vector based data sets.
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:141
const QgsField & field
Definition: qgsfield.h:463
QList< QgsLegendSymbolItem > QgsLegendSymbolList
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define RENDERER_TAG_NAME
Definition: qgsrenderer.h:50
QList< QgsSymbol * > QgsSymbolList
Definition: qgsrenderer.h:44