QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
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 "qgsrendercontext.h"
18#include "qgsdxfexport.h"
20#include "qgspainteffect.h"
22#include "qgsproperty.h"
24#include "qgssymbollayerutils.h"
25#include "qgslegendpatchshape.h"
26#include "qgsstyle.h"
28#include "qgssymbol.h"
30#include "qgsgeos.h"
31
32#include <QSize>
33#include <QPainter>
34#include <QPointF>
35#include <QPolygonF>
36#include <QUuid>
37
38QgsPropertiesDefinition QgsSymbolLayer::sPropertyDefinitions;
39
40void QgsSymbolLayer::initPropertyDefinitions()
41{
42 if ( !sPropertyDefinitions.isEmpty() )
43 return;
44
45 QString origin = QStringLiteral( "symbol" );
46
47 sPropertyDefinitions = QgsPropertiesDefinition
48 {
49 { static_cast< int >( QgsSymbolLayer::Property::Size ), QgsPropertyDefinition( "size", QObject::tr( "Symbol size" ), QgsPropertyDefinition::Size, origin ) },
50 { static_cast< int >( QgsSymbolLayer::Property::Angle ), QgsPropertyDefinition( "angle", QObject::tr( "Rotation angle" ), QgsPropertyDefinition::Rotation, origin ) },
51 { static_cast< int >( QgsSymbolLayer::Property::Name ), QgsPropertyDefinition( "name", QObject::tr( "Symbol name" ), QgsPropertyDefinition::String, origin ) },
52 { static_cast< int >( QgsSymbolLayer::Property::FillColor ), QgsPropertyDefinition( "fillColor", QObject::tr( "Symbol fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
53 { static_cast< int >( QgsSymbolLayer::Property::StrokeColor ), QgsPropertyDefinition( "outlineColor", QObject::tr( "Symbol stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
54 { static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ), QgsPropertyDefinition( "outlineWidth", QObject::tr( "Symbol stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },
55 { static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ), QgsPropertyDefinition( "outlineStyle", QObject::tr( "Symbol stroke style" ), QgsPropertyDefinition::LineStyle, origin )},
56 { static_cast< int >( QgsSymbolLayer::Property::Offset ), QgsPropertyDefinition( "offset", QObject::tr( "Symbol offset" ), QgsPropertyDefinition::Offset, origin )},
57 { static_cast< int >( QgsSymbolLayer::Property::Character ), QgsPropertyDefinition( "char", QObject::tr( "Marker character(s)" ), QgsPropertyDefinition::String, origin )},
58 { static_cast< int >( QgsSymbolLayer::Property::FontFamily ), QgsPropertyDefinition( "fontFamily", QObject::tr( "Font family" ), QgsPropertyDefinition::String, origin )},
59 { static_cast< int >( QgsSymbolLayer::Property::FontStyle ), QgsPropertyDefinition( "fontStyle", QObject::tr( "Font style" ), QgsPropertyDefinition::String, origin )},
60 { static_cast< int >( QgsSymbolLayer::Property::Width ), QgsPropertyDefinition( "width", QObject::tr( "Symbol width" ), QgsPropertyDefinition::DoublePositive, origin )},
61 { static_cast< int >( QgsSymbolLayer::Property::Height ), QgsPropertyDefinition( "height", QObject::tr( "Symbol height" ), QgsPropertyDefinition::DoublePositive, origin )},
62 { static_cast< int >( QgsSymbolLayer::Property::PreserveAspectRatio ), QgsPropertyDefinition( "preserveAspectRatio", QObject::tr( "Preserve aspect ratio between width and height" ), QgsPropertyDefinition::Boolean, origin )},
63 { static_cast< int >( QgsSymbolLayer::Property::FillStyle ), QgsPropertyDefinition( "fillStyle", QObject::tr( "Symbol fill style" ), QgsPropertyDefinition::FillStyle, origin )},
64 { static_cast< int >( QgsSymbolLayer::Property::JoinStyle ), QgsPropertyDefinition( "joinStyle", QObject::tr( "Outline join style" ), QgsPropertyDefinition::PenJoinStyle, origin )},
65 { static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ), QgsPropertyDefinition( "color2", QObject::tr( "Secondary fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin )},
66 { static_cast< int >( QgsSymbolLayer::Property::LineAngle ), QgsPropertyDefinition( "lineAngle", QObject::tr( "Angle for line fills" ), QgsPropertyDefinition::Rotation, origin )},
67 { static_cast< int >( QgsSymbolLayer::Property::GradientType ), QgsPropertyDefinition( "gradientType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient type" ), QObject::tr( "string " ) + QLatin1String( "[<b>linear</b>|<b>radial</b>|<b>conical</b>]" ), origin )},
68 { static_cast< int >( QgsSymbolLayer::Property::CoordinateMode ), QgsPropertyDefinition( "gradientMode", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>feature</b>|<b>viewport</b>]" ), origin )},
69 { static_cast< int >( QgsSymbolLayer::Property::GradientSpread ), QgsPropertyDefinition( "gradientSpread", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient spread" ), QObject::tr( "string " ) + QLatin1String( "[<b>pad</b>|<b>repeat</b>|<b>reflect</b>]" ), origin )},
70 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ), QgsPropertyDefinition( "gradientRef1X", QObject::tr( "Reference point 1 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
71 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ), QgsPropertyDefinition( "gradientRef1Y", QObject::tr( "Reference point 1 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
72 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ), QgsPropertyDefinition( "gradientRef2X", QObject::tr( "Reference point 2 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
73 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y ), QgsPropertyDefinition( "gradientRef2Y", QObject::tr( "Reference point 2 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
74 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid ), QgsPropertyDefinition( "gradientRef1Centroid", QObject::tr( "Reference point 1 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
75 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid ), QgsPropertyDefinition( "gradientRef2Centroid", QObject::tr( "Reference point 2 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
76 { static_cast< int >( QgsSymbolLayer::Property::BlurRadius ), QgsPropertyDefinition( "blurRadius", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Blur radius" ), QObject::tr( "Integer between 0 and 18" ), origin )},
77 { static_cast< int >( QgsSymbolLayer::Property::LineDistance ), QgsPropertyDefinition( "lineDistance", QObject::tr( "Distance between lines" ), QgsPropertyDefinition::DoublePositive, origin )},
78 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ), QgsPropertyDefinition( "shapeburstWholeShape", QObject::tr( "Shade whole shape" ), QgsPropertyDefinition::Boolean, origin )},
79 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ), QgsPropertyDefinition( "shapeburstMaxDist", QObject::tr( "Maximum distance for shapeburst fill" ), QgsPropertyDefinition::DoublePositive, origin )},
80 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ), QgsPropertyDefinition( "shapeburstIgnoreRings", QObject::tr( "Ignore rings in feature" ), QgsPropertyDefinition::Boolean, origin )},
81 { static_cast< int >( QgsSymbolLayer::Property::File ), QgsPropertyDefinition( "file", QObject::tr( "Symbol file path" ), QgsPropertyDefinition::String, origin )},
82 { static_cast< int >( QgsSymbolLayer::Property::DistanceX ), QgsPropertyDefinition( "distanceX", QObject::tr( "Horizontal distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
83 { static_cast< int >( QgsSymbolLayer::Property::DistanceY ), QgsPropertyDefinition( "distanceY", QObject::tr( "Vertical distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
84 { static_cast< int >( QgsSymbolLayer::Property::DisplacementX ), QgsPropertyDefinition( "displacementX", QObject::tr( "Horizontal displacement between rows" ), QgsPropertyDefinition::DoublePositive, origin )},
85 { static_cast< int >( QgsSymbolLayer::Property::DisplacementY ), QgsPropertyDefinition( "displacementY", QObject::tr( "Vertical displacement between columns" ), QgsPropertyDefinition::DoublePositive, origin )},
86 { static_cast< int >( QgsSymbolLayer::Property::OffsetX ), QgsPropertyDefinition( "offsetX", QObject::tr( "Horizontal offset" ), QgsPropertyDefinition::Double, origin )},
87 { static_cast< int >( QgsSymbolLayer::Property::OffsetY ), QgsPropertyDefinition( "offsetY", QObject::tr( "Vertical offset" ), QgsPropertyDefinition::Double, origin )},
88 { static_cast< int >( QgsSymbolLayer::Property::Opacity ), QgsPropertyDefinition( "alpha", QObject::tr( "Opacity" ), QgsPropertyDefinition::Opacity, origin )},
89 { static_cast< int >( QgsSymbolLayer::Property::CustomDash ), QgsPropertyDefinition( "customDash", QgsPropertyDefinition::DataTypeString, QObject::tr( "Custom dash pattern" ), QObject::tr( "[<b><dash>;<space></b>] e.g. '8;2;1;2'" ), origin )},
90 { static_cast< int >( QgsSymbolLayer::Property::CapStyle ), QgsPropertyDefinition( "capStyle", QObject::tr( "Line cap style" ), QgsPropertyDefinition::CapStyle, origin )},
91 { static_cast< int >( QgsSymbolLayer::Property::Placement ), 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 )},
92 { static_cast< int >( QgsSymbolLayer::Property::Interval ), QgsPropertyDefinition( "interval", QObject::tr( "Marker interval" ), QgsPropertyDefinition::DoublePositive, origin )},
93 { static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ), QgsPropertyDefinition( "offsetAlongLine", QObject::tr( "Offset along line" ), QgsPropertyDefinition::Double, origin )},
94 { static_cast< int >( QgsSymbolLayer::Property::AverageAngleLength ), QgsPropertyDefinition( "averageAngleLength", QObject::tr( "Average line angles over" ), QgsPropertyDefinition::DoublePositive, origin )},
95 { static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ), QgsPropertyDefinition( "hAnchor", QObject::tr( "Horizontal anchor point" ), QgsPropertyDefinition::HorizontalAnchor, origin )},
96 { static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ), QgsPropertyDefinition( "vAnchor", QObject::tr( "Vertical anchor point" ), QgsPropertyDefinition::VerticalAnchor, origin )},
97 { static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ), QgsPropertyDefinition( "enabled", QObject::tr( "Layer enabled" ), QgsPropertyDefinition::Boolean, origin )},
98 { static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ), QgsPropertyDefinition( "arrowWidth", QObject::tr( "Arrow line width" ), QgsPropertyDefinition::StrokeWidth, origin )},
99 { static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ), QgsPropertyDefinition( "arrowStartWidth", QObject::tr( "Arrow line start width" ), QgsPropertyDefinition::StrokeWidth, origin )},
100 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ), QgsPropertyDefinition( "arrowHeadLength", QObject::tr( "Arrow head length" ), QgsPropertyDefinition::DoublePositive, origin )},
101 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ), QgsPropertyDefinition( "arrowHeadThickness", QObject::tr( "Arrow head thickness" ), QgsPropertyDefinition::DoublePositive, origin )},
102 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ), QgsPropertyDefinition( "arrowHeadType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow head type" ), QObject::tr( "string " ) + QLatin1String( "[<b>single</b>|<b>reversed</b>|<b>double</b>]" ), origin )},
103 { static_cast< int >( QgsSymbolLayer::Property::ArrowType ), QgsPropertyDefinition( "arrowType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow type" ), QObject::tr( "string " ) + QLatin1String( "[<b>plain</b>|<b>lefthalf</b>|<b>righthalf</b>]" ), origin )},
104 { static_cast< int >( QgsSymbolLayer::Property::PointCount ), QgsPropertyDefinition( "pointCount", QObject::tr( "Point count" ), QgsPropertyDefinition::IntegerPositive, origin )},
105 { static_cast< int >( QgsSymbolLayer::Property::RandomSeed ), QgsPropertyDefinition( "randomSeed", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Random number seed" ), QObject::tr( "integer > 0, or 0 for completely random sequence" ), origin )},
106 { static_cast< int >( QgsSymbolLayer::Property::ClipPoints ), QgsPropertyDefinition( "clipPoints", QObject::tr( "Clip markers" ), QgsPropertyDefinition::Boolean, origin )},
107 { static_cast< int >( QgsSymbolLayer::Property::DensityArea ), QgsPropertyDefinition( "densityArea", QObject::tr( "Density area" ), QgsPropertyDefinition::DoublePositive, origin )},
108 { static_cast< int >( QgsSymbolLayer::Property::DashPatternOffset ), QgsPropertyDefinition( "dashPatternOffset", QObject::tr( "Dash pattern offset" ), QgsPropertyDefinition::DoublePositive, origin )},
109 { static_cast< int >( QgsSymbolLayer::Property::TrimStart ), QgsPropertyDefinition( "trimStart", QObject::tr( "Start trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
110 { static_cast< int >( QgsSymbolLayer::Property::TrimEnd ), QgsPropertyDefinition( "trimEnd", QObject::tr( "End trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
111 { static_cast< int >( QgsSymbolLayer::Property::LineStartWidthValue ), QgsPropertyDefinition( "lineStartWidthValue", QObject::tr( "Line start width value" ), QgsPropertyDefinition::Double, origin )},
112 { static_cast< int >( QgsSymbolLayer::Property::LineEndWidthValue ), QgsPropertyDefinition( "lineEndWidthValue", QObject::tr( "Line end width value" ), QgsPropertyDefinition::Double, origin )},
113 { static_cast< int >( QgsSymbolLayer::Property::LineStartColorValue ), QgsPropertyDefinition( "lineStartColorValue", QObject::tr( "Line start color value" ), QgsPropertyDefinition::Double, origin )},
114 { static_cast< int >( QgsSymbolLayer::Property::LineEndColorValue ), QgsPropertyDefinition( "lineEndColorValue", QObject::tr( "Line end color value" ), QgsPropertyDefinition::Double, origin )},
115 { static_cast< int >( QgsSymbolLayer::Property::MarkerClipping ), 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 )},
116 { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetX ), QgsPropertyDefinition( "randomOffsetX", QObject::tr( "Horizontal random offset" ), QgsPropertyDefinition::Double, origin )},
117 { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetY ), QgsPropertyDefinition( "randomOffsetY", QObject::tr( "Vertical random offset" ), QgsPropertyDefinition::Double, origin )},
118 { static_cast< int >( QgsSymbolLayer::Property::LineClipping ), 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 )},
119 { static_cast< int >( QgsSymbolLayer::Property::SkipMultiples ), QgsPropertyDefinition( "skipMultiples", QObject::tr( "Skip multiples of" ), QgsPropertyDefinition::DoublePositive, origin )},
120 { static_cast< int >( QgsSymbolLayer::Property::ShowMarker ), QgsPropertyDefinition( "showMarker", QObject::tr( "Show marker" ), QgsPropertyDefinition::Boolean, origin )},
121 };
122}
123
128
130{
131 installMasks( context, false );
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 removeMasks( context, false );
143}
144
146{
147 return nullptr;
148}
149
151{
152 delete symbol;
153 return false;
154}
155
156bool QgsSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const
157{
158 Q_UNUSED( e )
159 Q_UNUSED( mmMapUnitScaleFactor )
160 Q_UNUSED( layerName )
161 Q_UNUSED( context )
162 Q_UNUSED( shift )
163 return false;
164}
165
167{
168 Q_UNUSED( e )
169 Q_UNUSED( context )
170 return 1.0;
171}
172
174{
175 Q_UNUSED( e )
176 Q_UNUSED( context )
177 return 1.0;
178}
179
181{
182 Q_UNUSED( e )
183 Q_UNUSED( context )
184 return 0.0;
185}
186
188{
189 Q_UNUSED( context )
190 return color();
191}
192
194{
195 Q_UNUSED( context )
196 return 0.0;
197}
198
200{
201 Q_UNUSED( unit )
202 return QVector<qreal>();
203}
204
205Qt::PenStyle QgsSymbolLayer::dxfPenStyle() const
206{
207 return Qt::SolidLine;
208}
209
211{
212 Q_UNUSED( context )
213 return color();
214}
215
216Qt::BrushStyle QgsSymbolLayer::dxfBrushStyle() const
217{
218 return Qt::NoBrush;
219}
220
222{
223 return mPaintEffect.get();
224}
225
227{
228 if ( effect == mPaintEffect.get() )
229 return;
230
231 mPaintEffect.reset( effect );
232}
233
235 : mType( type )
236 , mLocked( locked )
237 , mId( QUuid::createUuid().toString() )
238{
239}
240
245
250
255
257{
258 return mColor;
259}
260
261void QgsSymbolLayer::setColor( const QColor &color )
262{
263 mColor = color;
264}
265
266void QgsSymbolLayer::setStrokeColor( const QColor & )
267{
268
269}
270
272{
273 return QColor();
274}
275
276void QgsSymbolLayer::setFillColor( const QColor & )
277{
278}
279
281{
282 return QColor();
283}
284
286{
288
289 if ( !context.fields().isEmpty() )
290 {
291 //QgsFields is implicitly shared, so it's cheap to make a copy
292 mFields = context.fields();
293 }
294}
295
300
302{
303 QgsSymbolLayer::initPropertyDefinitions();
304 return sPropertyDefinitions;
305}
306
308
310{
312 return true;
313
314 return symbol->type() == mType;
315}
316
318{
319 return false;
320}
321
323{
324 return false;
325}
326
327void QgsSymbolLayer::setRenderingPass( int renderingPass )
328{
330}
331
333{
334 return mRenderingPass;
335}
336
337QSet<QString> QgsSymbolLayer::usedAttributes( const QgsRenderContext &context ) const
338{
339 // calling referencedFields() with ignoreContext=true because in our expression context
340 // we do not have valid QgsFields yet - because of that the field names from expressions
341 // wouldn't get reported
342 QSet<QString> columns = mDataDefinedProperties.referencedFields( context.expressionContext(), true );
343 return columns;
344}
345
346QgsProperty propertyFromMap( const QVariantMap &map, const QString &baseName )
347{
348 QString prefix;
349 if ( !baseName.isEmpty() )
350 {
351 prefix.append( QStringLiteral( "%1_dd_" ).arg( baseName ) );
352 }
353
354 if ( !map.contains( QStringLiteral( "%1expression" ).arg( prefix ) ) )
355 {
356 //requires at least the expression value
357 return QgsProperty();
358 }
359
360 bool active = ( map.value( QStringLiteral( "%1active" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
361 QString expression = map.value( QStringLiteral( "%1expression" ).arg( prefix ) ).toString();
362 bool useExpression = ( map.value( QStringLiteral( "%1useexpr" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
363 QString field = map.value( QStringLiteral( "%1field" ).arg( prefix ), QString() ).toString();
364
365 if ( useExpression )
366 return QgsProperty::fromExpression( expression, active );
367 else
368 return QgsProperty::fromField( field, active );
369}
370
371void QgsSymbolLayer::restoreOldDataDefinedProperties( const QVariantMap &stringMap )
372{
373 // property string to type upgrade map
374 static const QMap < QString, int > OLD_PROPS
375 {
376 { "color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
377 { "arrow_width", static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ) },
378 { "arrow_start_width", static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ) },
379 { "head_length", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ) },
380 { "head_thickness", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ) },
381 { "offset", static_cast< int >( QgsSymbolLayer::Property::Offset ) },
382 { "head_type", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ) },
383 { "arrow_type", static_cast< int >( QgsSymbolLayer::Property::ArrowType ) },
384 { "width_field", static_cast< int >( QgsSymbolLayer::Property::Width ) },
385 { "height_field", static_cast< int >( QgsSymbolLayer::Property::Height ) },
386 { "rotation_field", static_cast< int >( QgsSymbolLayer::Property::Angle ) },
387 { "outline_width_field", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
388 { "fill_color_field", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
389 { "outline_color_field", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
390 { "symbol_name_field", static_cast< int >( QgsSymbolLayer::Property::Name ) },
391 { "outline_width", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
392 { "outline_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
393 { "join_style", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },
394 { "fill_color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
395 { "outline_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
396 { "width", static_cast< int >( QgsSymbolLayer::Property::Width ) },
397 { "height", static_cast< int >( QgsSymbolLayer::Property::Height ) },
398 { "symbol_name", static_cast< int >( QgsSymbolLayer::Property::Name ) },
399 { "angle", static_cast< int >( QgsSymbolLayer::Property::Angle ) },
400 { "fill_style", static_cast< int >( QgsSymbolLayer::Property::FillStyle ) },
401 { "color_border", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
402 { "width_border", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
403 { "border_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
404 { "border_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
405 { "color2", static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ) },
406 { "gradient_type", static_cast< int >( QgsSymbolLayer::Property::GradientType ) },
407 { "coordinate_mode", static_cast< int >( QgsSymbolLayer::Property::CoordinateMode )},
408 { "spread", static_cast< int >( QgsSymbolLayer::Property::GradientSpread ) },
409 { "reference1_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ) },
410 { "reference1_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ) },
411 { "reference2_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ) },
412 { "reference2_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y )},
413 { "reference1_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid )},
414 { "reference2_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid )},
415 { "blur_radius", static_cast< int >( QgsSymbolLayer::Property::BlurRadius ) },
416 { "use_whole_shape", static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ) },
417 { "max_distance", static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ) },
418 { "ignore_rings", static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ) },
419 { "svgFillColor", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
420 { "svgOutlineColor", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
421 { "svgOutlineWidth", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
422 { "svgFile", static_cast< int >( QgsSymbolLayer::Property::File ) },
423 { "lineangle", static_cast< int >( QgsSymbolLayer::Property::LineAngle ) },
424 { "distance", static_cast< int >( QgsSymbolLayer::Property::LineDistance )},
425 { "distance_x", static_cast< int >( QgsSymbolLayer::Property::DistanceX )},
426 { "distance_y", static_cast< int >( QgsSymbolLayer::Property::DistanceY ) },
427 { "displacement_x", static_cast< int >( QgsSymbolLayer::Property::DisplacementX )},
428 { "displacement_y", static_cast< int >( QgsSymbolLayer::Property::DisplacementY ) },
429 { "file", static_cast< int >( QgsSymbolLayer::Property::File ) },
430 { "alpha", static_cast< int >( QgsSymbolLayer::Property::Opacity )},
431 { "customdash", static_cast< int >( QgsSymbolLayer::Property::CustomDash ) },
432 { "line_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
433 { "joinstyle", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },
434 { "capstyle", static_cast< int >( QgsSymbolLayer::Property::CapStyle ) },
435 { "placement", static_cast< int >( QgsSymbolLayer::Property::Placement ) },
436 { "interval", static_cast< int >( QgsSymbolLayer::Property::Interval ) },
437 { "offset_along_line", static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ) },
438 { "name", static_cast< int >( QgsSymbolLayer::Property::Name ) },
439 { "size", static_cast< int >( QgsSymbolLayer::Property::Size ) },
440 { "fill", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
441 { "outline", static_cast< int >( QgsSymbolLayer::Property::StrokeColor )},
442 { "char", static_cast< int >( QgsSymbolLayer::Property::Character )},
443 { "enabled", static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ) },
444 { "rotation", static_cast< int >( QgsSymbolLayer::Property::Angle )},
445 { "horizontal_anchor_point", static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ) },
446 { "vertical_anchor_point", static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ) },
447 };
448
449 QVariantMap::const_iterator propIt = stringMap.constBegin();
450 for ( ; propIt != stringMap.constEnd(); ++propIt )
451 {
452 std::unique_ptr<QgsProperty> prop;
453 QString propertyName;
454
455 if ( propIt.key().endsWith( QLatin1String( "_dd_expression" ) ) )
456 {
457 //found a data defined property
458
459 //get data defined property name by stripping "_dd_expression" from property key
460 propertyName = propIt.key().left( propIt.key().length() - 14 );
461
462 prop = std::make_unique<QgsProperty>( propertyFromMap( stringMap, propertyName ) );
463 }
464 else if ( propIt.key().endsWith( QLatin1String( "_expression" ) ) )
465 {
466 //old style data defined property, upgrade
467
468 //get data defined property name by stripping "_expression" from property key
469 propertyName = propIt.key().left( propIt.key().length() - 11 );
470
471 prop = std::make_unique<QgsProperty>( QgsProperty::fromExpression( propIt.value().toString() ) );
472 }
473
474 if ( !prop || !OLD_PROPS.contains( propertyName ) )
475 continue;
476
477 int key = OLD_PROPS.value( propertyName );
478
479 if ( type() == Qgis::SymbolType::Line )
480 {
481 //these keys had different meaning for line symbol layers
482 if ( propertyName == QLatin1String( "width" ) )
483 key = static_cast< int >( QgsSymbolLayer::Property::StrokeWidth );
484 else if ( propertyName == QLatin1String( "color" ) )
485 key = static_cast< int >( QgsSymbolLayer::Property::StrokeColor );
486 }
487
488 setDataDefinedProperty( static_cast< QgsSymbolLayer::Property >( key ), QgsProperty( *prop.get() ) );
489 }
490}
491
493{
494 if ( !destLayer )
495 return;
496
498}
499
501{
502 if ( !destLayer || !mPaintEffect )
503 return;
504
506 destLayer->setPaintEffect( mPaintEffect->clone() );
507 else
508 destLayer->setPaintEffect( nullptr );
509}
510
512 : QgsSymbolLayer( Qgis::SymbolType::Marker, locked )
513{
514
515}
516
518 : QgsSymbolLayer( Qgis::SymbolType::Line, locked )
519{
520}
521
526
528{
529 mRingFilter = filter;
530}
531
533 : QgsSymbolLayer( Qgis::SymbolType::Fill, locked )
534{
535}
536
538{
539 Q_UNUSED( context )
540}
541
543{
544 Q_UNUSED( context )
545}
546
548{
549 startRender( context );
550 QgsPaintEffect *effect = paintEffect();
551
552 QPolygonF points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 )
554
555 std::unique_ptr< QgsEffectPainter > effectPainter;
556 if ( effect && effect->enabled() )
557 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
558
559 for ( QPointF point : std::as_const( points ) )
560 renderPoint( point, context );
561
562 effectPainter.reset();
563
564 stopRender( context );
565}
566
567void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const
568{
570}
571
572void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const
573{
574 markerOffset( context, width, height, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );
575}
576
577void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height,
578 Qgis::RenderUnit widthUnit, Qgis::RenderUnit heightUnit,
579 double &offsetX, double &offsetY, const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const
580{
581 offsetX = mOffset.x();
582 offsetY = mOffset.y();
583
585 {
588 bool ok = false;
589 const QPointF offset = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
590 if ( ok )
591 {
592 offsetX = offset.x();
593 offsetY = offset.y();
594 }
595 }
596
599
603 {
605 if ( !QgsVariantUtils::isNull( exprVal ) )
606 {
607 horizontalAnchorPoint = decodeHorizontalAnchorPoint( exprVal.toString() );
608 }
609 }
611 {
613 if ( !QgsVariantUtils::isNull( exprVal ) )
614 {
615 verticalAnchorPoint = decodeVerticalAnchorPoint( exprVal.toString() );
616 }
617 }
618
619 //correct horizontal position according to anchor point
621 {
622 return;
623 }
624
625 double anchorPointCorrectionX = context.renderContext().convertToPainterUnits( width, widthUnit, widthMapUnitScale ) / 2.0;
627 {
628 // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
629 // and clamp it to a reasonable range. It's the best we can do in this situation!
630 anchorPointCorrectionX = std::min( std::max( context.renderContext().convertToPainterUnits( width, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;
631 }
632
633 double anchorPointCorrectionY = context.renderContext().convertToPainterUnits( height, heightUnit, heightMapUnitScale ) / 2.0;
635 {
636 // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
637 // and clamp it to a reasonable range. It's the best we can do in this situation!
638 anchorPointCorrectionY = std::min( std::max( context.renderContext().convertToPainterUnits( height, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;
639 }
640
642 {
643 offsetX += anchorPointCorrectionX;
644 }
645 else if ( horizontalAnchorPoint == Right )
646 {
647 offsetX -= anchorPointCorrectionX;
648 }
649
650//correct vertical position according to anchor point
651 if ( verticalAnchorPoint == Top )
652 {
653 offsetY += anchorPointCorrectionY;
654 }
655 else if ( verticalAnchorPoint == Bottom )
656 {
657 offsetY -= anchorPointCorrectionY;
658 }
659}
660
661QPointF QgsMarkerSymbolLayer::_rotatedOffset( QPointF offset, double angle )
662{
663 angle = DEG2RAD( angle );
664 double c = std::cos( angle ), s = std::sin( angle );
665 return QPointF( offset.x() * c - offset.y() * s, offset.x() * s + offset.y() * c );
666}
667
668QgsMarkerSymbolLayer::HorizontalAnchorPoint QgsMarkerSymbolLayer::decodeHorizontalAnchorPoint( const QString &str )
669{
670 if ( str.compare( QLatin1String( "left" ), Qt::CaseInsensitive ) == 0 )
671 {
673 }
674 else if ( str.compare( QLatin1String( "right" ), Qt::CaseInsensitive ) == 0 )
675 {
677 }
678 else
679 {
681 }
682}
683
684QgsMarkerSymbolLayer::VerticalAnchorPoint QgsMarkerSymbolLayer::decodeVerticalAnchorPoint( const QString &str )
685{
686 if ( str.compare( QLatin1String( "top" ), Qt::CaseInsensitive ) == 0 )
687 {
689 }
690 else if ( str.compare( QLatin1String( "bottom" ), Qt::CaseInsensitive ) == 0 )
691 {
693 }
694 else
695 {
697 }
698}
699
701{
702 mSizeUnit = unit;
703 mOffsetUnit = unit;
704}
705
707{
708 if ( mOffsetUnit != mSizeUnit )
709 {
711 }
712 return mOffsetUnit;
713}
714
720
729
731{
732 mWidthUnit = unit;
733 mOffsetUnit = unit;
734}
735
740
745
750
751
753{
754 const QList< QList< QPolygonF > > points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Line, size )
756 startRender( context );
757 QgsPaintEffect *effect = paintEffect();
758
759 std::unique_ptr< QgsEffectPainter > effectPainter;
760 if ( effect && effect->enabled() )
761 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
762
763 for ( const QList< QPolygonF > &line : points )
764 renderPolyline( line.value( 0 ), context );
765
766 effectPainter.reset();
767
768 stopRender( context );
769}
770
771void QgsLineSymbolLayer::renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
772{
773 QgsExpressionContextScope *scope = nullptr;
774 std::unique_ptr< QgsExpressionContextScopePopper > scopePopper;
776 {
777 scope = new QgsExpressionContextScope();
778 scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.renderContext().expressionContext(), scope );
779 }
780
781 switch ( mRingFilter )
782 {
783 case AllRings:
784 case ExteriorRingOnly:
785 {
786 if ( scope )
788 renderPolyline( points, context );
789 break;
790 }
792 break;
793 }
794
795 if ( rings )
796 {
797 switch ( mRingFilter )
798 {
799 case AllRings:
801 {
802 int ringIndex = 1;
803 for ( const QPolygonF &ring : std::as_const( *rings ) )
804 {
805 if ( scope )
807
808 renderPolyline( ring, context );
809 ringIndex++;
810 }
811 }
812 break;
813 case ExteriorRingOnly:
814 break;
815 }
816 }
817}
818
819double QgsLineSymbolLayer::width( const QgsRenderContext &context ) const
820{
822}
823
825{
826 Q_UNUSED( context )
828}
829
830
832{
833 const QList< QList< QPolygonF > > polys = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Fill, size )
835
836 startRender( context );
837 QgsPaintEffect *effect = paintEffect();
838
839 std::unique_ptr< QgsEffectPainter > effectPainter;
840 if ( effect && effect->enabled() )
841 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
842
843 for ( const QList< QPolygonF > &poly : polys )
844 {
845 QVector< QPolygonF > rings;
846 for ( int i = 1; i < poly.size(); ++i )
847 rings << poly.at( i );
848 renderPolygon( poly.value( 0 ), &rings, context );
849 }
850
851 effectPainter.reset();
852
853 stopRender( context );
854}
855
857{
858 return QImage();
859}
860
861void QgsFillSymbolLayer::_renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
862{
863 if ( !p )
864 {
865 return;
866 }
867
868 // Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #5 points).
869 if ( points.size() <= 5 &&
872 ( p->renderHints() & QPainter::Antialiasing ) )
873 {
874 p->setRenderHint( QPainter::Antialiasing, false );
875 p->drawRect( points.boundingRect() );
876 p->setRenderHint( QPainter::Antialiasing, true );
877 return;
878 }
879
880 // polygons outlines are sometimes rendered wrongly with drawPolygon, when
881 // clipped (see #13343), so use drawPath instead.
882 if ( !rings && p->pen().style() == Qt::NoPen )
883 {
884 // simple polygon without holes
885 p->drawPolygon( points );
886 }
887 else
888 {
889 // polygon with holes must be drawn using painter path
890 QPainterPath path;
891 path.addPolygon( points );
892
893 if ( rings )
894 {
895 for ( auto it = rings->constBegin(); it != rings->constEnd(); ++it )
896 {
897 QPolygonF ring = *it;
898 path.addPolygon( ring );
899 }
900 }
901
902 p->drawPath( path );
903 }
904}
905
906void QgsMarkerSymbolLayer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
907{
908 QDomElement symbolizerElem = doc.createElement( QStringLiteral( "se:PointSymbolizer" ) );
909 if ( !props.value( QStringLiteral( "uom" ), QString() ).toString().isEmpty() )
910 symbolizerElem.setAttribute( QStringLiteral( "uom" ), props.value( QStringLiteral( "uom" ), QString() ).toString() );
911 element.appendChild( symbolizerElem );
912
913 // <Geometry>
914 QgsSymbolLayerUtils::createGeometryElement( doc, symbolizerElem, props.value( QStringLiteral( "geom" ), QString() ).toString() );
915
916 writeSldMarker( doc, symbolizerElem, props );
917}
918
919QList<QgsSymbolLayerReference> QgsSymbolLayer::masks() const
920{
921 return {};
922}
923
925{
926 double size = mSize;
928 {
929 bool ok = false;
931
932 if ( ok )
933 {
934 switch ( mScaleMethod )
935 {
937 size = std::sqrt( size );
938 break;
940 break;
941 }
942 }
943 }
945}
946
957
958QPainterPath generateClipPath( const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries )
959{
960 foundGeometries = false;
961 const QVector<QgsGeometry> clipGeometries = rect
963 : renderContext.symbolLayerClipGeometries( id );
964 if ( !clipGeometries.empty() )
965 {
966 foundGeometries = true;
967 QgsGeometry mergedGeom = QgsGeometry::unaryUnion( clipGeometries );
968 if ( renderContext.maskSettings().simplifyTolerance() > 0 )
969 {
970 QgsGeos geos( mergedGeom.constGet() );
971 mergedGeom = QgsGeometry( geos.simplify( renderContext.maskSettings().simplifyTolerance() ) );
972 }
973#if GEOS_VERSION_MAJOR==3 && GEOS_VERSION_MINOR<10
974 // structure would be better, but too old GEOS
975 mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Linework );
976#else
977 mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Structure );
978#endif
979 if ( !mergedGeom.isEmpty() )
980 {
981 QgsGeometry exterior;
982 const QgsRectangle contextBounds( 0, 0,
983 renderContext.outputSize().width(),
984 renderContext.outputSize().height() );
985 if ( rect )
986 {
987 exterior = QgsGeometry::fromRect( QgsRectangle( *rect ).intersect( contextBounds ) );
988 }
989 else
990 {
991 exterior = QgsGeometry::fromRect( contextBounds );
992 }
993 const QgsGeometry maskGeom = exterior.difference( mergedGeom );
994 if ( !maskGeom.isNull() )
995 {
996 return maskGeom.constGet()->asQPainterPath();
997 }
998 }
999 }
1000 return QPainterPath();
1001}
1002
1004{
1005 const QgsRenderContext &renderContext = context.renderContext();
1006
1007 bool foundGeometries = false;
1008 mClipPath = generateClipPath( renderContext, id(), nullptr, foundGeometries );
1009}
1010
1011bool QgsSymbolLayer::installMasks( QgsRenderContext &context, bool recursive, const QRectF &rect )
1012{
1013 bool res = false;
1014 if ( !mClipPath.isEmpty() )
1015 {
1016 context.painter()->save();
1017 context.painter()->setClipPath( mClipPath, Qt::IntersectClip );
1018 res = true;
1019 }
1020 else if ( rect.isValid() )
1021 {
1022 // find just the clip geometries within the area the symbol layer will be drawn over
1023 bool foundGeometries = false;
1024 const QPainterPath clipPath = generateClipPath( context, id(), &rect, foundGeometries );
1025 if ( !clipPath.isEmpty() )
1026 {
1027 context.painter()->setClipPath( clipPath, context.painter()->clipPath().isEmpty() ? Qt::ReplaceClip : Qt::IntersectClip );
1028 res = true;
1029 }
1030 }
1031
1032 if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )
1033 {
1034 const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();
1035 for ( QgsSymbolLayer *sl : layers )
1036 res = sl->installMasks( context, true ) || res;
1037 }
1038
1039 return res;
1040}
1041
1042void QgsSymbolLayer::removeMasks( QgsRenderContext &context, bool recursive )
1043{
1044 if ( !mClipPath.isEmpty() )
1045 {
1046 context.painter()->restore();
1047 }
1048
1049 if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )
1050 {
1051 const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();
1052 for ( QgsSymbolLayer *sl : layers )
1053 sl->removeMasks( context, true );
1054 }
1055}
1056
1061
1062void QgsSymbolLayer::setId( const QString &id )
1063{
1064 mId = id;
1065}
1066
1067QString QgsSymbolLayer::id() const
1068{
1069 return mId;
1070}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ AntialiasingSimplification
The geometries can be rendered with 'AntiAliasing' disabled because of it is '1-pixel size'.
@ ScaleDiameter
Calculate scale by the diameter.
@ ScaleArea
Calculate scale by the area.
QFlags< SymbolLayerFlag > SymbolLayerFlags
Symbol layer flags.
Definition qgis.h:821
QFlags< SymbolLayerUserFlag > SymbolLayerUserFlags
Symbol layer user flags.
Definition qgis.h:844
RenderUnit
Rendering size units.
Definition qgis.h:4839
@ Millimeters
Millimeters.
@ Unknown
Mixed or unknown units.
@ MetersInMapUnits
Meters value as Map units.
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
@ Linework
Combines all rings into a set of noded lines and then extracts valid polygons from that linework.
@ Structure
Structured method, first makes all rings valid and then merges shells and subtracts holes from shells...
@ DisableSelectionRecoloring
If present, indicates that the symbol layer should not be recolored when rendering selected features.
SymbolType
Symbol types.
Definition qgis.h:574
@ 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...
virtual QPainterPath asQPainterPath() const =0
Returns the geometry represented as a QPainterPath.
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double.
Exports QGIS layers to the DXF format.
static double mapUnitScaleFactor(double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
Qgis::DistanceUnit mapUnits() const
Retrieve map units.
double symbologyScale() const
Returns the reference scale for output.
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:58
bool isEmpty
Definition qgsfields.h:49
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.
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QgsFillSymbolLayer(const QgsFillSymbolLayer &other)=delete
A geometry is the spatial representation of a feature.
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
QgsGeometry difference(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters()) const
Returns a geometry representing the points making up this geometry that do not make up other.
QgsGeometry makeValid(Qgis::MakeValidMethod method=Qgis::MakeValidMethod::Linework, bool keepCollapsed=false) const
Attempts to make an invalid geometry valid without losing vertices.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
static QgsGeometry unaryUnion(const QVector< QgsGeometry > &geometries, const QgsGeometryParameters &parameters=QgsGeometryParameters())
Compute the unary union on a list of geometries.
Does vector analysis using the geos library and handles import, export, exception handling*.
Definition qgsgeos.h:137
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...
Qgis::RenderUnit mOffsetUnit
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
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
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
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.
Qgis::RenderUnit mWidthUnit
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
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
Qgis::RenderUnit widthUnit() const
Returns the units for the line's width.
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
Qgis::RenderUnit mOffsetUnit
Offset units.
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.
Qgis::RenderUnit outputUnit() const override
Returns 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
static QPointF _rotatedOffset(QPointF offset, double angle)
Adjusts a marker offset to account for rotation.
virtual double dxfAngle(QgsSymbolRenderContext &context) const override
Gets angle.
Qgis::ScaleMethod mScaleMethod
Marker size scaling method.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets marker size.
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.
Qgis::RenderUnit mSizeUnit
Marker size unit.
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
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.
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.
double mAngle
Marker rotation angle, in degrees clockwise from north.
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
double simplifyTolerance() const
Returns the simplification tolerance (in painter units) to use for on-the-fly simplification of mask ...
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 final
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.
bool isActive(int key) const final
Returns true if the collection contains an active property with the specified key.
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const final
Prepares the collection against a specified expression context.
bool hasActiveProperties() const final
Returns true if the collection has any active properties, or false if all properties within the colle...
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext(), bool ignoreContext=false) const final
Returns the set of any fields referenced by the active properties from the collection.
Definition for a property.
Definition qgsproperty.h:45
@ HorizontalAnchor
Horizontal anchor point.
Definition qgsproperty.h:73
@ Double
Double value (including negative values)
Definition qgsproperty.h:55
@ VerticalAnchor
Vertical anchor point.
Definition qgsproperty.h:74
@ Double0To1
Double value between 0-1 (inclusive)
Definition qgsproperty.h:57
@ FillStyle
Fill style (eg solid, lines)
Definition qgsproperty.h:71
@ StrokeWidth
Line stroke width.
Definition qgsproperty.h:70
@ LineStyle
Line style (eg solid/dashed)
Definition qgsproperty.h:69
@ String
Any string value.
Definition qgsproperty.h:59
@ Boolean
Boolean value.
Definition qgsproperty.h:51
@ PenJoinStyle
Pen join style.
Definition qgsproperty.h:64
@ IntegerPositive
Positive integer values (including 0)
Definition qgsproperty.h:53
@ Opacity
Opacity (0-100)
Definition qgsproperty.h:60
@ CapStyle
Line cap style (eg round)
Definition qgsproperty.h:72
@ Rotation
Rotation (value between 0-360 degrees)
Definition qgsproperty.h:58
@ Size
1D size (eg marker radius, or square marker height/width)
Definition qgsproperty.h:67
@ ColorWithAlpha
Color with alpha channel.
Definition qgsproperty.h:62
@ DoublePositive
Positive double value (including 0)
Definition qgsproperty.h:56
@ DataTypeString
Property requires a string value.
Definition qgsproperty.h:90
@ DataTypeNumeric
Property requires a numeric value.
Definition qgsproperty.h:97
A store for object properties.
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.
A rectangle specified with double values.
QgsRectangle intersect(const QgsRectangle &rect) const
Returns the intersection with the given rectangle.
Contains information about the context of a rendering operation.
QgsVectorSimplifyMethod & vectorSimplifyMethod()
Returns the simplification settings to use when rendering vector layers.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QVector< QgsGeometry > symbolLayerClipGeometries(const QString &symbolLayerId) const
Returns clipping geometries to be applied to the symbolLayer before rendering.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
const QgsMaskRenderSettings & maskSettings() const
Returns a reference to the mask render settings, which control how masks are drawn and behave during ...
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:145
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 (...
static QPointF toPoint(const QVariant &value, bool *ok=nullptr)
Converts a value to a point.
static QVector< QgsGeometry > collectSymbolLayerClipGeometries(const QgsRenderContext &context, const QString &symbolLayerId, const QRectF &bounds)
Returns a list of the symbol layer clip geometries to be used for the symbol layer with the specified...
static void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
static QString encodePoint(QPointF point)
Encodes a QPointF to a string.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
bool shouldRenderUsingSelectionColor(const QgsSymbolRenderContext &context) const
Returns true if the symbol layer should be rendered using the selection color from the render context...
Qgis::SymbolType type() const
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
virtual QColor fillColor() const
Returns the fill color for the symbol layer.
void setId(const QString &id)
Set symbol layer identifier This id has to be unique in the whole project.
virtual void setStrokeColor(const QColor &color)
Sets the stroke color for the symbol layer.
QPainterPath mClipPath
bool installMasks(QgsRenderContext &context, bool recursive, const QRectF &rect=QRectF())
When rendering, install masks on context painter.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets marker size.
virtual double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
Qgis::SymbolType mType
void removeMasks(QgsRenderContext &context, bool recursive)
When rendering, remove previously installed masks from context painter if recursive is true masks are...
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.
Property
Data definable properties.
@ SkipMultiples
Skip multiples of.
@ ArrowHeadLength
Arrow head length.
@ GradientType
Gradient fill type.
@ SecondaryColor
Secondary color (eg for gradient fills)
@ File
Filename, eg for svg files.
@ VerticalAnchor
Vertical anchor point.
@ GradientReference2Y
Gradient reference point 2 y.
@ GradientReference1X
Gradient reference point 1 x.
@ OffsetY
Vertical offset.
@ OffsetX
Horizontal offset.
@ GradientReference1Y
Gradient reference point 1 y.
@ ArrowWidth
Arrow tail width.
@ PointCount
Point count.
@ DashPatternOffset
Dash pattern offset,.
@ GradientSpread
Gradient spread mode.
@ OffsetAlongLine
Offset along line.
@ ArrowHeadType
Arrow head type.
@ CustomDash
Custom dash pattern.
@ ShapeburstMaxDistance
Shapeburst fill from edge distance.
@ HorizontalAnchor
Horizontal anchor point.
@ StrokeStyle
Stroke style (eg solid, dashed)
@ Name
Name, eg shape name for simple markers.
@ DistanceY
Vertical distance between points.
@ LineEndColorValue
End line color for interpolated line renderer.
@ DensityArea
Density area.
@ ClipPoints
Whether markers should be clipped to polygon boundaries.
@ ArrowHeadThickness
Arrow head thickness.
@ LineClipping
Line clipping mode.
@ ShapeburstIgnoreRings
Shapeburst ignore rings.
@ Character
Character, eg for font marker symbol layers.
@ ShapeburstUseWholeShape
Shapeburst use whole shape.
@ DisplacementX
Horizontal displacement.
@ ShowMarker
Show markers.
@ CoordinateMode
Gradient coordinate mode.
@ FillStyle
Fill style (eg solid, dots)
@ GradientReference2X
Gradient reference point 2 x.
@ StrokeColor
Stroke color.
@ TrimStart
Trim distance from start of line.
@ ArrowStartWidth
Arrow tail start width.
@ CapStyle
Line cap style.
@ BlurRadius
Shapeburst blur radius.
@ Placement
Line marker placement.
@ MarkerClipping
Marker clipping mode.
@ RandomSeed
Random number seed.
@ LineAngle
Line angle, or angle of hash lines for hash line symbols.
@ JoinStyle
Line join style.
@ RandomOffsetY
Random offset Y.
@ DisplacementY
Vertical displacement.
@ PreserveAspectRatio
Preserve aspect ratio between width and height.
@ LineStartColorValue
Start line color for interpolated line renderer.
@ DistanceX
Horizontal distance between points.
@ AverageAngleLength
Length to average symbol angles over.
@ LineEndWidthValue
End line width for interpolated line renderer.
@ GradientReference1IsCentroid
Gradient reference point 1 is centroid.
@ Interval
Line marker interval.
@ StrokeWidth
Stroke width.
@ FontFamily
Font family.
@ GradientReference2IsCentroid
Gradient reference point 2 is centroid.
@ LineStartWidthValue
Start line width for interpolated line renderer.
@ LineDistance
Distance between lines, or length of lines for hash line symbols.
@ Offset
Symbol offset.
@ RandomOffsetX
Random offset X.
@ TrimEnd
Trim distance from end of line.
@ Height
Symbol height.
@ LayerEnabled
Whether symbol layer is enabled.
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.
QgsSymbolLayer(const QgsSymbolLayer &other)=delete
std::unique_ptr< QgsPaintEffect > mPaintEffect
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual void setFillColor(const QColor &color)
Sets the fill color for the symbol layer.
virtual void prepareExpressions(const QgsSymbolRenderContext &context)
Prepares all data defined property expressions for evaluation.
void setUserFlags(Qgis::SymbolLayerUserFlags flags)
Sets user-controlled flags which control the symbol layer's behavior.
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.
QString id() const
Returns symbol layer identifier This id is unique in the whole project.
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
virtual void setColor(const QColor &color)
Sets the "representative" color for the symbol layer.
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
Qgis::SymbolLayerUserFlags userFlags() const
Returns user-controlled flags which control the symbol layer's behavior.
virtual QColor color() const
Returns the "representative" color of the symbol layer.
virtual void prepareMasks(const QgsSymbolRenderContext &context)
Prepares all mask internal objects according to what is defined in context This should be called prio...
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 QColor strokeColor() const
Returns the stroke color for the symbol layer.
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
Qgis::SymbolLayerUserFlags mUserFlags
User controlled flags.
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
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.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual QVector< qreal > dxfCustomDashPattern(Qgis::RenderUnit &unit) const
Gets dash pattern.
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.
bool selected() const
Returns true if symbols should be rendered using the selected symbol coloring and style.
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.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:231
Qgis::SymbolType type() const
Returns the symbol's type.
Definition qgssymbol.h:293
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
Qgis::VectorRenderingSimplificationFlags simplifyHints() const
Gets the simplification hints of the vector layer managed.
float threshold() const
Gets the simplification threshold of the vector layer managed.
Contains geos related utilities and functions.
Definition qgsgeos.h:75
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:38
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
QgsProperty propertyFromMap(const QVariantMap &map, const QString &baseName)
QPainterPath generateClipPath(const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries)
#define DEG2RAD(x)
Single variable definition for use within a QgsExpressionContextScope.