QGIS API Documentation  3.21.0-Master (909859188c)
qgssymbollayer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgssymbollayer.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 "qgssymbollayer.h"
17 #include "qgsclipper.h"
18 #include "qgsexpression.h"
19 #include "qgsrendercontext.h"
20 #include "qgsvectorlayer.h"
21 #include "qgsdxfexport.h"
22 #include "qgsgeometrysimplifier.h"
23 #include "qgspainteffect.h"
24 #include "qgseffectstack.h"
25 #include "qgspainteffectregistry.h"
26 #include "qgsproperty.h"
27 #include "qgsexpressioncontext.h"
28 #include "qgssymbollayerutils.h"
29 #include "qgsapplication.h"
30 #include "qgsmultipoint.h"
31 #include "qgslegendpatchshape.h"
32 #include "qgsstyle.h"
34 #include "qgssymbol.h"
36 
37 #include <QSize>
38 #include <QPainter>
39 #include <QPointF>
40 #include <QPolygonF>
41 
42 QgsPropertiesDefinition QgsSymbolLayer::sPropertyDefinitions;
43 
44 void QgsSymbolLayer::initPropertyDefinitions()
45 {
46  if ( !sPropertyDefinitions.isEmpty() )
47  return;
48 
49  QString origin = QStringLiteral( "symbol" );
50 
51  sPropertyDefinitions = QgsPropertiesDefinition
52  {
53  { QgsSymbolLayer::PropertySize, QgsPropertyDefinition( "size", QObject::tr( "Symbol size" ), QgsPropertyDefinition::Size, origin ) },
54  { QgsSymbolLayer::PropertyAngle, QgsPropertyDefinition( "angle", QObject::tr( "Rotation angle" ), QgsPropertyDefinition::Rotation, origin ) },
55  { QgsSymbolLayer::PropertyName, QgsPropertyDefinition( "name", QObject::tr( "Symbol name" ), QgsPropertyDefinition::String, origin ) },
56  { QgsSymbolLayer::PropertyFillColor, QgsPropertyDefinition( "fillColor", QObject::tr( "Symbol fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
57  { QgsSymbolLayer::PropertyStrokeColor, QgsPropertyDefinition( "outlineColor", QObject::tr( "Symbol stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
58  { QgsSymbolLayer::PropertyStrokeWidth, QgsPropertyDefinition( "outlineWidth", QObject::tr( "Symbol stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },
59  { QgsSymbolLayer::PropertyStrokeStyle, QgsPropertyDefinition( "outlineStyle", QObject::tr( "Symbol stroke style" ), QgsPropertyDefinition::LineStyle, origin )},
60  { QgsSymbolLayer::PropertyOffset, QgsPropertyDefinition( "offset", QObject::tr( "Symbol offset" ), QgsPropertyDefinition::Offset, origin )},
61  { QgsSymbolLayer::PropertyCharacter, QgsPropertyDefinition( "char", QObject::tr( "Marker character(s)" ), QgsPropertyDefinition::String, origin )},
62  { QgsSymbolLayer::PropertyFontFamily, QgsPropertyDefinition( "fontFamily", QObject::tr( "Font family" ), QgsPropertyDefinition::String, origin )},
63  { QgsSymbolLayer::PropertyFontStyle, QgsPropertyDefinition( "fontStyle", QObject::tr( "Font style" ), QgsPropertyDefinition::String, origin )},
64  { QgsSymbolLayer::PropertyWidth, QgsPropertyDefinition( "width", QObject::tr( "Symbol width" ), QgsPropertyDefinition::DoublePositive, origin )},
65  { QgsSymbolLayer::PropertyHeight, QgsPropertyDefinition( "height", QObject::tr( "Symbol height" ), QgsPropertyDefinition::DoublePositive, origin )},
66  { QgsSymbolLayer::PropertyPreserveAspectRatio, QgsPropertyDefinition( "preserveAspectRatio", QObject::tr( "Preserve aspect ratio between width and height" ), QgsPropertyDefinition::Boolean, origin )},
67  { QgsSymbolLayer::PropertyFillStyle, QgsPropertyDefinition( "fillStyle", QObject::tr( "Symbol fill style" ), QgsPropertyDefinition::FillStyle, origin )},
68  { QgsSymbolLayer::PropertyJoinStyle, QgsPropertyDefinition( "joinStyle", QObject::tr( "Outline join style" ), QgsPropertyDefinition::PenJoinStyle, origin )},
69  { QgsSymbolLayer::PropertySecondaryColor, QgsPropertyDefinition( "color2", QObject::tr( "Secondary fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin )},
70  { QgsSymbolLayer::PropertyLineAngle, QgsPropertyDefinition( "lineAngle", QObject::tr( "Angle for line fills" ), QgsPropertyDefinition::Rotation, origin )},
71  { QgsSymbolLayer::PropertyGradientType, QgsPropertyDefinition( "gradientType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient type" ), QObject::tr( "string " ) + QLatin1String( "[<b>linear</b>|<b>radial</b>|<b>conical</b>]" ), origin )},
72  { QgsSymbolLayer::PropertyCoordinateMode, QgsPropertyDefinition( "gradientMode", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>feature</b>|<b>viewport</b>]" ), origin )},
73  { QgsSymbolLayer::PropertyGradientSpread, QgsPropertyDefinition( "gradientSpread", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient spread" ), QObject::tr( "string " ) + QLatin1String( "[<b>pad</b>|<b>repeat</b>|<b>reflect</b>]" ), origin )},
74  { QgsSymbolLayer::PropertyGradientReference1X, QgsPropertyDefinition( "gradientRef1X", QObject::tr( "Reference point 1 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
75  { QgsSymbolLayer::PropertyGradientReference1Y, QgsPropertyDefinition( "gradientRef1Y", QObject::tr( "Reference point 1 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
76  { QgsSymbolLayer::PropertyGradientReference2X, QgsPropertyDefinition( "gradientRef2X", QObject::tr( "Reference point 2 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
77  { QgsSymbolLayer::PropertyGradientReference2Y, QgsPropertyDefinition( "gradientRef2Y", QObject::tr( "Reference point 2 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
78  { QgsSymbolLayer::PropertyGradientReference1IsCentroid, QgsPropertyDefinition( "gradientRef1Centroid", QObject::tr( "Reference point 1 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
79  { QgsSymbolLayer::PropertyGradientReference2IsCentroid, QgsPropertyDefinition( "gradientRef2Centroid", QObject::tr( "Reference point 2 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
80  { QgsSymbolLayer::PropertyBlurRadius, QgsPropertyDefinition( "blurRadius", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Blur radius" ), QObject::tr( "Integer between 0 and 18" ), origin )},
81  { QgsSymbolLayer::PropertyLineDistance, QgsPropertyDefinition( "lineDistance", QObject::tr( "Distance between lines" ), QgsPropertyDefinition::DoublePositive, origin )},
82  { QgsSymbolLayer::PropertyShapeburstUseWholeShape, QgsPropertyDefinition( "shapeburstWholeShape", QObject::tr( "Shade whole shape" ), QgsPropertyDefinition::Boolean, origin )},
83  { QgsSymbolLayer::PropertyShapeburstMaxDistance, QgsPropertyDefinition( "shapeburstMaxDist", QObject::tr( "Maximum distance for shapeburst fill" ), QgsPropertyDefinition::DoublePositive, origin )},
84  { QgsSymbolLayer::PropertyShapeburstIgnoreRings, QgsPropertyDefinition( "shapeburstIgnoreRings", QObject::tr( "Ignore rings in feature" ), QgsPropertyDefinition::Boolean, origin )},
85  { QgsSymbolLayer::PropertyFile, QgsPropertyDefinition( "file", QObject::tr( "Symbol file path" ), QgsPropertyDefinition::String, origin )},
86  { QgsSymbolLayer::PropertyDistanceX, QgsPropertyDefinition( "distanceX", QObject::tr( "Horizontal distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
87  { QgsSymbolLayer::PropertyDistanceY, QgsPropertyDefinition( "distanceY", QObject::tr( "Vertical distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
88  { QgsSymbolLayer::PropertyDisplacementX, QgsPropertyDefinition( "displacementX", QObject::tr( "Horizontal displacement between rows" ), QgsPropertyDefinition::DoublePositive, origin )},
89  { QgsSymbolLayer::PropertyDisplacementY, QgsPropertyDefinition( "displacementY", QObject::tr( "Vertical displacement between columns" ), QgsPropertyDefinition::DoublePositive, origin )},
90  { QgsSymbolLayer::PropertyOffsetX, QgsPropertyDefinition( "offsetX", QObject::tr( "Horizontal offset" ), QgsPropertyDefinition::Double, origin )},
91  { QgsSymbolLayer::PropertyOffsetY, QgsPropertyDefinition( "offsetY", QObject::tr( "Vertical offset" ), QgsPropertyDefinition::Double, origin )},
92  { QgsSymbolLayer::PropertyOpacity, QgsPropertyDefinition( "alpha", QObject::tr( "Opacity" ), QgsPropertyDefinition::Opacity, origin )},
93  { QgsSymbolLayer::PropertyCustomDash, QgsPropertyDefinition( "customDash", QgsPropertyDefinition::DataTypeString, QObject::tr( "Custom dash pattern" ), QObject::tr( "[<b><dash>;<space></b>] e.g. '8;2;1;2'" ), origin )},
94  { QgsSymbolLayer::PropertyCapStyle, QgsPropertyDefinition( "capStyle", QObject::tr( "Line cap style" ), QgsPropertyDefinition::CapStyle, origin )},
95  { QgsSymbolLayer::PropertyPlacement, QgsPropertyDefinition( "placement", QgsPropertyDefinition::DataTypeString, QObject::tr( "Marker placement" ), QObject::tr( "string " ) + "[<b>interval</b>|<b>vertex</b>|<b>lastvertex</b>|<b>firstvertex</b>|<b>centerpoint</b>|<b>curvepoint</b>|<b>segmentcenter</b>]", origin )},
96  { QgsSymbolLayer::PropertyInterval, QgsPropertyDefinition( "interval", QObject::tr( "Marker interval" ), QgsPropertyDefinition::DoublePositive, origin )},
97  { QgsSymbolLayer::PropertyOffsetAlongLine, QgsPropertyDefinition( "offsetAlongLine", QObject::tr( "Offset along line" ), QgsPropertyDefinition::DoublePositive, origin )},
98  { QgsSymbolLayer::PropertyAverageAngleLength, QgsPropertyDefinition( "averageAngleLength", QObject::tr( "Average line angles over" ), QgsPropertyDefinition::DoublePositive, origin )},
99  { QgsSymbolLayer::PropertyHorizontalAnchor, QgsPropertyDefinition( "hAnchor", QObject::tr( "Horizontal anchor point" ), QgsPropertyDefinition::HorizontalAnchor, origin )},
100  { QgsSymbolLayer::PropertyVerticalAnchor, QgsPropertyDefinition( "vAnchor", QObject::tr( "Vertical anchor point" ), QgsPropertyDefinition::VerticalAnchor, origin )},
101  { QgsSymbolLayer::PropertyLayerEnabled, QgsPropertyDefinition( "enabled", QObject::tr( "Layer enabled" ), QgsPropertyDefinition::Boolean, origin )},
102  { QgsSymbolLayer::PropertyArrowWidth, QgsPropertyDefinition( "arrowWidth", QObject::tr( "Arrow line width" ), QgsPropertyDefinition::StrokeWidth, origin )},
103  { QgsSymbolLayer::PropertyArrowStartWidth, QgsPropertyDefinition( "arrowStartWidth", QObject::tr( "Arrow line start width" ), QgsPropertyDefinition::StrokeWidth, origin )},
104  { QgsSymbolLayer::PropertyArrowHeadLength, QgsPropertyDefinition( "arrowHeadLength", QObject::tr( "Arrow head length" ), QgsPropertyDefinition::DoublePositive, origin )},
105  { QgsSymbolLayer::PropertyArrowHeadThickness, QgsPropertyDefinition( "arrowHeadThickness", QObject::tr( "Arrow head thickness" ), QgsPropertyDefinition::DoublePositive, origin )},
106  { QgsSymbolLayer::PropertyArrowHeadType, QgsPropertyDefinition( "arrowHeadType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow head type" ), QObject::tr( "string " ) + QLatin1String( "[<b>single</b>|<b>reversed</b>|<b>double</b>]" ), origin )},
107  { QgsSymbolLayer::PropertyArrowType, QgsPropertyDefinition( "arrowType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow type" ), QObject::tr( "string " ) + QLatin1String( "[<b>plain</b>|<b>lefthalf</b>|<b>righthalf</b>]" ), origin )},
108  { QgsSymbolLayer::PropertyPointCount, QgsPropertyDefinition( "pointCount", QObject::tr( "Point count" ), QgsPropertyDefinition::IntegerPositive, origin )},
109  { QgsSymbolLayer::PropertyRandomSeed, QgsPropertyDefinition( "randomSeed", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Random number seed" ), QObject::tr( "integer > 0, or 0 for completely random sequence" ), origin )},
110  { QgsSymbolLayer::PropertyClipPoints, QgsPropertyDefinition( "clipPoints", QObject::tr( "Clip markers" ), QgsPropertyDefinition::Boolean, origin )},
111  { QgsSymbolLayer::PropertyClipPoints, QgsPropertyDefinition( "densityArea", QObject::tr( "Density area" ), QgsPropertyDefinition::DoublePositive, origin )},
112  { QgsSymbolLayer::PropertyDashPatternOffset, QgsPropertyDefinition( "dashPatternOffset", QObject::tr( "Dash pattern offset" ), QgsPropertyDefinition::DoublePositive, origin )},
113  { QgsSymbolLayer::PropertyTrimStart, QgsPropertyDefinition( "trimStart", QObject::tr( "Start trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
114  { QgsSymbolLayer::PropertyTrimEnd, QgsPropertyDefinition( "trimEnd", QObject::tr( "End trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
115  };
116 }
117 
119 {
120  dataDefinedProperties().setProperty( key, property );
121 }
122 
124 {
125  if ( QgsSymbol *lSubSymbol = subSymbol() )
126  lSubSymbol->startFeatureRender( feature, context );
127 }
128 
130 {
131  if ( QgsSymbol *lSubSymbol = subSymbol() )
132  lSubSymbol->stopFeatureRender( feature, context );
133 }
134 
136 {
137  return nullptr;
138 }
139 
141 {
142  delete symbol;
143  return false;
144 }
145 
146 bool QgsSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const
147 {
148  Q_UNUSED( e )
149  Q_UNUSED( mmMapUnitScaleFactor )
150  Q_UNUSED( layerName )
151  Q_UNUSED( context )
152  Q_UNUSED( shift )
153  return false;
154 }
155 
157 {
158  Q_UNUSED( e )
159  Q_UNUSED( context )
160  return 1.0;
161 }
162 
164 {
165  Q_UNUSED( e )
166  Q_UNUSED( context )
167  return 0.0;
168 }
169 
171 {
172  Q_UNUSED( context )
173  return color();
174 }
175 
177 {
178  Q_UNUSED( context )
179  return 0.0;
180 }
181 
183 {
184  Q_UNUSED( unit )
185  return QVector<qreal>();
186 }
187 
188 Qt::PenStyle QgsSymbolLayer::dxfPenStyle() const
189 {
190  return Qt::SolidLine;
191 }
192 
194 {
195  Q_UNUSED( context )
196  return color();
197 }
198 
199 Qt::BrushStyle QgsSymbolLayer::dxfBrushStyle() const
200 {
201  return Qt::NoBrush;
202 }
203 
205 {
206  return mPaintEffect.get();
207 }
208 
210 {
211  if ( effect == mPaintEffect.get() )
212  return;
213 
214  mPaintEffect.reset( effect );
215 }
216 
218  : mType( type )
219  , mLocked( locked )
220 {
221 }
222 
224 {
226 
227  if ( !context.fields().isEmpty() )
228  {
229  //QgsFields is implicitly shared, so it's cheap to make a copy
230  mFields = context.fields();
231  }
232 }
233 
235 {
237 }
238 
240 {
241  QgsSymbolLayer::initPropertyDefinitions();
242  return sPropertyDefinitions;
243 }
244 
246 
248 {
249  if ( symbol->type() == Qgis::SymbolType::Fill && mType == Qgis::SymbolType::Line )
250  return true;
251 
252  return symbol->type() == mType;
253 }
254 
256 {
257  return false;
258 }
259 
261 {
262  return false;
263 }
264 
265 void QgsSymbolLayer::setRenderingPass( int renderingPass )
266 {
268 }
269 
271 {
272  return mRenderingPass;
273 }
274 
275 QSet<QString> QgsSymbolLayer::usedAttributes( const QgsRenderContext &context ) const
276 {
277  // calling referencedFields() with ignoreContext=true because in our expression context
278  // we do not have valid QgsFields yet - because of that the field names from expressions
279  // wouldn't get reported
280  QSet<QString> columns = mDataDefinedProperties.referencedFields( context.expressionContext(), true );
281  return columns;
282 }
283 
284 QgsProperty propertyFromMap( const QVariantMap &map, const QString &baseName )
285 {
286  QString prefix;
287  if ( !baseName.isEmpty() )
288  {
289  prefix.append( QStringLiteral( "%1_dd_" ).arg( baseName ) );
290  }
291 
292  if ( !map.contains( QStringLiteral( "%1expression" ).arg( prefix ) ) )
293  {
294  //requires at least the expression value
295  return QgsProperty();
296  }
297 
298  bool active = ( map.value( QStringLiteral( "%1active" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
299  QString expression = map.value( QStringLiteral( "%1expression" ).arg( prefix ) ).toString();
300  bool useExpression = ( map.value( QStringLiteral( "%1useexpr" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
301  QString field = map.value( QStringLiteral( "%1field" ).arg( prefix ), QString() ).toString();
302 
303  if ( useExpression )
304  return QgsProperty::fromExpression( expression, active );
305  else
306  return QgsProperty::fromField( field, active );
307 }
308 
309 void QgsSymbolLayer::restoreOldDataDefinedProperties( const QVariantMap &stringMap )
310 {
311  // property string to type upgrade map
312  static const QMap< QString, QgsSymbolLayer::Property > OLD_PROPS
313  {
315  { "arrow_width", QgsSymbolLayer::PropertyArrowWidth },
316  { "arrow_start_width", QgsSymbolLayer::PropertyArrowStartWidth },
317  { "head_length", QgsSymbolLayer::PropertyArrowHeadLength },
318  { "head_thickness", QgsSymbolLayer::PropertyArrowHeadThickness },
319  { "offset", QgsSymbolLayer::PropertyOffset },
320  { "head_type", QgsSymbolLayer::PropertyArrowHeadType },
321  { "arrow_type", QgsSymbolLayer::PropertyArrowType },
322  { "width_field", QgsSymbolLayer::PropertyWidth },
323  { "height_field", QgsSymbolLayer::PropertyHeight },
324  { "rotation_field", QgsSymbolLayer::PropertyAngle },
325  { "outline_width_field", QgsSymbolLayer::PropertyStrokeWidth },
326  { "fill_color_field", QgsSymbolLayer::PropertyFillColor },
327  { "outline_color_field", QgsSymbolLayer::PropertyStrokeColor },
328  { "symbol_name_field", QgsSymbolLayer::PropertyName },
329  { "outline_width", QgsSymbolLayer::PropertyStrokeWidth },
330  { "outline_style", QgsSymbolLayer::PropertyStrokeStyle },
331  { "join_style", QgsSymbolLayer::PropertyJoinStyle },
332  { "fill_color", QgsSymbolLayer::PropertyFillColor },
333  { "outline_color", QgsSymbolLayer::PropertyStrokeColor },
334  { "width", QgsSymbolLayer::PropertyWidth },
335  { "height", QgsSymbolLayer::PropertyHeight },
336  { "symbol_name", QgsSymbolLayer::PropertyName },
337  { "angle", QgsSymbolLayer::PropertyAngle },
338  { "fill_style", QgsSymbolLayer::PropertyFillStyle },
339  { "color_border", QgsSymbolLayer::PropertyStrokeColor },
340  { "width_border", QgsSymbolLayer::PropertyStrokeWidth },
341  { "border_color", QgsSymbolLayer::PropertyStrokeColor },
342  { "border_style", QgsSymbolLayer::PropertyStrokeStyle },
344  { "gradient_type", QgsSymbolLayer::PropertyGradientType },
345  { "coordinate_mode", QgsSymbolLayer::PropertyCoordinateMode },
351  { "reference1_iscentroid", QgsSymbolLayer::PropertyGradientReference1IsCentroid },
352  { "reference2_iscentroid", QgsSymbolLayer::PropertyGradientReference2IsCentroid },
353  { "blur_radius", QgsSymbolLayer::PropertyBlurRadius },
357  { "svgFillColor", QgsSymbolLayer::PropertyFillColor },
358  { "svgOutlineColor", QgsSymbolLayer::PropertyStrokeColor },
359  { "svgOutlineWidth", QgsSymbolLayer::PropertyStrokeWidth },
360  { "svgFile", QgsSymbolLayer::PropertyFile },
361  { "lineangle", QgsSymbolLayer::PropertyLineAngle },
362  { "distance", QgsSymbolLayer::PropertyLineDistance },
363  { "distance_x", QgsSymbolLayer::PropertyDistanceX },
364  { "distance_y", QgsSymbolLayer::PropertyDistanceY },
365  { "displacement_x", QgsSymbolLayer::PropertyDisplacementX },
366  { "displacement_y", QgsSymbolLayer::PropertyDisplacementY },
367  { "file", QgsSymbolLayer::PropertyFile },
368  { "alpha", QgsSymbolLayer::PropertyOpacity },
369  { "customdash", QgsSymbolLayer::PropertyCustomDash },
370  { "line_style", QgsSymbolLayer::PropertyStrokeStyle },
371  { "joinstyle", QgsSymbolLayer::PropertyJoinStyle },
372  { "capstyle", QgsSymbolLayer::PropertyCapStyle },
373  { "placement", QgsSymbolLayer::PropertyPlacement },
374  { "interval", QgsSymbolLayer::PropertyInterval },
375  { "offset_along_line", QgsSymbolLayer::PropertyOffsetAlongLine },
376  { "name", QgsSymbolLayer::PropertyName },
377  { "size", QgsSymbolLayer::PropertySize },
382  { "rotation", QgsSymbolLayer::PropertyAngle },
383  { "horizontal_anchor_point", QgsSymbolLayer::PropertyHorizontalAnchor },
384  { "vertical_anchor_point", QgsSymbolLayer::PropertyVerticalAnchor },
385  };
386 
387  QVariantMap::const_iterator propIt = stringMap.constBegin();
388  for ( ; propIt != stringMap.constEnd(); ++propIt )
389  {
390  std::unique_ptr<QgsProperty> prop;
391  QString propertyName;
392 
393  if ( propIt.key().endsWith( QLatin1String( "_dd_expression" ) ) )
394  {
395  //found a data defined property
396 
397  //get data defined property name by stripping "_dd_expression" from property key
398  propertyName = propIt.key().left( propIt.key().length() - 14 );
399 
400  prop = std::make_unique<QgsProperty>( propertyFromMap( stringMap, propertyName ) );
401  }
402  else if ( propIt.key().endsWith( QLatin1String( "_expression" ) ) )
403  {
404  //old style data defined property, upgrade
405 
406  //get data defined property name by stripping "_expression" from property key
407  propertyName = propIt.key().left( propIt.key().length() - 11 );
408 
409  prop = std::make_unique<QgsProperty>( QgsProperty::fromExpression( propIt.value().toString() ) );
410  }
411 
412  if ( !prop || !OLD_PROPS.contains( propertyName ) )
413  continue;
414 
415  QgsSymbolLayer::Property key = static_cast< QgsSymbolLayer::Property >( OLD_PROPS.value( propertyName ) );
416 
417  if ( type() == Qgis::SymbolType::Line )
418  {
419  //these keys had different meaning for line symbol layers
420  if ( propertyName == QLatin1String( "width" ) )
422  else if ( propertyName == QLatin1String( "color" ) )
424  }
425 
426  setDataDefinedProperty( key, QgsProperty( *prop.get() ) );
427  }
428 }
429 
431 {
432  if ( !destLayer )
433  return;
434 
436 }
437 
439 {
440  if ( !destLayer || !mPaintEffect )
441  return;
442 
444  destLayer->setPaintEffect( mPaintEffect->clone() );
445  else
446  destLayer->setPaintEffect( nullptr );
447 }
448 
450  : QgsSymbolLayer( Qgis::SymbolType::Marker, locked )
451 {
452 
453 }
454 
456  : QgsSymbolLayer( Qgis::SymbolType::Line, locked )
457 {
458 }
459 
461 {
462  return mRingFilter;
463 }
464 
466 {
467  mRingFilter = filter;
468 }
469 
471  : QgsSymbolLayer( Qgis::SymbolType::Fill, locked )
472 {
473 }
474 
476 {
477  Q_UNUSED( context )
478 }
479 
481 {
482  Q_UNUSED( context )
483 }
484 
486 {
487  startRender( context );
488  QgsPaintEffect *effect = paintEffect();
489 
490  QPolygonF points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 )
492 
493  std::unique_ptr< QgsEffectPainter > effectPainter;
494  if ( effect && effect->enabled() )
495  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
496 
497  for ( QPointF point : std::as_const( points ) )
498  renderPoint( point, context );
499 
500  effectPainter.reset();
501 
502  stopRender( context );
503 }
504 
505 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const
506 {
508 }
509 
510 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const
511 {
512  markerOffset( context, width, height, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );
513 }
514 
515 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height,
517  double &offsetX, double &offsetY, const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const
518 {
519  offsetX = mOffset.x();
520  offsetY = mOffset.y();
521 
523  {
526  bool ok = false;
527  const QPointF offset = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
528  if ( ok )
529  {
530  offsetX = offset.x();
531  offsetY = offset.y();
532  }
533  }
534 
535  offsetX = context.renderContext().convertToPainterUnits( offsetX, mOffsetUnit, mOffsetMapUnitScale );
536  offsetY = context.renderContext().convertToPainterUnits( offsetY, mOffsetUnit, mOffsetMapUnitScale );
537 
541  {
543  if ( !exprVal.isNull() )
544  {
545  horizontalAnchorPoint = decodeHorizontalAnchorPoint( exprVal.toString() );
546  }
547  }
549  {
551  if ( !exprVal.isNull() )
552  {
553  verticalAnchorPoint = decodeVerticalAnchorPoint( exprVal.toString() );
554  }
555  }
556 
557  //correct horizontal position according to anchor point
559  {
560  return;
561  }
562 
563  double anchorPointCorrectionX = context.renderContext().convertToPainterUnits( width, widthUnit, widthMapUnitScale ) / 2.0;
565  {
566  // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
567  // and clamp it to a reasonable range. It's the best we can do in this situation!
568  anchorPointCorrectionX = std::min( std::max( context.renderContext().convertToPainterUnits( width, QgsUnitTypes::RenderMillimeters ), 3.0 ), 100.0 ) / 2.0;
569  }
570 
571  double anchorPointCorrectionY = context.renderContext().convertToPainterUnits( height, heightUnit, heightMapUnitScale ) / 2.0;
573  {
574  // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
575  // and clamp it to a reasonable range. It's the best we can do in this situation!
576  anchorPointCorrectionY = std::min( std::max( context.renderContext().convertToPainterUnits( height, QgsUnitTypes::RenderMillimeters ), 3.0 ), 100.0 ) / 2.0;
577  }
578 
579  if ( horizontalAnchorPoint == Left )
580  {
581  offsetX += anchorPointCorrectionX;
582  }
583  else if ( horizontalAnchorPoint == Right )
584  {
585  offsetX -= anchorPointCorrectionX;
586  }
587 
588  //correct vertical position according to anchor point
589  if ( verticalAnchorPoint == Top )
590  {
591  offsetY += anchorPointCorrectionY;
592  }
593  else if ( verticalAnchorPoint == Bottom )
594  {
595  offsetY -= anchorPointCorrectionY;
596  }
597 }
598 
599 QPointF QgsMarkerSymbolLayer::_rotatedOffset( QPointF offset, double angle )
600 {
601  angle = DEG2RAD( angle );
602  double c = std::cos( angle ), s = std::sin( angle );
603  return QPointF( offset.x() * c - offset.y() * s, offset.x() * s + offset.y() * c );
604 }
605 
606 QgsMarkerSymbolLayer::HorizontalAnchorPoint QgsMarkerSymbolLayer::decodeHorizontalAnchorPoint( const QString &str )
607 {
608  if ( str.compare( QLatin1String( "left" ), Qt::CaseInsensitive ) == 0 )
609  {
611  }
612  else if ( str.compare( QLatin1String( "right" ), Qt::CaseInsensitive ) == 0 )
613  {
615  }
616  else
617  {
619  }
620 }
621 
622 QgsMarkerSymbolLayer::VerticalAnchorPoint QgsMarkerSymbolLayer::decodeVerticalAnchorPoint( const QString &str )
623 {
624  if ( str.compare( QLatin1String( "top" ), Qt::CaseInsensitive ) == 0 )
625  {
627  }
628  else if ( str.compare( QLatin1String( "bottom" ), Qt::CaseInsensitive ) == 0 )
629  {
631  }
632  else
633  {
635  }
636 }
637 
639 {
640  mSizeUnit = unit;
641  mOffsetUnit = unit;
642 }
643 
645 {
646  if ( mOffsetUnit != mSizeUnit )
647  {
649  }
650  return mOffsetUnit;
651 }
652 
654 {
655  mSizeMapUnitScale = scale;
656  mOffsetMapUnitScale = scale;
657 }
658 
660 {
662  {
663  return mSizeMapUnitScale;
664  }
665  return QgsMapUnitScale();
666 }
667 
669 {
670  mWidthUnit = unit;
671 }
672 
674 {
675  return mWidthUnit;
676 }
677 
679 {
680  mWidthMapUnitScale = scale;
681 }
682 
684 {
685  return mWidthMapUnitScale;
686 }
687 
688 
690 {
691  const QList< QList< QPolygonF > > points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Line, size )
693  startRender( context );
694  QgsPaintEffect *effect = paintEffect();
695 
696  std::unique_ptr< QgsEffectPainter > effectPainter;
697  if ( effect && effect->enabled() )
698  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
699 
700  for ( const QList< QPolygonF > &line : points )
701  renderPolyline( line.value( 0 ), context );
702 
703  effectPainter.reset();
704 
705  stopRender( context );
706 }
707 
708 void QgsLineSymbolLayer::renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
709 {
710  QgsExpressionContextScope *scope = nullptr;
711  std::unique_ptr< QgsExpressionContextScopePopper > scopePopper;
712  if ( hasDataDefinedProperties() )
713  {
714  scope = new QgsExpressionContextScope();
715  scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.renderContext().expressionContext(), scope );
716  }
717 
718  switch ( mRingFilter )
719  {
720  case AllRings:
721  case ExteriorRingOnly:
722  {
723  if ( scope )
725  renderPolyline( points, context );
726  break;
727  }
728  case InteriorRingsOnly:
729  break;
730  }
731 
732  if ( rings )
733  {
734  switch ( mRingFilter )
735  {
736  case AllRings:
737  case InteriorRingsOnly:
738  {
739  int ringIndex = 1;
740  for ( const QPolygonF &ring : std::as_const( *rings ) )
741  {
742  if ( scope )
744 
745  renderPolyline( ring, context );
746  ringIndex++;
747  }
748  }
749  break;
750  case ExteriorRingOnly:
751  break;
752  }
753  }
754 }
755 
756 double QgsLineSymbolLayer::width( const QgsRenderContext &context ) const
757 {
759 }
760 
762 {
763  Q_UNUSED( context )
765 }
766 
767 
769 {
770  const QList< QList< QPolygonF > > polys = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Fill, size )
772 
773  startRender( context );
774  QgsPaintEffect *effect = paintEffect();
775 
776  std::unique_ptr< QgsEffectPainter > effectPainter;
777  if ( effect && effect->enabled() )
778  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
779 
780  for ( const QList< QPolygonF > &poly : polys )
781  {
782  QVector< QPolygonF > rings;
783  for ( int i = 1; i < poly.size(); ++i )
784  rings << poly.at( i );
785  renderPolygon( poly.value( 0 ), &rings, context );
786  }
787 
788  effectPainter.reset();
789 
790  stopRender( context );
791 }
792 
793 void QgsFillSymbolLayer::_renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
794 {
795  if ( !p )
796  {
797  return;
798  }
799 
800  // Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #5 points).
801  if ( points.size() <= 5 &&
804  ( p->renderHints() & QPainter::Antialiasing ) )
805  {
806  p->setRenderHint( QPainter::Antialiasing, false );
807  p->drawRect( points.boundingRect() );
808  p->setRenderHint( QPainter::Antialiasing, true );
809  return;
810  }
811 
812  // polygons outlines are sometimes rendered wrongly with drawPolygon, when
813  // clipped (see #13343), so use drawPath instead.
814  if ( !rings && p->pen().style() == Qt::NoPen )
815  {
816  // simple polygon without holes
817  p->drawPolygon( points );
818  }
819  else
820  {
821  // polygon with holes must be drawn using painter path
822  QPainterPath path;
823  path.addPolygon( points );
824 
825  if ( rings )
826  {
827  for ( auto it = rings->constBegin(); it != rings->constEnd(); ++it )
828  {
829  QPolygonF ring = *it;
830  path.addPolygon( ring );
831  }
832  }
833 
834  p->drawPath( path );
835  }
836 }
837 
838 void QgsMarkerSymbolLayer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
839 {
840  QDomElement symbolizerElem = doc.createElement( QStringLiteral( "se:PointSymbolizer" ) );
841  if ( !props.value( QStringLiteral( "uom" ), QString() ).toString().isEmpty() )
842  symbolizerElem.setAttribute( QStringLiteral( "uom" ), props.value( QStringLiteral( "uom" ), QString() ).toString() );
843  element.appendChild( symbolizerElem );
844 
845  // <Geometry>
846  QgsSymbolLayerUtils::createGeometryElement( doc, symbolizerElem, props.value( QStringLiteral( "geom" ), QString() ).toString() );
847 
848  writeSldMarker( doc, symbolizerElem, props );
849 }
850 
851 QList<QgsSymbolLayerReference> QgsSymbolLayer::masks() const
852 {
853  return {};
854 }
855 
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:63
SymbolType
Symbol types.
Definition: qgis.h:169
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
static bool isGeneralizableByDeviceBoundingBox(const QgsRectangle &envelope, float mapToPixelTol=1.0f)
Returns whether the device-envelope can be replaced by its BBOX when is applied the specified toleran...
Exports QGIS layers to the DXF format.
Definition: qgsdxfexport.h:64
static double mapUnitScaleFactor(double scale, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
QgsUnitTypes::DistanceUnit mapUnits() const
Retrieve map units.
double symbologyScale() const
Returns the reference scale for output.
Definition: qgsdxfexport.h:228
Single scope for storing variables and functions for use within a QgsExpressionContext.
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
static const QString EXPR_GEOMETRY_RING_NUM
Inbuilt variable name for geometry ring number variable.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
bool isEmpty() const
Checks whether the container is empty.
Definition: qgsfields.cpp:128
virtual void renderPolygon(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)=0
Renders the fill symbol layer for the polygon whose outer ring is defined by points,...
void _renderPolygon(QPainter *p, const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Default method to render polygon.
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QgsFillSymbolLayer(const QgsFillSymbolLayer &other)=delete
QgsFillSymbolLayer cannot be copied.
QList< QList< QPolygonF > > toQPolygonF(Qgis::SymbolType type, QSizeF size) const
Converts the patch shape to a set of QPolygonF objects representing how the patch should be drawn for...
RenderRingFilter
Options for filtering rings when the line symbol layer is being used to render a polygon's rings.
@ ExteriorRingOnly
Render the exterior ring only.
@ InteriorRingsOnly
Render the interior rings only.
@ AllRings
Render both exterior and interior rings.
QgsMapUnitScale mWidthMapUnitScale
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
QgsUnitTypes::RenderUnit mWidthUnit
RenderRingFilter ringFilter() const
Returns the line symbol layer's ring filter, which controls which rings are rendered when the line sy...
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QgsLineSymbolLayer(const QgsLineSymbolLayer &other)=delete
QgsLineSymbolLayer cannot be copied.
virtual void renderPolygonStroke(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Renders the line symbol layer along the outline of polygon, using the given render context.
virtual void renderPolyline(const QPolygonF &points, QgsSymbolRenderContext &context)=0
Renders the line symbol layer along the line joining points, using the given render context.
RenderRingFilter mRingFilter
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QgsUnitTypes::RenderUnit widthUnit() const
Returns the units for the line's width.
virtual double width() const
Returns the estimated width for the line symbol layer.
double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets line width.
QgsMapUnitScale mapUnitScale() const override
void setRingFilter(QgsLineSymbolLayer::RenderRingFilter filter)
Sets the line symbol layer's ring filter, which controls which rings are rendered when the line symbo...
void setMapUnitScale(const QgsMapUnitScale &scale) override
double mapUnitsPerPixel() const
Returns current map units per pixel.
Struct for storing maximum and minimum scales for measurements in map units.
double mSize
Marker size.
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QPointF offset() const
Returns the marker's offset, which is the horizontal and vertical displacement which the rendered mar...
HorizontalAnchorPoint
Symbol horizontal anchor points.
@ Right
Align to right side of symbol.
@ HCenter
Align to horizontal center of symbol.
@ Left
Align to left side of symbol.
QgsUnitTypes::RenderUnit mOffsetUnit
Offset units.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
virtual void renderPoint(QPointF point, QgsSymbolRenderContext &context)=0
Renders a marker at the specified point.
QPointF mOffset
Marker offset.
QgsMapUnitScale mapUnitScale() const override
double size() const
Returns the symbol size.
QgsMapUnitScale mOffsetMapUnitScale
Offset map unit scale.
HorizontalAnchorPoint mHorizontalAnchorPoint
Horizontal anchor point.
QgsMarkerSymbolLayer(const QgsMarkerSymbolLayer &other)=delete
QgsMarkerSymbolLayer cannot be copied.
static QPointF _rotatedOffset(QPointF offset, double angle)
Adjusts a marker offset to account for rotation.
void stopRender(QgsSymbolRenderContext &context) override
Called after a set of rendering operations has finished on the supplied render context.
VerticalAnchorPoint verticalAnchorPoint() const
Returns the vertical anchor point for positioning the symbol.
QgsMapUnitScale mSizeMapUnitScale
Marker size map unit scale.
HorizontalAnchorPoint horizontalAnchorPoint() const
Returns the horizontal anchor point for positioning the symbol.
VerticalAnchorPoint
Symbol vertical anchor points.
@ VCenter
Align to vertical center of symbol.
@ Bottom
Align to bottom of symbol.
@ Top
Align to top of symbol.
void markerOffset(QgsSymbolRenderContext &context, double &offsetX, double &offsetY) const
Calculates the required marker offset, including both the symbol offset and any displacement required...
VerticalAnchorPoint mVerticalAnchorPoint
Vertical anchor point.
QgsUnitTypes::RenderUnit mSizeUnit
Marker size unit.
void toSld(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const override
Saves the symbol layer as SLD.
virtual void writeSldMarker(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const
Writes the symbol layer definition as a SLD XML element.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
void startRender(QgsSymbolRenderContext &context) override
Called before a set of rendering operations commences on the supplied render context.
double angle() const
Returns the rotation angle for the marker, in degrees clockwise from north.
void setMapUnitScale(const QgsMapUnitScale &scale) override
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.
bool enabled() const
Returns whether the effect is enabled.
QVariant value(int key, const QgsExpressionContext &context, const QVariant &defaultValue=QVariant()) const override
Returns the calculated value of the property with the specified key from within the collection.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext(), bool ignoreContext=false) const override
Returns the set of any fields referenced by the active properties from the collection.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
bool hasActiveProperties() const override
Returns true if the collection has any active properties, or false if all properties within the colle...
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const override
Prepares the collection against a specified expression context.
Definition for a property.
Definition: qgsproperty.h:48
@ HorizontalAnchor
Horizontal anchor point.
Definition: qgsproperty.h:76
@ Double
Double value (including negative values)
Definition: qgsproperty.h:58
@ VerticalAnchor
Vertical anchor point.
Definition: qgsproperty.h:77
@ Double0To1
Double value between 0-1 (inclusive)
Definition: qgsproperty.h:60
@ FillStyle
Fill style (eg solid, lines)
Definition: qgsproperty.h:74
@ StrokeWidth
Line stroke width.
Definition: qgsproperty.h:73
@ LineStyle
Line style (eg solid/dashed)
Definition: qgsproperty.h:72
@ String
Any string value.
Definition: qgsproperty.h:62
@ Boolean
Boolean value.
Definition: qgsproperty.h:54
@ PenJoinStyle
Pen join style.
Definition: qgsproperty.h:67
@ IntegerPositive
Positive integer values (including 0)
Definition: qgsproperty.h:56
@ Opacity
Opacity (0-100)
Definition: qgsproperty.h:63
@ CapStyle
Line cap style (eg round)
Definition: qgsproperty.h:75
@ Rotation
Rotation (value between 0-360 degrees)
Definition: qgsproperty.h:61
@ Size
1D size (eg marker radius, or square marker height/width)
Definition: qgsproperty.h:70
@ ColorWithAlpha
Color with alpha channel.
Definition: qgsproperty.h:65
@ DoublePositive
Positive double value (including 0)
Definition: qgsproperty.h:59
@ DataTypeString
Property requires a string value.
Definition: qgsproperty.h:93
@ DataTypeNumeric
Property requires a numeric value.
Definition: qgsproperty.h:100
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.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
Contains information about the context of a rendering operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
Flags flags() const
Returns combination of flags used for rendering.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to painter units (pixels).
const QgsVectorSimplifyMethod & vectorSimplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
static QgsStyle * defaultStyle()
Returns default application-wide style.
Definition: qgsstyle.cpp:131
QList< QList< QPolygonF > > defaultPatchAsQPolygonF(Qgis::SymbolType type, QSizeF size) const
Returns the default patch geometry for the given symbol type and size as a set of QPolygonF objects (...
Definition: qgsstyle.cpp:1215
static QPointF toPoint(const QVariant &value, bool *ok=nullptr)
Converts a value to a point.
static void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
static QString encodePoint(QPointF point)
Encodes a QPointF to a string.
Property
Data definable properties.
@ PropertyGradientReference1X
Gradient reference point 1 x.
@ PropertyShapeburstIgnoreRings
Shapeburst ignore rings.
@ PropertyGradientReference2X
Gradient reference point 2 x.
@ PropertyStrokeStyle
Stroke style (eg solid, dashed)
@ PropertyPlacement
Line marker placement.
@ PropertyHorizontalAnchor
Horizontal anchor point.
@ PropertyPreserveAspectRatio
Preserve aspect ratio between width and height.
@ PropertyDistanceX
Horizontal distance between points.
@ PropertyFile
Filename, eg for svg files.
@ PropertyGradientType
Gradient fill type.
@ PropertyCapStyle
Line cap style.
@ PropertyAngle
Symbol angle.
@ PropertyDistanceY
Vertical distance between points.
@ PropertyDisplacementX
Horizontal displacement.
@ PropertyVerticalAnchor
Vertical anchor point.
@ PropertyGradientSpread
Gradient spread mode.
@ PropertyOffsetY
Vertical offset.
@ PropertyGradientReference1Y
Gradient reference point 1 y.
@ PropertyLineDistance
Distance between lines, or length of lines for hash line symbols.
@ PropertyOffsetAlongLine
Offset along line.
@ PropertyArrowStartWidth
Arrow tail start width.
@ PropertyBlurRadius
Shapeburst blur radius.
@ PropertyGradientReference2Y
Gradient reference point 2 y.
@ PropertyArrowHeadLength
Arrow head length.
@ PropertyGradientReference1IsCentroid
Gradient reference point 1 is centroid.
@ PropertyCustomDash
Custom dash pattern.
@ PropertyShapeburstUseWholeShape
Shapeburst use whole shape.
@ PropertySize
Symbol size.
@ PropertyArrowHeadThickness
Arrow head thickness.
@ PropertyOffsetX
Horizontal offset.
@ PropertyJoinStyle
Line join style.
@ PropertyTrimEnd
Trim distance from end of line (since QGIS 3.20)
@ PropertyOpacity
Opacity.
@ PropertySecondaryColor
Secondary color (eg for gradient fills)
@ PropertyCharacter
Character, eg for font marker symbol layers.
@ PropertyCoordinateMode
Gradient coordinate mode.
@ PropertyLineAngle
Line angle, or angle of hash lines for hash line symbols.
@ PropertyShapeburstMaxDistance
Shapeburst fill from edge distance.
@ PropertyTrimStart
Trim distance from start of line (since QGIS 3.20)
@ PropertyOffset
Symbol offset.
@ PropertyStrokeWidth
Stroke width.
@ PropertyDashPatternOffset
Dash pattern offset,.
@ PropertyFillColor
Fill color.
@ PropertyArrowHeadType
Arrow head type.
@ PropertyFontStyle
Font style.
@ PropertyHeight
Symbol height.
@ PropertyClipPoints
Whether markers should be clipped to polygon boundaries.
@ PropertyFontFamily
Font family.
@ PropertyPointCount
Point count.
@ PropertyRandomSeed
Random number seed.
@ PropertyLayerEnabled
Whether symbol layer is enabled.
@ PropertyName
Name, eg shape name for simple markers.
@ PropertyAverageAngleLength
Length to average symbol angles over.
@ PropertyInterval
Line marker interval.
@ PropertyFillStyle
Fill style (eg solid, dots)
@ PropertyArrowType
Arrow type.
@ PropertyDisplacementY
Vertical displacement.
@ PropertyStrokeColor
Stroke color.
@ PropertyGradientReference2IsCentroid
Gradient reference point 2 is centroid.
@ PropertyArrowWidth
Arrow tail width.
@ PropertyWidth
Symbol width.
QgsFields mFields
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
Qgis::SymbolType type() const
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
virtual double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
virtual QColor color() const
The fill color.
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
Qgis::SymbolType mType
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 setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the layer.
void setRenderingPass(int renderingPass)
Specifies the rendering pass in which this symbol layer should be rendered.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.
virtual QVector< qreal > dxfCustomDashPattern(QgsUnitTypes::RenderUnit &unit) const
Gets dash pattern.
QgsSymbolLayer(const QgsSymbolLayer &other)=delete
QgsSymbolLayer cannot be copied.
std::unique_ptr< QgsPaintEffect > mPaintEffect
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual void prepareExpressions(const QgsSymbolRenderContext &context)
Prepares all data defined property expressions for evaluation.
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
int renderingPass() const
Specifies the rendering pass in which this symbol layer should be rendered.
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.
virtual bool isCompatibleWithSymbol(QgsSymbol *symbol) const
Returns if the layer can be used below the specified symbol.
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
static const QgsPropertiesDefinition & propertyDefinitions()
Returns the symbol layer property definitions.
virtual double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
virtual ~QgsSymbolLayer()
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
virtual bool writeDxf(QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift=QPointF(0.0, 0.0)) const
write as DXF
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
QgsPropertyCollection mDataDefinedProperties
virtual QList< QgsSymbolLayerReference > masks() const
Returns masks defined by this symbol layer.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the symbol layer's property collection, used for data defined overrides.
QgsFields fields() const
Fields of the layer.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
const QgsLegendPatchShape * patchShape() const
Returns the symbol patch shape, to use if rendering symbol preview icons.
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:38
Qgis::SymbolType type() const
Returns the symbol's type.
Definition: qgssymbol.h:97
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
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
SimplifyHints simplifyHints() const
Gets the simplification hints of the vector layer managed.
float threshold() const
Gets the simplification threshold of the vector layer managed.
@ AntialiasingSimplification
The geometries can be rendered with 'AntiAliasing' disabled because of it is '1-pixel size'.
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
#define str(x)
Definition: qgis.cpp:37
#define DEG2RAD(x)
const QgsField & field
Definition: qgsfield.h:463
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
QgsProperty propertyFromMap(const QVariantMap &map, const QString &baseName)
Single variable definition for use within a QgsExpressionContextScope.