QGIS API Documentation  3.23.0-Master (7c4a6de034)
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>innervertices</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::Double, 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  { QgsSymbolLayer::PropertyLineStartWidthValue, QgsPropertyDefinition( "lineStartWidthValue", QObject::tr( "Line start width value" ), QgsPropertyDefinition::Double, origin )},
116  { QgsSymbolLayer::PropertyLineEndWidthValue, QgsPropertyDefinition( "lineEndWidthValue", QObject::tr( "Line end width value" ), QgsPropertyDefinition::Double, origin )},
117  { QgsSymbolLayer::PropertyLineStartColorValue, QgsPropertyDefinition( "lineStartColorValue", QObject::tr( "Line start color value" ), QgsPropertyDefinition::Double, origin )},
118  { QgsSymbolLayer::PropertyLineEndColorValue, QgsPropertyDefinition( "lineEndColorValue", QObject::tr( "Line end color value" ), QgsPropertyDefinition::Double, origin )},
119  { QgsSymbolLayer::PropertyMarkerClipping, QgsPropertyDefinition( "markerClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Marker clipping mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>no</b>|<b>shape</b>|<b>centroid_within</b>|<b>completely_within</b>]" ), origin )},
120  { QgsSymbolLayer::PropertyRandomOffsetX, QgsPropertyDefinition( "randomOffsetX", QObject::tr( "Horizontal random offset" ), QgsPropertyDefinition::Double, origin )},
121  { QgsSymbolLayer::PropertyRandomOffsetY, QgsPropertyDefinition( "randomOffsetY", QObject::tr( "Vertical random offset" ), QgsPropertyDefinition::Double, origin )},
122  { QgsSymbolLayer::PropertyLineClipping, QgsPropertyDefinition( "lineClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line clipping mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>no</b>|<b>during_render</b>|<b>before_render</b>]" ), origin )},
123  };
124 }
125 
127 {
128  dataDefinedProperties().setProperty( key, property );
129 }
130 
132 {
133  if ( QgsSymbol *lSubSymbol = subSymbol() )
134  lSubSymbol->startFeatureRender( feature, context );
135 }
136 
138 {
139  if ( QgsSymbol *lSubSymbol = subSymbol() )
140  lSubSymbol->stopFeatureRender( feature, context );
141 }
142 
144 {
145  return nullptr;
146 }
147 
149 {
150  delete symbol;
151  return false;
152 }
153 
154 bool QgsSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const
155 {
156  Q_UNUSED( e )
157  Q_UNUSED( mmMapUnitScaleFactor )
158  Q_UNUSED( layerName )
159  Q_UNUSED( context )
160  Q_UNUSED( shift )
161  return false;
162 }
163 
165 {
166  Q_UNUSED( e )
167  Q_UNUSED( context )
168  return 1.0;
169 }
170 
172 {
173  Q_UNUSED( e )
174  Q_UNUSED( context )
175  return 0.0;
176 }
177 
179 {
180  Q_UNUSED( context )
181  return color();
182 }
183 
185 {
186  Q_UNUSED( context )
187  return 0.0;
188 }
189 
191 {
192  Q_UNUSED( unit )
193  return QVector<qreal>();
194 }
195 
196 Qt::PenStyle QgsSymbolLayer::dxfPenStyle() const
197 {
198  return Qt::SolidLine;
199 }
200 
202 {
203  Q_UNUSED( context )
204  return color();
205 }
206 
207 Qt::BrushStyle QgsSymbolLayer::dxfBrushStyle() const
208 {
209  return Qt::NoBrush;
210 }
211 
213 {
214  return mPaintEffect.get();
215 }
216 
218 {
219  if ( effect == mPaintEffect.get() )
220  return;
221 
222  mPaintEffect.reset( effect );
223 }
224 
226  : mType( type )
227  , mLocked( locked )
228 {
229 }
230 
231 Qgis::SymbolLayerFlags QgsSymbolLayer::flags() const
232 {
233  return Qgis::SymbolLayerFlags();
234 }
235 
237 {
239 
240  if ( !context.fields().isEmpty() )
241  {
242  //QgsFields is implicitly shared, so it's cheap to make a copy
243  mFields = context.fields();
244  }
245 }
246 
248 {
250 }
251 
253 {
254  QgsSymbolLayer::initPropertyDefinitions();
255  return sPropertyDefinitions;
256 }
257 
259 
261 {
262  if ( symbol->type() == Qgis::SymbolType::Fill && mType == Qgis::SymbolType::Line )
263  return true;
264 
265  return symbol->type() == mType;
266 }
267 
269 {
270  return false;
271 }
272 
274 {
275  return false;
276 }
277 
278 void QgsSymbolLayer::setRenderingPass( int renderingPass )
279 {
281 }
282 
284 {
285  return mRenderingPass;
286 }
287 
288 QSet<QString> QgsSymbolLayer::usedAttributes( const QgsRenderContext &context ) const
289 {
290  // calling referencedFields() with ignoreContext=true because in our expression context
291  // we do not have valid QgsFields yet - because of that the field names from expressions
292  // wouldn't get reported
293  QSet<QString> columns = mDataDefinedProperties.referencedFields( context.expressionContext(), true );
294  return columns;
295 }
296 
297 QgsProperty propertyFromMap( const QVariantMap &map, const QString &baseName )
298 {
299  QString prefix;
300  if ( !baseName.isEmpty() )
301  {
302  prefix.append( QStringLiteral( "%1_dd_" ).arg( baseName ) );
303  }
304 
305  if ( !map.contains( QStringLiteral( "%1expression" ).arg( prefix ) ) )
306  {
307  //requires at least the expression value
308  return QgsProperty();
309  }
310 
311  bool active = ( map.value( QStringLiteral( "%1active" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
312  QString expression = map.value( QStringLiteral( "%1expression" ).arg( prefix ) ).toString();
313  bool useExpression = ( map.value( QStringLiteral( "%1useexpr" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
314  QString field = map.value( QStringLiteral( "%1field" ).arg( prefix ), QString() ).toString();
315 
316  if ( useExpression )
317  return QgsProperty::fromExpression( expression, active );
318  else
319  return QgsProperty::fromField( field, active );
320 }
321 
322 void QgsSymbolLayer::restoreOldDataDefinedProperties( const QVariantMap &stringMap )
323 {
324  // property string to type upgrade map
325  static const QMap< QString, QgsSymbolLayer::Property > OLD_PROPS
326  {
328  { "arrow_width", QgsSymbolLayer::PropertyArrowWidth },
329  { "arrow_start_width", QgsSymbolLayer::PropertyArrowStartWidth },
330  { "head_length", QgsSymbolLayer::PropertyArrowHeadLength },
331  { "head_thickness", QgsSymbolLayer::PropertyArrowHeadThickness },
332  { "offset", QgsSymbolLayer::PropertyOffset },
333  { "head_type", QgsSymbolLayer::PropertyArrowHeadType },
334  { "arrow_type", QgsSymbolLayer::PropertyArrowType },
335  { "width_field", QgsSymbolLayer::PropertyWidth },
336  { "height_field", QgsSymbolLayer::PropertyHeight },
337  { "rotation_field", QgsSymbolLayer::PropertyAngle },
338  { "outline_width_field", QgsSymbolLayer::PropertyStrokeWidth },
339  { "fill_color_field", QgsSymbolLayer::PropertyFillColor },
340  { "outline_color_field", QgsSymbolLayer::PropertyStrokeColor },
341  { "symbol_name_field", QgsSymbolLayer::PropertyName },
342  { "outline_width", QgsSymbolLayer::PropertyStrokeWidth },
343  { "outline_style", QgsSymbolLayer::PropertyStrokeStyle },
344  { "join_style", QgsSymbolLayer::PropertyJoinStyle },
345  { "fill_color", QgsSymbolLayer::PropertyFillColor },
346  { "outline_color", QgsSymbolLayer::PropertyStrokeColor },
347  { "width", QgsSymbolLayer::PropertyWidth },
348  { "height", QgsSymbolLayer::PropertyHeight },
349  { "symbol_name", QgsSymbolLayer::PropertyName },
350  { "angle", QgsSymbolLayer::PropertyAngle },
351  { "fill_style", QgsSymbolLayer::PropertyFillStyle },
352  { "color_border", QgsSymbolLayer::PropertyStrokeColor },
353  { "width_border", QgsSymbolLayer::PropertyStrokeWidth },
354  { "border_color", QgsSymbolLayer::PropertyStrokeColor },
355  { "border_style", QgsSymbolLayer::PropertyStrokeStyle },
357  { "gradient_type", QgsSymbolLayer::PropertyGradientType },
358  { "coordinate_mode", QgsSymbolLayer::PropertyCoordinateMode },
364  { "reference1_iscentroid", QgsSymbolLayer::PropertyGradientReference1IsCentroid },
365  { "reference2_iscentroid", QgsSymbolLayer::PropertyGradientReference2IsCentroid },
366  { "blur_radius", QgsSymbolLayer::PropertyBlurRadius },
370  { "svgFillColor", QgsSymbolLayer::PropertyFillColor },
371  { "svgOutlineColor", QgsSymbolLayer::PropertyStrokeColor },
372  { "svgOutlineWidth", QgsSymbolLayer::PropertyStrokeWidth },
373  { "svgFile", QgsSymbolLayer::PropertyFile },
374  { "lineangle", QgsSymbolLayer::PropertyLineAngle },
375  { "distance", QgsSymbolLayer::PropertyLineDistance },
376  { "distance_x", QgsSymbolLayer::PropertyDistanceX },
377  { "distance_y", QgsSymbolLayer::PropertyDistanceY },
378  { "displacement_x", QgsSymbolLayer::PropertyDisplacementX },
379  { "displacement_y", QgsSymbolLayer::PropertyDisplacementY },
380  { "file", QgsSymbolLayer::PropertyFile },
381  { "alpha", QgsSymbolLayer::PropertyOpacity },
382  { "customdash", QgsSymbolLayer::PropertyCustomDash },
383  { "line_style", QgsSymbolLayer::PropertyStrokeStyle },
384  { "joinstyle", QgsSymbolLayer::PropertyJoinStyle },
385  { "capstyle", QgsSymbolLayer::PropertyCapStyle },
386  { "placement", QgsSymbolLayer::PropertyPlacement },
387  { "interval", QgsSymbolLayer::PropertyInterval },
388  { "offset_along_line", QgsSymbolLayer::PropertyOffsetAlongLine },
389  { "name", QgsSymbolLayer::PropertyName },
390  { "size", QgsSymbolLayer::PropertySize },
395  { "rotation", QgsSymbolLayer::PropertyAngle },
396  { "horizontal_anchor_point", QgsSymbolLayer::PropertyHorizontalAnchor },
397  { "vertical_anchor_point", QgsSymbolLayer::PropertyVerticalAnchor },
398  };
399 
400  QVariantMap::const_iterator propIt = stringMap.constBegin();
401  for ( ; propIt != stringMap.constEnd(); ++propIt )
402  {
403  std::unique_ptr<QgsProperty> prop;
404  QString propertyName;
405 
406  if ( propIt.key().endsWith( QLatin1String( "_dd_expression" ) ) )
407  {
408  //found a data defined property
409 
410  //get data defined property name by stripping "_dd_expression" from property key
411  propertyName = propIt.key().left( propIt.key().length() - 14 );
412 
413  prop = std::make_unique<QgsProperty>( propertyFromMap( stringMap, propertyName ) );
414  }
415  else if ( propIt.key().endsWith( QLatin1String( "_expression" ) ) )
416  {
417  //old style data defined property, upgrade
418 
419  //get data defined property name by stripping "_expression" from property key
420  propertyName = propIt.key().left( propIt.key().length() - 11 );
421 
422  prop = std::make_unique<QgsProperty>( QgsProperty::fromExpression( propIt.value().toString() ) );
423  }
424 
425  if ( !prop || !OLD_PROPS.contains( propertyName ) )
426  continue;
427 
428  QgsSymbolLayer::Property key = static_cast< QgsSymbolLayer::Property >( OLD_PROPS.value( propertyName ) );
429 
430  if ( type() == Qgis::SymbolType::Line )
431  {
432  //these keys had different meaning for line symbol layers
433  if ( propertyName == QLatin1String( "width" ) )
435  else if ( propertyName == QLatin1String( "color" ) )
437  }
438 
439  setDataDefinedProperty( key, QgsProperty( *prop.get() ) );
440  }
441 }
442 
444 {
445  if ( !destLayer )
446  return;
447 
449 }
450 
452 {
453  if ( !destLayer || !mPaintEffect )
454  return;
455 
457  destLayer->setPaintEffect( mPaintEffect->clone() );
458  else
459  destLayer->setPaintEffect( nullptr );
460 }
461 
463  : QgsSymbolLayer( Qgis::SymbolType::Marker, locked )
464 {
465 
466 }
467 
469  : QgsSymbolLayer( Qgis::SymbolType::Line, locked )
470 {
471 }
472 
474 {
475  return mRingFilter;
476 }
477 
479 {
480  mRingFilter = filter;
481 }
482 
484  : QgsSymbolLayer( Qgis::SymbolType::Fill, locked )
485 {
486 }
487 
489 {
490  Q_UNUSED( context )
491 }
492 
494 {
495  Q_UNUSED( context )
496 }
497 
499 {
500  startRender( context );
501  QgsPaintEffect *effect = paintEffect();
502 
503  QPolygonF points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 )
505 
506  std::unique_ptr< QgsEffectPainter > effectPainter;
507  if ( effect && effect->enabled() )
508  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
509 
510  for ( QPointF point : std::as_const( points ) )
511  renderPoint( point, context );
512 
513  effectPainter.reset();
514 
515  stopRender( context );
516 }
517 
518 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const
519 {
521 }
522 
523 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const
524 {
525  markerOffset( context, width, height, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );
526 }
527 
528 void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height,
530  double &offsetX, double &offsetY, const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const
531 {
532  offsetX = mOffset.x();
533  offsetY = mOffset.y();
534 
536  {
539  bool ok = false;
540  const QPointF offset = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
541  if ( ok )
542  {
543  offsetX = offset.x();
544  offsetY = offset.y();
545  }
546  }
547 
548  offsetX = context.renderContext().convertToPainterUnits( offsetX, mOffsetUnit, mOffsetMapUnitScale );
549  offsetY = context.renderContext().convertToPainterUnits( offsetY, mOffsetUnit, mOffsetMapUnitScale );
550 
554  {
556  if ( !exprVal.isNull() )
557  {
558  horizontalAnchorPoint = decodeHorizontalAnchorPoint( exprVal.toString() );
559  }
560  }
562  {
564  if ( !exprVal.isNull() )
565  {
566  verticalAnchorPoint = decodeVerticalAnchorPoint( exprVal.toString() );
567  }
568  }
569 
570  //correct horizontal position according to anchor point
572  {
573  return;
574  }
575 
576  double anchorPointCorrectionX = context.renderContext().convertToPainterUnits( width, widthUnit, widthMapUnitScale ) / 2.0;
578  {
579  // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
580  // and clamp it to a reasonable range. It's the best we can do in this situation!
581  anchorPointCorrectionX = std::min( std::max( context.renderContext().convertToPainterUnits( width, QgsUnitTypes::RenderMillimeters ), 3.0 ), 100.0 ) / 2.0;
582  }
583 
584  double anchorPointCorrectionY = context.renderContext().convertToPainterUnits( height, heightUnit, heightMapUnitScale ) / 2.0;
586  {
587  // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
588  // and clamp it to a reasonable range. It's the best we can do in this situation!
589  anchorPointCorrectionY = std::min( std::max( context.renderContext().convertToPainterUnits( height, QgsUnitTypes::RenderMillimeters ), 3.0 ), 100.0 ) / 2.0;
590  }
591 
592  if ( horizontalAnchorPoint == Left )
593  {
594  offsetX += anchorPointCorrectionX;
595  }
596  else if ( horizontalAnchorPoint == Right )
597  {
598  offsetX -= anchorPointCorrectionX;
599  }
600 
601  //correct vertical position according to anchor point
602  if ( verticalAnchorPoint == Top )
603  {
604  offsetY += anchorPointCorrectionY;
605  }
606  else if ( verticalAnchorPoint == Bottom )
607  {
608  offsetY -= anchorPointCorrectionY;
609  }
610 }
611 
612 QPointF QgsMarkerSymbolLayer::_rotatedOffset( QPointF offset, double angle )
613 {
614  angle = DEG2RAD( angle );
615  double c = std::cos( angle ), s = std::sin( angle );
616  return QPointF( offset.x() * c - offset.y() * s, offset.x() * s + offset.y() * c );
617 }
618 
619 QgsMarkerSymbolLayer::HorizontalAnchorPoint QgsMarkerSymbolLayer::decodeHorizontalAnchorPoint( const QString &str )
620 {
621  if ( str.compare( QLatin1String( "left" ), Qt::CaseInsensitive ) == 0 )
622  {
624  }
625  else if ( str.compare( QLatin1String( "right" ), Qt::CaseInsensitive ) == 0 )
626  {
628  }
629  else
630  {
632  }
633 }
634 
635 QgsMarkerSymbolLayer::VerticalAnchorPoint QgsMarkerSymbolLayer::decodeVerticalAnchorPoint( const QString &str )
636 {
637  if ( str.compare( QLatin1String( "top" ), Qt::CaseInsensitive ) == 0 )
638  {
640  }
641  else if ( str.compare( QLatin1String( "bottom" ), Qt::CaseInsensitive ) == 0 )
642  {
644  }
645  else
646  {
648  }
649 }
650 
652 {
653  mSizeUnit = unit;
654  mOffsetUnit = unit;
655 }
656 
658 {
659  if ( mOffsetUnit != mSizeUnit )
660  {
662  }
663  return mOffsetUnit;
664 }
665 
667 {
668  mSizeMapUnitScale = scale;
669  mOffsetMapUnitScale = scale;
670 }
671 
673 {
675  {
676  return mSizeMapUnitScale;
677  }
678  return QgsMapUnitScale();
679 }
680 
682 {
683  mWidthUnit = unit;
684 }
685 
687 {
688  return mWidthUnit;
689 }
690 
692 {
693  mWidthMapUnitScale = scale;
694 }
695 
697 {
698  return mWidthMapUnitScale;
699 }
700 
701 
703 {
704  const QList< QList< QPolygonF > > points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Line, size )
706  startRender( context );
707  QgsPaintEffect *effect = paintEffect();
708 
709  std::unique_ptr< QgsEffectPainter > effectPainter;
710  if ( effect && effect->enabled() )
711  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
712 
713  for ( const QList< QPolygonF > &line : points )
714  renderPolyline( line.value( 0 ), context );
715 
716  effectPainter.reset();
717 
718  stopRender( context );
719 }
720 
721 void QgsLineSymbolLayer::renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
722 {
723  QgsExpressionContextScope *scope = nullptr;
724  std::unique_ptr< QgsExpressionContextScopePopper > scopePopper;
725  if ( hasDataDefinedProperties() )
726  {
727  scope = new QgsExpressionContextScope();
728  scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.renderContext().expressionContext(), scope );
729  }
730 
731  switch ( mRingFilter )
732  {
733  case AllRings:
734  case ExteriorRingOnly:
735  {
736  if ( scope )
738  renderPolyline( points, context );
739  break;
740  }
741  case InteriorRingsOnly:
742  break;
743  }
744 
745  if ( rings )
746  {
747  switch ( mRingFilter )
748  {
749  case AllRings:
750  case InteriorRingsOnly:
751  {
752  int ringIndex = 1;
753  for ( const QPolygonF &ring : std::as_const( *rings ) )
754  {
755  if ( scope )
757 
758  renderPolyline( ring, context );
759  ringIndex++;
760  }
761  }
762  break;
763  case ExteriorRingOnly:
764  break;
765  }
766  }
767 }
768 
769 double QgsLineSymbolLayer::width( const QgsRenderContext &context ) const
770 {
772 }
773 
775 {
776  Q_UNUSED( context )
778 }
779 
780 
782 {
783  const QList< QList< QPolygonF > > polys = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Fill, size )
785 
786  startRender( context );
787  QgsPaintEffect *effect = paintEffect();
788 
789  std::unique_ptr< QgsEffectPainter > effectPainter;
790  if ( effect && effect->enabled() )
791  effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
792 
793  for ( const QList< QPolygonF > &poly : polys )
794  {
795  QVector< QPolygonF > rings;
796  for ( int i = 1; i < poly.size(); ++i )
797  rings << poly.at( i );
798  renderPolygon( poly.value( 0 ), &rings, context );
799  }
800 
801  effectPainter.reset();
802 
803  stopRender( context );
804 }
805 
806 void QgsFillSymbolLayer::_renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
807 {
808  if ( !p )
809  {
810  return;
811  }
812 
813  // Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #5 points).
814  if ( points.size() <= 5 &&
817  ( p->renderHints() & QPainter::Antialiasing ) )
818  {
819  p->setRenderHint( QPainter::Antialiasing, false );
820  p->drawRect( points.boundingRect() );
821  p->setRenderHint( QPainter::Antialiasing, true );
822  return;
823  }
824 
825  // polygons outlines are sometimes rendered wrongly with drawPolygon, when
826  // clipped (see #13343), so use drawPath instead.
827  if ( !rings && p->pen().style() == Qt::NoPen )
828  {
829  // simple polygon without holes
830  p->drawPolygon( points );
831  }
832  else
833  {
834  // polygon with holes must be drawn using painter path
835  QPainterPath path;
836  path.addPolygon( points );
837 
838  if ( rings )
839  {
840  for ( auto it = rings->constBegin(); it != rings->constEnd(); ++it )
841  {
842  QPolygonF ring = *it;
843  path.addPolygon( ring );
844  }
845  }
846 
847  p->drawPath( path );
848  }
849 }
850 
851 void QgsMarkerSymbolLayer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
852 {
853  QDomElement symbolizerElem = doc.createElement( QStringLiteral( "se:PointSymbolizer" ) );
854  if ( !props.value( QStringLiteral( "uom" ), QString() ).toString().isEmpty() )
855  symbolizerElem.setAttribute( QStringLiteral( "uom" ), props.value( QStringLiteral( "uom" ), QString() ).toString() );
856  element.appendChild( symbolizerElem );
857 
858  // <Geometry>
859  QgsSymbolLayerUtils::createGeometryElement( doc, symbolizerElem, props.value( QStringLiteral( "geom" ), QString() ).toString() );
860 
861  writeSldMarker( doc, symbolizerElem, props );
862 }
863 
864 QList<QgsSymbolLayerReference> QgsSymbolLayer::masks() const
865 {
866  return {};
867 }
868 
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:64
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
SymbolType
Symbol types.
Definition: qgis.h:183
@ 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:65
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:229
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 the 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:47
@ HorizontalAnchor
Horizontal anchor point.
Definition: qgsproperty.h:75
@ Double
Double value (including negative values)
Definition: qgsproperty.h:57
@ VerticalAnchor
Vertical anchor point.
Definition: qgsproperty.h:76
@ Double0To1
Double value between 0-1 (inclusive)
Definition: qgsproperty.h:59
@ FillStyle
Fill style (eg solid, lines)
Definition: qgsproperty.h:73
@ StrokeWidth
Line stroke width.
Definition: qgsproperty.h:72
@ LineStyle
Line style (eg solid/dashed)
Definition: qgsproperty.h:71
@ String
Any string value.
Definition: qgsproperty.h:61
@ Boolean
Boolean value.
Definition: qgsproperty.h:53
@ PenJoinStyle
Pen join style.
Definition: qgsproperty.h:66
@ IntegerPositive
Positive integer values (including 0)
Definition: qgsproperty.h:55
@ Opacity
Opacity (0-100)
Definition: qgsproperty.h:62
@ CapStyle
Line cap style (eg round)
Definition: qgsproperty.h:74
@ Rotation
Rotation (value between 0-360 degrees)
Definition: qgsproperty.h:60
@ Size
1D size (eg marker radius, or square marker height/width)
Definition: qgsproperty.h:69
@ ColorWithAlpha
Color with alpha channel.
Definition: qgsproperty.h:64
@ DoublePositive
Positive double value (including 0)
Definition: qgsproperty.h:58
@ DataTypeString
Property requires a string value.
Definition: qgsproperty.h:92
@ DataTypeNumeric
Property requires a numeric value.
Definition: qgsproperty.h:99
A store for object properties.
Definition: qgsproperty.h:231
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...
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).
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
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.
@ PropertyLineEndWidthValue
End line width for interpolated line renderer (since QGIS 3.22)
@ PropertyLineEndColorValue
End line color for interpolated line renderer (since QGIS 3.22)
@ PropertyAngle
Symbol angle.
@ PropertyLineClipping
Line clipping mode (since QGIS 3.24)
@ 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.
@ PropertyLineStartColorValue
Start line color for interpolated line renderer (since QGIS 3.22)
@ PropertyArrowStartWidth
Arrow tail start width.
@ PropertyBlurRadius
Shapeburst blur radius.
@ PropertyGradientReference2Y
Gradient reference point 2 y.
@ PropertyMarkerClipping
Marker clipping mode (since QGIS 3.24)
@ 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.
@ PropertyLineStartWidthValue
Start line width for interpolated line renderer (since QGIS 3.22)
@ 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.
@ PropertyRandomOffsetY
Random offset Y (since QGIS 3.24)
@ 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.
@ PropertyRandomOffsetX
Random offset X (since QGIS 3.24)
@ 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.
virtual Qgis::SymbolLayerFlags flags() const
Returns flags which control the symbol layer's behavior.
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.