QGIS API Documentation  3.21.0-Master (5b68dc587e)
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"
19 #include "qgsrulebasedrenderer.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"
28 #include "qgsgeometrycollection.h"
29 #include "qgsfeature.h"
30 #include "qgslogger.h"
31 #include "qgsvectorlayer.h"
32 #include "qgspainteffect.h"
33 #include "qgseffectstack.h"
34 #include "qgspainteffectregistry.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 
47 QPointF QgsFeatureRenderer::_getPoint( QgsRenderContext &context, const QgsPoint &point )
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 
89 QSet< 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 
127 bool 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 
141 void 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 
157 QgsFeatureRenderer *QgsFeatureRenderer::load( QDomElement &element, const QgsReadWriteContext &context )
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 
193 QDomElement 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 
204 void 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" ) );
216  mOrderBy.save( orderBy );
217  rendererElem.appendChild( orderBy );
218  }
219  rendererElem.setAttribute( QStringLiteral( "enableorderby" ), ( mOrderByEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) ) );
220 }
221 
222 QgsFeatureRenderer *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 
333 QDomElement 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 
359 void QgsFeatureRenderer::checkLegendSymbolItem( const QString &key, bool state )
360 {
361  Q_UNUSED( key )
362  Q_UNUSED( state )
363 }
364 
365 void QgsFeatureRenderer::setLegendSymbolItem( const QString &key, QgsSymbol *symbol )
366 {
367  Q_UNUSED( key )
368  delete symbol;
369 }
370 
372 {
373  return QgsLegendSymbolList();
374 }
375 
377 {
380 }
381 
383 {
384  return nullptr != symbolForFeature( feature, context );
385 }
386 
388 {
390  QgsSymbolLayerUtils::drawVertexMarker( pt.x(), pt.y(), *context.painter(),
392  markerSize );
393 }
394 
396 {
397  const auto constPts = pts;
398  for ( const QPointF pt : constPts )
399  renderVertexMarker( pt, context );
400 }
401 
402 void QgsFeatureRenderer::renderVertexMarkerPolygon( QPolygonF &pts, QList<QPolygonF> *rings, QgsRenderContext &context )
403 {
404  const auto constPts = pts;
405  for ( const QPointF pt : constPts )
406  renderVertexMarker( pt, context );
407 
408  if ( rings )
409  {
410  const auto constRings = *rings;
411  for ( const QPolygonF &ring : constRings )
412  {
413  const auto constRing = ring;
414  for ( const QPointF pt : constRing )
415  renderVertexMarker( pt, context );
416  }
417  }
418 }
419 
421 {
422  QgsSymbolList lst;
423  QgsSymbol *s = symbolForFeature( feature, context );
424  if ( s ) lst.append( s );
425  return lst;
426 }
427 
429 {
430  Q_UNUSED( extent )
431  Q_UNUSED( context )
432 }
433 
435 {
436  QgsSymbolList lst;
437  QgsSymbol *s = originalSymbolForFeature( feature, context );
438  if ( s ) lst.append( s );
439  return lst;
440 }
441 
443 {
444  return mPaintEffect;
445 }
446 
448 {
449  delete mPaintEffect;
450  mPaintEffect = effect;
451 }
452 
454 {
455  return mOrderBy;
456 }
457 
459 {
460  mOrderBy = orderBy;
461 }
462 
464 {
465  return mOrderByEnabled;
466 }
467 
469 {
470  mOrderByEnabled = enabled;
471 }
472 
474 {
475  delete subRenderer;
476 }
477 
479 {
480  return nullptr;
481 }
482 
484 {
485  return true;
486 }
487 
489 {
490  if ( symbol->type() == Qgis:: SymbolType::Marker )
491  {
492  QgsMarkerSymbol *s = static_cast<QgsMarkerSymbol *>( symbol );
493  if ( Qgis::ScaleMethod::ScaleArea == method )
494  {
495  s->setDataDefinedSize( QgsProperty::fromExpression( "coalesce(sqrt(" + QString::number( s->size() ) + " * (" + field + ")),0)" ) );
496  }
497  else
498  {
499  s->setDataDefinedSize( QgsProperty::fromExpression( "coalesce(" + QString::number( s->size() ) + " * (" + field + "),0)" ) );
500  }
502  }
503  else if ( symbol->type() == Qgis::SymbolType::Line )
504  {
505  QgsLineSymbol *s = static_cast<QgsLineSymbol *>( symbol );
506  s->setDataDefinedWidth( QgsProperty::fromExpression( "coalesce(" + QString::number( s->width() ) + " * (" + field + "),0)" ) );
507  }
508 }
509 
511 {
512  if ( symbol->type() == Qgis::SymbolType::Marker )
513  {
514  QgsMarkerSymbol *s = static_cast<QgsMarkerSymbol *>( symbol );
516  ? QString::number( s->angle() ) + " + "
517  : QString() ) + field );
518  s->setDataDefinedAngle( dd );
519  }
520 }
521 
523 {
524  return mSymbol;
525 }
526 
528 {
529  return mLayer;
530 }
ScaleMethod
Scale methods.
Definition: qgis.h:183
@ 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:574
@ 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:436
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:591
virtual QgsSymbol * symbolForFeature(const QgsFeature &feature, QgsRenderContext &context) const =0
To be overridden.
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:468
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 void checkLegendSymbolItem(const QString &key, bool state=true)
item in symbology was checked
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:609
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:586
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:589
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
double width() const
Returns the estimated width for the whole symbol, which is the maximum width of all marker symbol lay...
void setDataDefinedWidth(const QgsProperty &property)
Set data defined width for whole symbol (including all symbol layers).
A marker symbol type, for rendering Point and MultiPoint geometries.
void setScaleMethod(Qgis::ScaleMethod scaleMethod)
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)
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:232
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 * createRendererFromSld(QDomElement &elem, QgsWkbTypes::GeometryType geomType)
virtual QgsFeatureRenderer * createRenderer(QDomElement &elem, const QgsReadWriteContext &context)=0
Returns new instance of the renderer given the DOM element.
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:38
static QPointF _getPoint(QgsRenderContext &context, const QgsPoint &point)
Creates a point in screen coordinates from a QgsPoint in map coordinates.
Definition: qgssymbol.h:639
static QgsSymbol * defaultSymbol(QgsWkbTypes::GeometryType geomType)
Returns a new default symbol for the specified geometry type.
Definition: qgssymbol.cpp:355
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:903
Qgis::SymbolType type() const
Returns the symbol's type.
Definition: qgssymbol.h:97
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
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