Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgssymbollayer.h
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 : : #ifndef QGSSYMBOLLAYER_H
16 : : #define QGSSYMBOLLAYER_H
17 : :
18 : : #define DEG2RAD(x) ((x)*M_PI/180)
19 : : #define DEFAULT_SCALE_METHOD QgsSymbol::ScaleDiameter
20 : :
21 : : #include "qgis_core.h"
22 : : // #include "qgis.h"
23 : : #include <QColor>
24 : : #include <QMap>
25 : : #include <QPointF>
26 : : #include <QSet>
27 : : #include <QDomDocument>
28 : : #include <QDomElement>
29 : : #include <QPainterPath>
30 : :
31 : : #include "qgssymbol.h"
32 : : #include "qgsfields.h"
33 : : #include "qgspropertycollection.h"
34 : : #include "qgspainteffect.h"
35 : :
36 : : class QPainter;
37 : : class QSize;
38 : : class QPolygonF;
39 : :
40 : : class QgsDxfExport;
41 : : class QgsExpression;
42 : : class QgsRenderContext;
43 : :
44 : : #ifndef SIP_RUN
45 : : typedef QMap<QString, QString> QgsStringMap;
46 : : #endif
47 : :
48 : : /**
49 : : * \ingroup core
50 : : * \class QgsSymbolLayer
51 : : */
52 : : class CORE_EXPORT QgsSymbolLayer
53 : : {
54 : : #ifdef SIP_RUN
55 : : #include <qgslinesymbollayer.h>
56 : : #endif
57 : :
58 : :
59 : : #ifdef SIP_RUN
60 : : SIP_CONVERT_TO_SUBCLASS_CODE
61 : : switch ( sipCpp->type() )
62 : : {
63 : : case QgsSymbol::Marker:
64 : : if ( sipCpp->layerType() == "EllipseMarker" )
65 : : sipType = sipType_QgsEllipseSymbolLayer;
66 : : else if ( sipCpp->layerType() == "FontMarker" )
67 : : sipType = sipType_QgsFontMarkerSymbolLayer;
68 : : else if ( sipCpp->layerType() == "SimpleMarker" )
69 : : sipType = sipType_QgsSimpleMarkerSymbolLayer;
70 : : else if ( sipCpp->layerType() == "FilledMarker" )
71 : : sipType = sipType_QgsFilledMarkerSymbolLayer;
72 : : else if ( sipCpp->layerType() == "SvgMarker" )
73 : : sipType = sipType_QgsSvgMarkerSymbolLayer;
74 : : else if ( sipCpp->layerType() == "RasterMarker" )
75 : : sipType = sipType_QgsRasterMarkerSymbolLayer;
76 : : else if ( sipCpp->layerType() == "VectorField" )
77 : : sipType = sipType_QgsVectorFieldSymbolLayer;
78 : : else if ( sipCpp->layerType() == "MaskMarker" )
79 : : sipType = sipType_QgsMaskMarkerSymbolLayer;
80 : : else
81 : : sipType = sipType_QgsMarkerSymbolLayer;
82 : : break;
83 : :
84 : : case QgsSymbol::Line:
85 : : if ( sipCpp->layerType() == "MarkerLine" )
86 : : sipType = sipType_QgsMarkerLineSymbolLayer;
87 : : else if ( sipCpp->layerType() == "SimpleLine" )
88 : : sipType = sipType_QgsSimpleLineSymbolLayer;
89 : : else if ( sipCpp->layerType() == "ArrowLine" )
90 : : sipType = sipType_QgsArrowSymbolLayer;
91 : : else
92 : : sipType = sipType_QgsLineSymbolLayer;
93 : : break;
94 : :
95 : : case QgsSymbol::Fill:
96 : : if ( sipCpp->layerType() == "SimpleFill" )
97 : : sipType = sipType_QgsSimpleFillSymbolLayer;
98 : : else if ( sipCpp->layerType() == "LinePatternFill" )
99 : : sipType = sipType_QgsLinePatternFillSymbolLayer;
100 : : else if ( sipCpp->layerType() == "PointPatternFill" )
101 : : sipType = sipType_QgsPointPatternFillSymbolLayer;
102 : : else if ( sipCpp->layerType() == "SVGFill" )
103 : : sipType = sipType_QgsSVGFillSymbolLayer;
104 : : else if ( sipCpp->layerType() == "RasterFill" )
105 : : sipType = sipType_QgsRasterFillSymbolLayer;
106 : : else if ( sipCpp->layerType() == "CentroidFill" )
107 : : sipType = sipType_QgsCentroidFillSymbolLayer;
108 : : else if ( sipCpp->layerType() == "GradientFill" )
109 : : sipType = sipType_QgsGradientFillSymbolLayer;
110 : : else if ( sipCpp->layerType() == "ShapeburstFill" )
111 : : sipType = sipType_QgsShapeburstFillSymbolLayer;
112 : : else if ( sipCpp->layerType() == "RandomMarkerFill" )
113 : : sipType = sipType_QgsRandomMarkerFillSymbolLayer;
114 : : else
115 : : sipType = sipType_QgsFillSymbolLayer;
116 : : break;
117 : :
118 : : case QgsSymbol::Hybrid:
119 : : sipType = sipType_QgsGeometryGeneratorSymbolLayer;
120 : : break;
121 : : }
122 : : SIP_END
123 : : #endif
124 : : public:
125 : :
126 : : /**
127 : : * Data definable properties.
128 : : * \since QGIS 3.0
129 : : */
130 : : enum Property
131 : : {
132 : : PropertySize = 0, //!< Symbol size
133 : : PropertyAngle, //!< Symbol angle
134 : : PropertyName, //!< Name, eg shape name for simple markers
135 : : PropertyFillColor, //!< Fill color
136 : : PropertyStrokeColor, //!< Stroke color
137 : : PropertyStrokeWidth, //!< Stroke width
138 : : PropertyStrokeStyle, //!< Stroke style (eg solid, dashed)
139 : : PropertyOffset, //!< Symbol offset
140 : : PropertyCharacter, //!< Character, eg for font marker symbol layers
141 : : PropertyWidth, //!< Symbol width
142 : : PropertyHeight, //!< Symbol height
143 : : PropertyPreserveAspectRatio, //!< Preserve aspect ratio between width and height
144 : : PropertyFillStyle, //!< Fill style (eg solid, dots)
145 : : PropertyJoinStyle, //!< Line join style
146 : : PropertySecondaryColor, //!< Secondary color (eg for gradient fills)
147 : : PropertyLineAngle, //!< Line angle, or angle of hash lines for hash line symbols
148 : : PropertyLineDistance, //!< Distance between lines, or length of lines for hash line symbols
149 : : PropertyGradientType, //!< Gradient fill type
150 : : PropertyCoordinateMode, //!< Gradient coordinate mode
151 : : PropertyGradientSpread, //!< Gradient spread mode
152 : : PropertyGradientReference1X, //!< Gradient reference point 1 x
153 : : PropertyGradientReference1Y, //!< Gradient reference point 1 y
154 : : PropertyGradientReference2X, //!< Gradient reference point 2 x
155 : : PropertyGradientReference2Y, //!< Gradient reference point 2 y
156 : : PropertyGradientReference1IsCentroid, //!< Gradient reference point 1 is centroid
157 : : PropertyGradientReference2IsCentroid, //!< Gradient reference point 2 is centroid
158 : : PropertyBlurRadius, //!< Shapeburst blur radius
159 : : PropertyShapeburstUseWholeShape, //!< Shapeburst use whole shape
160 : : PropertyShapeburstMaxDistance, //!< Shapeburst fill from edge distance
161 : : PropertyShapeburstIgnoreRings, //!< Shapeburst ignore rings
162 : : PropertyFile, //!< Filename, eg for svg files
163 : : PropertyDistanceX, //!< Horizontal distance between points
164 : : PropertyDistanceY, //!< Vertical distance between points
165 : : PropertyDisplacementX, //!< Horizontal displacement
166 : : PropertyDisplacementY, //!< Vertical displacement
167 : : PropertyOpacity, //!< Opacity
168 : : PropertyCustomDash, //!< Custom dash pattern
169 : : PropertyCapStyle, //!< Line cap style
170 : : PropertyPlacement, //!< Line marker placement
171 : : PropertyInterval, //!< Line marker interval
172 : : PropertyOffsetAlongLine, //!< Offset along line
173 : : PropertyAverageAngleLength, //!< Length to average symbol angles over
174 : : PropertyHorizontalAnchor, //!< Horizontal anchor point
175 : : PropertyVerticalAnchor, //!< Vertical anchor point
176 : : PropertyLayerEnabled, //!< Whether symbol layer is enabled
177 : : PropertyArrowWidth, //!< Arrow tail width
178 : : PropertyArrowStartWidth, //!< Arrow tail start width
179 : : PropertyArrowHeadLength, //!< Arrow head length
180 : : PropertyArrowHeadThickness, //!< Arrow head thickness
181 : : PropertyArrowHeadType, //!< Arrow head type
182 : : PropertyArrowType, //!< Arrow type
183 : : PropertyOffsetX, //!< Horizontal offset
184 : : PropertyOffsetY, //!< Vertical offset
185 : : PropertyPointCount, //!< Point count
186 : : PropertyRandomSeed, //!< Random number seed
187 : : PropertyClipPoints, //!< Whether markers should be clipped to polygon boundaries
188 : : PropertyDensityArea, //!< Density area
189 : : PropertyFontFamily, //!< Font family
190 : : PropertyFontStyle, //!< Font style
191 : : PropertyDashPatternOffset, //!< Dash pattern offset,
192 : : PropertyTrimStart, //!< Trim distance from start of line (since QGIS 3.20)
193 : : PropertyTrimEnd, //!< Trim distance from end of line (since QGIS 3.20)
194 : : };
195 : :
196 : : /**
197 : : * Returns the symbol layer property definitions.
198 : : * \since QGIS 3.0
199 : : */
200 : : static const QgsPropertiesDefinition &propertyDefinitions();
201 : :
202 : : virtual ~QgsSymbolLayer();
203 : :
204 : : //! QgsSymbolLayer cannot be copied
205 : : QgsSymbolLayer( const QgsSymbolLayer &other ) = delete;
206 : :
207 : : //! QgsSymbolLayer cannot be copied
208 : : QgsSymbolLayer &operator=( const QgsSymbolLayer &other ) = delete;
209 : :
210 : : /**
211 : : * Returns TRUE if symbol layer is enabled and will be drawn.
212 : : * \see setEnabled()
213 : : * \since QGIS 3.0
214 : : */
215 : 0 : bool enabled() const { return mEnabled; }
216 : :
217 : : /**
218 : : * Sets whether symbol layer is enabled and should be drawn. Disabled
219 : : * layers are not drawn, but remain part of the symbol and can be re-enabled
220 : : * when desired.
221 : : * \see enabled()
222 : : * \since QGIS 3.0
223 : : */
224 : 990 : void setEnabled( bool enabled ) { mEnabled = enabled; }
225 : :
226 : : /**
227 : : * The fill color.
228 : : */
229 : 10 : virtual QColor color() const { return mColor; }
230 : :
231 : : /**
232 : : * The fill color.
233 : : */
234 : 166 : virtual void setColor( const QColor &color ) { mColor = color; }
235 : :
236 : : /**
237 : : * Set stroke color. Supported by marker and fill layers.
238 : : * \since QGIS 2.1
239 : : */
240 : 0 : virtual void setStrokeColor( const QColor &color ) { Q_UNUSED( color ) }
241 : :
242 : : /**
243 : : * Gets stroke color. Supported by marker and fill layers.
244 : : * \since QGIS 2.1
245 : : */
246 : 0 : virtual QColor strokeColor() const { return QColor(); }
247 : :
248 : : /**
249 : : * Set fill color. Supported by marker and fill layers.
250 : : * \since QGIS 2.1
251 : : */
252 : 0 : virtual void setFillColor( const QColor &color ) { Q_UNUSED( color ) }
253 : :
254 : : /**
255 : : * Gets fill color. Supported by marker and fill layers.
256 : : * \since QGIS 2.1
257 : : */
258 : 0 : virtual QColor fillColor() const { return QColor(); }
259 : :
260 : : /**
261 : : * Returns a string that represents this layer type. Used for serialization.
262 : : * Should match with the string used to register this symbol layer in the registry.
263 : : */
264 : : virtual QString layerType() const = 0;
265 : :
266 : : /**
267 : : * Called before a set of rendering operations commences on the supplied render \a context.
268 : : *
269 : : * This is always followed by a call to stopRender() after all rendering operations
270 : : * have been completed.
271 : : *
272 : : * Subclasses can use this method to prepare for a set of rendering operations, e.g. by
273 : : * pre-evaluating paths or images to render, and performing other one-time optimisations.
274 : : *
275 : : * \see startFeatureRender()
276 : : * \see stopRender()
277 : : */
278 : : virtual void startRender( QgsSymbolRenderContext &context ) = 0;
279 : :
280 : : /**
281 : : * Called after a set of rendering operations has finished on the supplied render \a context.
282 : : *
283 : : * This is always preceded by a call to startRender() before all rendering operations
284 : : * are commenced.
285 : : *
286 : : * Subclasses can use this method to cleanup after a set of rendering operations.
287 : : *
288 : : * \see startRender()
289 : : * \see stopFeatureRender()
290 : : */
291 : : virtual void stopRender( QgsSymbolRenderContext &context ) = 0;
292 : :
293 : : /**
294 : : * Called before the layer will be rendered for a particular \a feature.
295 : : *
296 : : * This is always followed by a call to stopFeatureRender() after the feature
297 : : * has been completely rendered (i.e. all parts have been rendered).
298 : : *
299 : : * The default implementation does nothing.
300 : : *
301 : : * \note In some circumstances, startFeatureRender() and stopFeatureRender() may not be called
302 : : * before a symbol layer is rendered. E.g., when a symbol layer is being rendered in isolation
303 : : * and not as a result of rendering a feature (for instance, when rendering a legend patch or other
304 : : * non-feature based shape).
305 : : *
306 : : * \see stopFeatureRender()
307 : : * \see startRender()
308 : : *
309 : : * \since QGIS 3.12
310 : : */
311 : : virtual void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context );
312 : :
313 : : /**
314 : : * Called after the layer has been rendered for a particular \a feature.
315 : : *
316 : : * This is always preceded by a call to startFeatureRender() just before the feature
317 : : * will be rendered.
318 : : *
319 : : * The default implementation does nothing.
320 : : *
321 : : * \note In some circumstances, startFeatureRender() and stopFeatureRender() may not be called
322 : : * before a symbol layer is rendered. E.g., when a symbol layer is being rendered in isolation
323 : : * and not as a result of rendering a feature (for instance, when rendering a legend patch or other
324 : : * non-feature based shape).
325 : : *
326 : : * \see startFeatureRender()
327 : : * \see stopRender()
328 : : *
329 : : * \since QGIS 3.12
330 : : */
331 : : virtual void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context );
332 : :
333 : : /**
334 : : * Shall be reimplemented by subclasses to create a deep copy of the instance.
335 : : */
336 : : virtual QgsSymbolLayer *clone() const = 0 SIP_FACTORY;
337 : :
338 : : //! Saves the symbol layer as SLD
339 : 0 : virtual void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
340 : 0 : { Q_UNUSED( props ) element.appendChild( doc.createComment( QStringLiteral( "SymbolLayerV2 %1 not implemented yet" ).arg( layerType() ) ) ); }
341 : :
342 : 0 : virtual QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const { Q_UNUSED( mmScaleFactor ) Q_UNUSED( mapUnitScaleFactor ); return QString(); }
343 : :
344 : : /**
345 : : * Should be reimplemented by subclasses to return a string map that
346 : : * contains the configuration information for the symbol layer. This
347 : : * is used to serialize a symbol layer perstistently.
348 : : */
349 : : virtual QVariantMap properties() const = 0;
350 : :
351 : : virtual void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) = 0;
352 : :
353 : : /**
354 : : * Returns the symbol's sub symbol, if present.
355 : : */
356 : 0 : virtual QgsSymbol *subSymbol() { return nullptr; }
357 : :
358 : : //! Sets layer's subsymbol. takes ownership of the passed symbol
359 : 0 : virtual bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) { delete symbol; return false; }
360 : :
361 : 0 : QgsSymbol::SymbolType type() const { return mType; }
362 : :
363 : : //! Returns if the layer can be used below the specified symbol
364 : : virtual bool isCompatibleWithSymbol( QgsSymbol *symbol ) const;
365 : :
366 : : /**
367 : : * Returns TRUE if the symbol layer rendering can cause visible artifacts across a single feature
368 : : * when the feature is rendered as a series of adjacent map tiles each containing a portion of the feature's geometry.
369 : : *
370 : : * The default implementation returns FALSE.
371 : : *
372 : : * \since QGIS 3.18
373 : : */
374 : : virtual bool canCauseArtifactsBetweenAdjacentTiles() const;
375 : :
376 : 990 : void setLocked( bool locked ) { mLocked = locked; }
377 : 238 : bool isLocked() const { return mLocked; }
378 : :
379 : : /**
380 : : * Returns the estimated maximum distance which the layer style will bleed outside
381 : : * the drawn shape when drawn in the specified /a context. For example, polygons
382 : : * drawn with an stroke will draw half the width
383 : : * of the stroke outside of the polygon. This amount is estimated, since it may
384 : : * be affected by data defined symbology rules.
385 : : */
386 : 0 : virtual double estimateMaxBleed( const QgsRenderContext &context ) const { Q_UNUSED( context ) return 0; }
387 : :
388 : : /**
389 : : * Sets the units to use for sizes and widths within the symbol layer. Individual
390 : : * symbol layer subclasses will interpret this in different ways, e.g., a marker symbol
391 : : * layer may use it to specify the units for the marker size, while a line symbol
392 : : * layer may use it to specify the units for the line width.
393 : : * \param unit output units
394 : : * \see outputUnit()
395 : : */
396 : 0 : virtual void setOutputUnit( QgsUnitTypes::RenderUnit unit ) { Q_UNUSED( unit ) }
397 : :
398 : : /**
399 : : * Returns the units to use for sizes and widths within the symbol layer. Individual
400 : : * symbol layer subclasses will interpret this in different ways, e.g., a marker symbol
401 : : * layer may use it to specify the units for the marker size, while a line symbol
402 : : * layer may use it to specify the units for the line width.
403 : : * \returns output unit, or QgsUnitTypes::RenderUnknownUnit if the symbol layer contains mixed units
404 : : * \see setOutputUnit()
405 : : */
406 : 0 : virtual QgsUnitTypes::RenderUnit outputUnit() const { return QgsUnitTypes::RenderUnknownUnit; }
407 : :
408 : : /**
409 : : * Returns TRUE if the symbol layer has any components which use map unit based sizes.
410 : : *
411 : : * \since QGIS 3.18
412 : : */
413 : : virtual bool usesMapUnits() const;
414 : :
415 : 0 : virtual void setMapUnitScale( const QgsMapUnitScale &scale ) { Q_UNUSED( scale ) }
416 : 0 : virtual QgsMapUnitScale mapUnitScale() const { return QgsMapUnitScale(); }
417 : :
418 : : /**
419 : : * Specifies the rendering pass in which this symbol layer should be rendered.
420 : : * The lower the number, the lower the symbol will be rendered.
421 : : * 0: first pass, 1: second pass, ...
422 : : * Defaults to 0
423 : : */
424 : : void setRenderingPass( int renderingPass );
425 : :
426 : : /**
427 : : * Specifies the rendering pass in which this symbol layer should be rendered.
428 : : * The lower the number, the lower the symbol will be rendered.
429 : : * 0: first pass, 1: second pass, ...
430 : : * Defaults to 0
431 : : */
432 : : int renderingPass() const;
433 : :
434 : : /**
435 : : * Returns the set of attributes referenced by the layer. This includes attributes
436 : : * required by any data defined properties associated with the layer.
437 : : */
438 : : virtual QSet<QString> usedAttributes( const QgsRenderContext &context ) const;
439 : :
440 : : /**
441 : : * Sets a data defined property for the layer. Any existing property with the same key
442 : : * will be overwritten.
443 : : * \see dataDefinedProperties()
444 : : * \see Property
445 : : * \since QGIS 3.0
446 : : */
447 : : virtual void setDataDefinedProperty( Property key, const QgsProperty &property );
448 : :
449 : : //! write as DXF
450 : : virtual bool writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift = QPointF( 0.0, 0.0 ) ) const;
451 : :
452 : : //! Gets line width
453 : : virtual double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const;
454 : :
455 : : //! Gets offset
456 : : virtual double dxfOffset( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const;
457 : :
458 : : //! Gets color
459 : : virtual QColor dxfColor( QgsSymbolRenderContext &context ) const;
460 : :
461 : : //! Gets angle
462 : : virtual double dxfAngle( QgsSymbolRenderContext &context ) const;
463 : :
464 : : //! Gets dash pattern
465 : : virtual QVector<qreal> dxfCustomDashPattern( QgsUnitTypes::RenderUnit &unit ) const;
466 : :
467 : : //! Gets pen style
468 : : virtual Qt::PenStyle dxfPenStyle() const;
469 : :
470 : : //! Gets brush/fill color
471 : : virtual QColor dxfBrushColor( QgsSymbolRenderContext &context ) const;
472 : :
473 : : //! Gets brush/fill style
474 : : virtual Qt::BrushStyle dxfBrushStyle() const;
475 : :
476 : : /**
477 : : * Returns the current paint effect for the layer.
478 : : * \returns paint effect
479 : : * \see setPaintEffect
480 : : * \since QGIS 2.9
481 : : */
482 : : QgsPaintEffect *paintEffect() const;
483 : :
484 : : /**
485 : : * Sets the current paint effect for the layer.
486 : : * \param effect paint effect. Ownership is transferred to the layer.
487 : : * \see paintEffect
488 : : * \since QGIS 2.9
489 : : */
490 : : void setPaintEffect( QgsPaintEffect *effect SIP_TRANSFER );
491 : :
492 : : /**
493 : : * Prepares all data defined property expressions for evaluation. This should
494 : : * be called prior to evaluating data defined properties.
495 : : * \param context symbol render context
496 : : * \since QGIS 2.12
497 : : */
498 : : virtual void prepareExpressions( const QgsSymbolRenderContext &context );
499 : :
500 : : /**
501 : : * Returns a reference to the symbol layer's property collection, used for data defined overrides.
502 : : * \see setDataDefinedProperties()
503 : : * \see Property
504 : : * \since QGIS 3.0
505 : : */
506 : 990 : QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }
507 : :
508 : : /**
509 : : * Returns a reference to the symbol layer's property collection, used for data defined overrides.
510 : : * \see setDataDefinedProperties()
511 : : * \since QGIS 3.0
512 : : */
513 : 0 : const QgsPropertyCollection &dataDefinedProperties() const { return mDataDefinedProperties; } SIP_SKIP
514 : :
515 : : /**
516 : : * Sets the symbol layer's property collection, used for data defined overrides.
517 : : * \param collection property collection. Existing properties will be replaced.
518 : : * \see dataDefinedProperties()
519 : : * \since QGIS 3.0
520 : : */
521 : 0 : void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }
522 : :
523 : : /**
524 : : * Returns TRUE if the symbol layer (or any of its sub-symbols) contains data defined properties.
525 : : *
526 : : * \since QGIS 3.4.5
527 : : */
528 : : virtual bool hasDataDefinedProperties() const;
529 : :
530 : : /**
531 : : * Returns masks defined by this symbol layer.
532 : : * This is a list of symbol layers of other layers that should be occluded.
533 : : * \since QGIS 3.12
534 : : */
535 : : virtual QgsSymbolLayerReferenceList masks() const;
536 : :
537 : : protected:
538 : :
539 : : QgsSymbolLayer( QgsSymbol::SymbolType type, bool locked = false );
540 : :
541 : : QgsSymbol::SymbolType mType;
542 : :
543 : : //! True if layer is enabled and should be drawn
544 : : bool mEnabled = true;
545 : :
546 : : bool mLocked = false;
547 : : QColor mColor;
548 : : int mRenderingPass = 0;
549 : :
550 : : QgsPropertyCollection mDataDefinedProperties;
551 : :
552 : : std::unique_ptr< QgsPaintEffect > mPaintEffect;
553 : : QgsFields mFields;
554 : :
555 : : // Configuration of selected symbology implementation
556 : : //! Whether styles for selected features ignore symbol alpha
557 : : static const bool SELECTION_IS_OPAQUE = true;
558 : : //! Whether fill styles for selected features also highlight symbol stroke
559 : : static const bool SELECT_FILL_BORDER = false;
560 : : //! Whether fill styles for selected features uses symbol layer style
561 : : static const bool SELECT_FILL_STYLE = false;
562 : :
563 : : /**
564 : : * Restores older data defined properties from string map.
565 : : * \since QGIS 3.0
566 : : */
567 : : void restoreOldDataDefinedProperties( const QVariantMap &stringMap );
568 : :
569 : : /**
570 : : * Copies all data defined properties of this layer to another symbol layer.
571 : : * \param destLayer destination layer
572 : : */
573 : : void copyDataDefinedProperties( QgsSymbolLayer *destLayer ) const;
574 : :
575 : : /**
576 : : * Copies paint effect of this layer to another symbol layer
577 : : * \param destLayer destination layer
578 : : * \since QGIS 2.9
579 : : */
580 : : void copyPaintEffect( QgsSymbolLayer *destLayer ) const;
581 : :
582 : : private:
583 : : static void initPropertyDefinitions();
584 : :
585 : : //! Property definitions
586 : : static QgsPropertiesDefinition sPropertyDefinitions;
587 : :
588 : : #ifdef SIP_RUN
589 : : QgsSymbolLayer( const QgsSymbolLayer &other );
590 : : #endif
591 : :
592 : : };
593 : :
594 : : //////////////////////
595 : :
596 : : /**
597 : : * \ingroup core
598 : : * \class QgsMarkerSymbolLayer
599 : : * \brief Abstract base class for marker symbol layers.
600 : : */
601 : 258 : class CORE_EXPORT QgsMarkerSymbolLayer : public QgsSymbolLayer
602 : : {
603 : : public:
604 : :
605 : : //! Symbol horizontal anchor points
606 : : enum HorizontalAnchorPoint
607 : : {
608 : : Left, //!< Align to left side of symbol
609 : : HCenter, //!< Align to horizontal center of symbol
610 : : Right, //!< Align to right side of symbol
611 : : };
612 : :
613 : : //! Symbol vertical anchor points
614 : : enum VerticalAnchorPoint
615 : : {
616 : : Top, //!< Align to top of symbol
617 : : VCenter, //!< Align to vertical center of symbol
618 : : Bottom, //!< Align to bottom of symbol
619 : : };
620 : :
621 : : //! QgsMarkerSymbolLayer cannot be copied
622 : : QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other ) = delete;
623 : :
624 : : //! QgsMarkerSymbolLayer cannot be copied
625 : : QgsMarkerSymbolLayer &operator=( const QgsMarkerSymbolLayer &other ) = delete;
626 : :
627 : : void startRender( QgsSymbolRenderContext &context ) override;
628 : :
629 : : void stopRender( QgsSymbolRenderContext &context ) override;
630 : :
631 : : /**
632 : : * Renders a marker at the specified point. Derived classes must implement this to
633 : : * handle drawing the point.
634 : : * \param point position at which to render point, in painter units
635 : : * \param context symbol render context
636 : : */
637 : : virtual void renderPoint( QPointF point, QgsSymbolRenderContext &context ) = 0;
638 : :
639 : : void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;
640 : :
641 : : /**
642 : : * Sets the rotation angle for the marker.
643 : : * \param angle angle in degrees clockwise from north.
644 : : * \see angle()
645 : : * \see setLineAngle()
646 : : */
647 : 0 : void setAngle( double angle ) { mAngle = angle; }
648 : :
649 : : /**
650 : : * Returns the rotation angle for the marker, in degrees clockwise from north.
651 : : * \see setAngle()
652 : : */
653 : 0 : double angle() const { return mAngle; }
654 : :
655 : : /**
656 : : * Sets the line angle modification for the symbol's angle. This angle is added to
657 : : * the marker's rotation and data defined rotation before rendering the symbol, and
658 : : * is usually used for orienting symbols to match a line's angle.
659 : : * \param lineAngle Angle in degrees clockwise from north, valid values are between 0 and 360
660 : : * \see setAngle()
661 : : * \see angle()
662 : : * \since QGIS 2.9
663 : : */
664 : 0 : void setLineAngle( double lineAngle ) { mLineAngle = lineAngle; }
665 : :
666 : : /**
667 : : * Sets the symbol size.
668 : : * \param size symbol size. Units are specified by sizeUnit().
669 : : * \see size()
670 : : * \see setSizeUnit()
671 : : * \see setSizeMapUnitScale()
672 : : */
673 : 0 : virtual void setSize( double size ) { mSize = size; }
674 : :
675 : : /**
676 : : * Returns the symbol size. Units are specified by sizeUnit().
677 : : * \see setSize()
678 : : * \see sizeUnit()
679 : : * \see sizeMapUnitScale()
680 : : */
681 : 0 : double size() const { return mSize; }
682 : :
683 : : /**
684 : : * Sets the units for the symbol's size.
685 : : * \param unit size units
686 : : * \see sizeUnit()
687 : : * \see setSize()
688 : : * \see setSizeMapUnitScale()
689 : : */
690 : 270 : void setSizeUnit( QgsUnitTypes::RenderUnit unit ) { mSizeUnit = unit; }
691 : :
692 : : /**
693 : : * Returns the units for the symbol's size.
694 : : * \see setSizeUnit()
695 : : * \see size()
696 : : * \see sizeMapUnitScale()
697 : : */
698 : 0 : QgsUnitTypes::RenderUnit sizeUnit() const { return mSizeUnit; }
699 : :
700 : : /**
701 : : * Sets the map unit scale for the symbol's size.
702 : : * \param scale size map unit scale
703 : : * \see sizeMapUnitScale()
704 : : * \see setSize()
705 : : * \see setSizeUnit()
706 : : */
707 : 270 : void setSizeMapUnitScale( const QgsMapUnitScale &scale ) { mSizeMapUnitScale = scale; }
708 : :
709 : : /**
710 : : * Returns the map unit scale for the symbol's size.
711 : : * \see setSizeMapUnitScale()
712 : : * \see size()
713 : : * \see sizeUnit()
714 : : */
715 : 0 : const QgsMapUnitScale &sizeMapUnitScale() const { return mSizeMapUnitScale; }
716 : :
717 : : /**
718 : : * Sets the method to use for scaling the marker's size.
719 : : * \param scaleMethod scale method
720 : : * \see scaleMethod()
721 : : */
722 : 0 : void setScaleMethod( QgsSymbol::ScaleMethod scaleMethod ) { mScaleMethod = scaleMethod; }
723 : :
724 : : /**
725 : : * Returns the method to use for scaling the marker's size.
726 : : * \see setScaleMethod()
727 : : */
728 : 0 : QgsSymbol::ScaleMethod scaleMethod() const { return mScaleMethod; }
729 : :
730 : : /**
731 : : * Sets the marker's offset, which is the horizontal and vertical displacement which the rendered marker
732 : : * should have from the original feature's geometry.
733 : : * \param offset marker offset. Units are specified by offsetUnit()
734 : : * \see offset()
735 : : * \see setOffsetUnit()
736 : : * \see setOffsetMapUnitScale()
737 : : */
738 : 270 : void setOffset( QPointF offset ) { mOffset = offset; }
739 : :
740 : : /**
741 : : * Returns the marker's offset, which is the horizontal and vertical displacement which the rendered marker
742 : : * will have from the original feature's geometry. Units are specified by offsetUnit().
743 : : * \see setOffset()
744 : : * \see offsetUnit()
745 : : * \see offsetMapUnitScale()
746 : : */
747 : 0 : QPointF offset() const { return mOffset; }
748 : :
749 : : /**
750 : : * Sets the units for the symbol's offset.
751 : : * \param unit offset units
752 : : * \see offsetUnit()
753 : : * \see setOffset()
754 : : * \see setOffsetMapUnitScale()
755 : : */
756 : 270 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
757 : :
758 : : /**
759 : : * Returns the units for the symbol's offset.
760 : : * \see setOffsetUnit()
761 : : * \see offset()
762 : : * \see offsetMapUnitScale()
763 : : */
764 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
765 : :
766 : : /**
767 : : * Sets the map unit scale for the symbol's offset.
768 : : * \param scale offset map unit scale
769 : : * \see offsetMapUnitScale()
770 : : * \see setOffset()
771 : : * \see setOffsetUnit()
772 : : */
773 : 270 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
774 : :
775 : : /**
776 : : * Returns the map unit scale for the symbol's offset.
777 : : * \see setOffsetMapUnitScale()
778 : : * \see offset()
779 : : * \see offsetUnit()
780 : : */
781 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
782 : :
783 : : /**
784 : : * Sets the horizontal anchor point for positioning the symbol.
785 : : * \param h anchor point. Symbol will be drawn so that the horizontal anchor point is aligned with
786 : : * the marker's desired location.
787 : : * \see horizontalAnchorPoint()
788 : : * \see setVerticalAnchorPoint()
789 : : */
790 : 270 : void setHorizontalAnchorPoint( HorizontalAnchorPoint h ) { mHorizontalAnchorPoint = h; }
791 : :
792 : : /**
793 : : * Returns the horizontal anchor point for positioning the symbol. The symbol will be drawn so that
794 : : * the horizontal anchor point is aligned with the marker's desired location.
795 : : * \see setHorizontalAnchorPoint()
796 : : * \see verticalAnchorPoint()
797 : : */
798 : : HorizontalAnchorPoint horizontalAnchorPoint() const { return mHorizontalAnchorPoint; }
799 : :
800 : : /**
801 : : * Sets the vertical anchor point for positioning the symbol.
802 : : * \param v anchor point. Symbol will be drawn so that the vertical anchor point is aligned with
803 : : * the marker's desired location.
804 : : * \see verticalAnchorPoint()
805 : : * \see setHorizontalAnchorPoint()
806 : : */
807 : 270 : void setVerticalAnchorPoint( VerticalAnchorPoint v ) { mVerticalAnchorPoint = v; }
808 : :
809 : : /**
810 : : * Returns the vertical anchor point for positioning the symbol. The symbol will be drawn so that
811 : : * the vertical anchor point is aligned with the marker's desired location.
812 : : * \see setVerticalAnchorPoint()
813 : : * \see horizontalAnchorPoint()
814 : : */
815 : : VerticalAnchorPoint verticalAnchorPoint() const { return mVerticalAnchorPoint; }
816 : :
817 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
818 : :
819 : : /**
820 : : * Writes the symbol layer definition as a SLD XML element.
821 : : * \param doc XML document
822 : : * \param element parent XML element
823 : : * \param props symbol layer definition (see properties())
824 : : */
825 : 0 : virtual void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
826 : 0 : { Q_UNUSED( props ) element.appendChild( doc.createComment( QStringLiteral( "QgsMarkerSymbolLayer %1 not implemented yet" ).arg( layerType() ) ) ); }
827 : :
828 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
829 : : QgsUnitTypes::RenderUnit outputUnit() const override;
830 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
831 : : QgsMapUnitScale mapUnitScale() const override;
832 : :
833 : : /**
834 : : * Returns the approximate bounding box of the marker symbol layer, taking into account
835 : : * any data defined overrides and offsets which are set for the marker layer.
836 : : * \returns approximate symbol bounds, in painter units
837 : : * \since QGIS 2.14
838 : : */
839 : : virtual QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) = 0;
840 : :
841 : : protected:
842 : :
843 : : /**
844 : : * Constructor for QgsMarkerSymbolLayer.
845 : : * \param locked set to TRUE to lock symbol color
846 : : */
847 : : QgsMarkerSymbolLayer( bool locked = false );
848 : :
849 : : /**
850 : : * Calculates the required marker offset, including both the symbol offset
851 : : * and any displacement required to align with the marker's anchor point.
852 : : * \param context symbol render context
853 : : * \param offsetX will be set to required horizontal offset (in painter units)
854 : : * \param offsetY will be set to required vertical offset (in painter units)
855 : : */
856 : : void markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const;
857 : :
858 : : /**
859 : : * Calculates the required marker offset, including both the symbol offset
860 : : * and any displacement required to align with the marker's anchor point.
861 : : * \param context symbol render context
862 : : * \param width marker width
863 : : * \param height marker height
864 : : * \param offsetX will be set to required horizontal offset (in painter units)
865 : : * \param offsetY will be set to required vertical offset (in painter units)
866 : : * \note available in Python as markerOffsetWithWidthAndHeight
867 : : */
868 : : void markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const SIP_PYNAME( markerOffsetWithWidthAndHeight );
869 : :
870 : : //! \note available in Python bindings as markerOffset2
871 : : void markerOffset( QgsSymbolRenderContext &context, double width, double height,
872 : : QgsUnitTypes::RenderUnit widthUnit, QgsUnitTypes::RenderUnit heightUnit,
873 : : double &offsetX, double &offsetY,
874 : : const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const SIP_PYNAME( markerOffset2 );
875 : :
876 : : /**
877 : : * Adjusts a marker offset to account for rotation.
878 : : * \param offset offset prior to rotation
879 : : * \param angle rotation angle in degrees clockwise from north
880 : : * \returns adjusted offset
881 : : */
882 : : static QPointF _rotatedOffset( QPointF offset, double angle );
883 : :
884 : : //! Marker rotation angle, in degrees clockwise from north
885 : : double mAngle = 0;
886 : : //! Line rotation angle (see setLineAngle() for details)
887 : : double mLineAngle = 0;
888 : : //! Marker size
889 : : double mSize = 2.0;
890 : : //! Marker size unit
891 : : QgsUnitTypes::RenderUnit mSizeUnit = QgsUnitTypes::RenderMillimeters;
892 : : //! Marker size map unit scale
893 : : QgsMapUnitScale mSizeMapUnitScale;
894 : : //! Marker offset
895 : : QPointF mOffset;
896 : : //! Offset units
897 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
898 : : //! Offset map unit scale
899 : : QgsMapUnitScale mOffsetMapUnitScale;
900 : : //! Marker size scaling method
901 : : QgsSymbol::ScaleMethod mScaleMethod = QgsSymbol::ScaleDiameter;
902 : : //! Horizontal anchor point
903 : : HorizontalAnchorPoint mHorizontalAnchorPoint = HCenter;
904 : : //! Vertical anchor point
905 : : VerticalAnchorPoint mVerticalAnchorPoint = VCenter;
906 : :
907 : : private:
908 : : static QgsMarkerSymbolLayer::HorizontalAnchorPoint decodeHorizontalAnchorPoint( const QString &str );
909 : : static QgsMarkerSymbolLayer::VerticalAnchorPoint decodeVerticalAnchorPoint( const QString &str );
910 : :
911 : : #ifdef SIP_RUN
912 : : QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other );
913 : : #endif
914 : : };
915 : :
916 : : /**
917 : : * \ingroup core
918 : : * \class QgsLineSymbolLayer
919 : : */
920 : 437 : class CORE_EXPORT QgsLineSymbolLayer : public QgsSymbolLayer
921 : : {
922 : : public:
923 : :
924 : : //! Options for filtering rings when the line symbol layer is being used to render a polygon's rings.
925 : : enum RenderRingFilter
926 : : {
927 : : AllRings, //!< Render both exterior and interior rings
928 : : ExteriorRingOnly, //!< Render the exterior ring only
929 : : InteriorRingsOnly, //!< Render the interior rings only
930 : : };
931 : :
932 : : //! QgsLineSymbolLayer cannot be copied
933 : : QgsLineSymbolLayer( const QgsLineSymbolLayer &other ) = delete;
934 : :
935 : : //! QgsLineSymbolLayer cannot be copied
936 : : QgsLineSymbolLayer &operator=( const QgsLineSymbolLayer &other ) = delete;
937 : :
938 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
939 : : QgsUnitTypes::RenderUnit outputUnit() const override;
940 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
941 : : QgsMapUnitScale mapUnitScale() const override;
942 : : void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;
943 : : double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
944 : :
945 : : /**
946 : : * Renders the line symbol layer along the line joining \a points, using the given render \a context.
947 : : * \see renderPolygonStroke()
948 : : */
949 : : virtual void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) = 0;
950 : :
951 : : /**
952 : : * Renders the line symbol layer along the outline of polygon, using the given render \a context.
953 : : *
954 : : * The exterior ring of the polygon is specified in \a points. Optionally, interior
955 : : * rings are set via the \a rings argument.
956 : : *
957 : : * \see renderPolyline()
958 : : */
959 : : virtual void renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context );
960 : :
961 : : /**
962 : : * Sets the \a width of the line symbol layer.
963 : : *
964 : : * Calling this method updates the width of the line symbol layer, without
965 : : * changing the existing width units. It has different effects depending
966 : : * on the line symbol layer subclass, e.g. for a simple line layer it
967 : : * changes the stroke width of the line, for a marker line layer it
968 : : * changes the size of the markers used to draw the line.
969 : : *
970 : : * \see width()
971 : : * \warning Since the width units vary, this method is useful for changing the
972 : : * relative width of a line symbol layer only.
973 : : */
974 : 70 : virtual void setWidth( double width ) { mWidth = width; }
975 : :
976 : : /**
977 : : * Returns the estimated width for the line symbol layer.
978 : : *
979 : : * \warning This returned value is inaccurate if the symbol layer has sub-symbols with
980 : : * different width units. Use the overload accepting a QgsRenderContext
981 : : * argument instead for accurate sizes in this case.
982 : : *
983 : : * \see setWidth()
984 : : */
985 : 140 : virtual double width() const { return mWidth; }
986 : :
987 : : /**
988 : : * Returns the line symbol layer width, in painter units.
989 : : *
990 : : * This method returns an accurate width by calculating the actual rendered
991 : : * width of the symbol layer using the provided render \a context.
992 : : *
993 : : * \see setWidth()
994 : : *
995 : : * \since QGIS 3.4.5
996 : : */
997 : : virtual double width( const QgsRenderContext &context ) const;
998 : :
999 : : /**
1000 : : * Returns the line's offset.
1001 : : *
1002 : : * Offset units can be retrieved by calling offsetUnit().
1003 : : *
1004 : : * \see setOffset()
1005 : : * \see offsetUnit()
1006 : : * \see offsetMapUnitScale()
1007 : : */
1008 : 70 : double offset() const { return mOffset; }
1009 : :
1010 : : /**
1011 : : * Sets the line's \a offset.
1012 : : *
1013 : : * Offset units are set via setOffsetUnit().
1014 : : *
1015 : : * \see offset()
1016 : : * \see setOffsetUnit()
1017 : : * \see setOffsetMapUnitScale()
1018 : : */
1019 : 410 : void setOffset( double offset ) { mOffset = offset; }
1020 : :
1021 : : /**
1022 : : * Sets the \a unit for the line's offset.
1023 : : * \see offsetUnit()
1024 : : * \see setOffset()
1025 : : * \see setOffsetMapUnitScale()
1026 : : */
1027 : 410 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
1028 : :
1029 : : /**
1030 : : * Returns the units for the line's offset.
1031 : : * \see setOffsetUnit()
1032 : : * \see offset()
1033 : : * \see offsetMapUnitScale()
1034 : : */
1035 : 0 : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
1036 : :
1037 : : /**
1038 : : * Sets the map unit \a scale for the line's offset.
1039 : : * \see offsetMapUnitScale()
1040 : : * \see setOffset()
1041 : : * \see setOffsetUnit()
1042 : : */
1043 : 405 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1044 : :
1045 : : /**
1046 : : * Returns the map unit scale for the line's offset.
1047 : : * \see setOffsetMapUnitScale()
1048 : : * \see offset()
1049 : : * \see offsetUnit()
1050 : : */
1051 : 0 : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1052 : :
1053 : : // TODO QGIS 4.0 - setWidthUnit(), widthUnit(), setWidthUnitScale(), widthUnitScale()
1054 : : // only apply to simple line symbol layers and do not belong here.
1055 : :
1056 : : /**
1057 : : * Sets the units for the line's width.
1058 : : * \param unit width units
1059 : : * \see widthUnit()
1060 : : */
1061 : 355 : void setWidthUnit( QgsUnitTypes::RenderUnit unit ) { mWidthUnit = unit; }
1062 : :
1063 : : /**
1064 : : * Returns the units for the line's width.
1065 : : * \see setWidthUnit()
1066 : : */
1067 : 0 : QgsUnitTypes::RenderUnit widthUnit() const { return mWidthUnit; }
1068 : :
1069 : 355 : void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
1070 : : const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }
1071 : :
1072 : : /**
1073 : : * Returns the line symbol layer's ring filter, which controls which rings are
1074 : : * rendered when the line symbol is being used to draw a polygon's rings.
1075 : : *
1076 : : * This setting has no effect when the line symbol is not being rendered
1077 : : * for a polygon.
1078 : : *
1079 : : * \see setRingFilter()
1080 : : * \since QGIS 3.6
1081 : : */
1082 : : RenderRingFilter ringFilter() const;
1083 : :
1084 : : /**
1085 : : * Sets the line symbol layer's ring \a filter, which controls which rings are
1086 : : * rendered when the line symbol is being used to draw a polygon's rings.
1087 : : *
1088 : : * This setting has no effect when the line symbol is not being rendered
1089 : : * for a polygon.
1090 : : *
1091 : : * \see ringFilter()
1092 : : * \since QGIS 3.6
1093 : : */
1094 : : void setRingFilter( QgsLineSymbolLayer::RenderRingFilter filter );
1095 : :
1096 : : protected:
1097 : : QgsLineSymbolLayer( bool locked = false );
1098 : :
1099 : : double mWidth = 0;
1100 : : QgsUnitTypes::RenderUnit mWidthUnit = QgsUnitTypes::RenderMillimeters;
1101 : : QgsMapUnitScale mWidthMapUnitScale;
1102 : : double mOffset = 0;
1103 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
1104 : : QgsMapUnitScale mOffsetMapUnitScale;
1105 : :
1106 : : RenderRingFilter mRingFilter = AllRings;
1107 : :
1108 : : private:
1109 : : #ifdef SIP_RUN
1110 : : QgsLineSymbolLayer( const QgsLineSymbolLayer &other );
1111 : : #endif
1112 : : };
1113 : :
1114 : : /**
1115 : : * \ingroup core
1116 : : * \class QgsFillSymbolLayer
1117 : : */
1118 : 228 : class CORE_EXPORT QgsFillSymbolLayer : public QgsSymbolLayer
1119 : : {
1120 : : public:
1121 : :
1122 : : //! QgsFillSymbolLayer cannot be copied
1123 : : QgsFillSymbolLayer( const QgsFillSymbolLayer &other ) = delete;
1124 : :
1125 : : //! QgsFillSymbolLayer cannot be copied
1126 : : QgsFillSymbolLayer &operator=( const QgsFillSymbolLayer &other ) = delete;
1127 : :
1128 : : /**
1129 : : * Renders the fill symbol layer for the polygon whose outer ring is defined by \a points, using the given render \a context.
1130 : : *
1131 : : * The \a rings argument optionally specifies a list of polygon rings to render as holes.
1132 : : */
1133 : : virtual void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) = 0;
1134 : :
1135 : : void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;
1136 : :
1137 : 50 : void setAngle( double angle ) { mAngle = angle; }
1138 : : double angle() const { return mAngle; }
1139 : :
1140 : : protected:
1141 : : QgsFillSymbolLayer( bool locked = false );
1142 : : //! Default method to render polygon
1143 : : void _renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context );
1144 : :
1145 : : double mAngle = 0.0;
1146 : :
1147 : : private:
1148 : : #ifdef SIP_RUN
1149 : : QgsFillSymbolLayer( const QgsFillSymbolLayer &other );
1150 : : #endif
1151 : : };
1152 : :
1153 : : class QgsSymbolLayerWidget; // why does SIP fail, when this isn't here
1154 : :
1155 : : #endif
1156 : :
1157 : :
|
