Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsfillsymbollayer.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 : :
16 : : #ifndef QGSFILLSYMBOLLAYER_H
17 : : #define QGSFILLSYMBOLLAYER_H
18 : :
19 : : #include "qgis_core.h"
20 : : #include "qgis.h"
21 : : #include "qgssymbollayer.h"
22 : :
23 : : #define DEFAULT_SIMPLEFILL_COLOR QColor(0,0,255)
24 : : #define DEFAULT_SIMPLEFILL_STYLE Qt::SolidPattern
25 : : #define DEFAULT_SIMPLEFILL_BORDERCOLOR QColor( 35, 35, 35 )
26 : : #define DEFAULT_SIMPLEFILL_BORDERSTYLE Qt::SolidLine
27 : : #define DEFAULT_SIMPLEFILL_BORDERWIDTH DEFAULT_LINE_WIDTH
28 : : #define DEFAULT_SIMPLEFILL_JOINSTYLE Qt::BevelJoin
29 : :
30 : : #define INF 1E20
31 : :
32 : : #include <QPen>
33 : : #include <QBrush>
34 : :
35 : : /**
36 : : * \ingroup core
37 : : * \class QgsSimpleFillSymbolLayer
38 : : */
39 : 270 : class CORE_EXPORT QgsSimpleFillSymbolLayer : public QgsFillSymbolLayer
40 : : {
41 : : public:
42 : : QgsSimpleFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,
43 : : Qt::BrushStyle style = DEFAULT_SIMPLEFILL_STYLE,
44 : : const QColor &strokeColor = DEFAULT_SIMPLEFILL_BORDERCOLOR,
45 : : Qt::PenStyle strokeStyle = DEFAULT_SIMPLEFILL_BORDERSTYLE,
46 : : double strokeWidth = DEFAULT_SIMPLEFILL_BORDERWIDTH,
47 : : Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEFILL_JOINSTYLE
48 : : );
49 : :
50 : : // static stuff
51 : :
52 : : /**
53 : : * Creates a new QgsSimpleFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
54 : : *
55 : : * Caller takes ownership of the returned symbol layer.
56 : : */
57 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
58 : : static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
59 : :
60 : : // implemented from base classes
61 : :
62 : : QString layerType() const override;
63 : :
64 : : void startRender( QgsSymbolRenderContext &context ) override;
65 : :
66 : : void stopRender( QgsSymbolRenderContext &context ) override;
67 : :
68 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
69 : :
70 : : QVariantMap properties() const override;
71 : :
72 : : QgsSimpleFillSymbolLayer *clone() const override SIP_FACTORY;
73 : :
74 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
75 : :
76 : : QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;
77 : :
78 : 0 : Qt::BrushStyle brushStyle() const { return mBrushStyle; }
79 : 0 : void setBrushStyle( Qt::BrushStyle style ) { mBrushStyle = style; }
80 : :
81 : 0 : QColor strokeColor() const override { return mStrokeColor; }
82 : 0 : void setStrokeColor( const QColor &strokeColor ) override { mStrokeColor = strokeColor; }
83 : :
84 : 0 : QColor fillColor() const override { return color(); }
85 : 0 : void setFillColor( const QColor &color ) override { setColor( color ); }
86 : :
87 : : Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
88 : 0 : void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
89 : :
90 : : double strokeWidth() const { return mStrokeWidth; }
91 : 0 : void setStrokeWidth( double strokeWidth ) { mStrokeWidth = strokeWidth; }
92 : :
93 : : Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
94 : : void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
95 : :
96 : : /**
97 : : * Sets an \a offset by which polygons will be translated during rendering.
98 : : *
99 : : * Units are specified by offsetUnit().
100 : : *
101 : : * \see offset()
102 : : * \see setOffsetUnit()
103 : : */
104 : 175 : void setOffset( QPointF offset ) { mOffset = offset; }
105 : :
106 : : /**
107 : : * Returns the offset by which polygons will be translated during rendering.
108 : : *
109 : : * Units are specified by offsetUnit().
110 : : *
111 : : * \see setOffset()
112 : : * \see offsetUnit()
113 : : */
114 : : QPointF offset() { return mOffset; }
115 : :
116 : : /**
117 : : * Sets the units for the width of the fill's stroke.
118 : : * \param unit width units
119 : : * \see strokeWidthUnit()
120 : : */
121 : 165 : void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
122 : :
123 : : /**
124 : : * Returns the units for the width of the fill's stroke.
125 : : * \see setStrokeWidthUnit()
126 : : */
127 : : QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
128 : :
129 : 165 : void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
130 : : const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
131 : :
132 : : /**
133 : : * Sets the \a unit for the fill's offset.
134 : : * \see offset()
135 : : * \see offsetUnit()
136 : : */
137 : 170 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
138 : :
139 : : /**
140 : : * Returns the units for the fill's offset.
141 : : * \see setOffsetUnit()
142 : : * \see offset()
143 : : */
144 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
145 : :
146 : : /**
147 : : * Sets the map unit \a scale for the fill's offset.
148 : : * \see setOffset()
149 : : * \see offsetMapUnitScale()
150 : : */
151 : 165 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
152 : :
153 : : /**
154 : : * Returns the map unit scale for the fill's offset.
155 : : * \see offset()
156 : : * \see setOffsetMapUnitScale()
157 : : */
158 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
159 : :
160 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
161 : : QgsUnitTypes::RenderUnit outputUnit() const override;
162 : : bool usesMapUnits() const override;
163 : :
164 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
165 : : QgsMapUnitScale mapUnitScale() const override;
166 : :
167 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
168 : :
169 : : double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
170 : : QColor dxfColor( QgsSymbolRenderContext &context ) const override;
171 : : double dxfAngle( QgsSymbolRenderContext &context ) const override;
172 : :
173 : : Qt::PenStyle dxfPenStyle() const override;
174 : : QColor dxfBrushColor( QgsSymbolRenderContext &context ) const override;
175 : : Qt::BrushStyle dxfBrushStyle() const override;
176 : :
177 : : protected:
178 : : QBrush mBrush;
179 : : QBrush mSelBrush;
180 : : Qt::BrushStyle mBrushStyle;
181 : : QColor mStrokeColor;
182 : : Qt::PenStyle mStrokeStyle;
183 : : double mStrokeWidth;
184 : : QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
185 : : QgsMapUnitScale mStrokeWidthMapUnitScale;
186 : : Qt::PenJoinStyle mPenJoinStyle;
187 : : QPen mPen;
188 : : QPen mSelPen;
189 : :
190 : : QPointF mOffset;
191 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
192 : : QgsMapUnitScale mOffsetMapUnitScale;
193 : :
194 : : private:
195 : : //helper functions for data defined symbology
196 : : void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );
197 : : };
198 : :
199 : : class QgsColorRamp;
200 : :
201 : : /**
202 : : * \ingroup core
203 : : * \class QgsGradientFillSymbolLayer
204 : : */
205 : : class CORE_EXPORT QgsGradientFillSymbolLayer : public QgsFillSymbolLayer
206 : : {
207 : : public:
208 : :
209 : : enum GradientColorType
210 : : {
211 : : SimpleTwoColor,
212 : : ColorRamp
213 : : };
214 : :
215 : : enum GradientType
216 : : {
217 : : Linear,
218 : : Radial,
219 : : Conical
220 : : };
221 : :
222 : : enum GradientCoordinateMode
223 : : {
224 : : Feature,
225 : : Viewport
226 : : };
227 : :
228 : : enum GradientSpread
229 : : {
230 : : Pad,
231 : : Reflect,
232 : : Repeat
233 : : };
234 : :
235 : : QgsGradientFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,
236 : : const QColor &color2 = Qt::white,
237 : : GradientColorType gradientColorType = SimpleTwoColor,
238 : : GradientType gradientType = Linear,
239 : : GradientCoordinateMode coordinateMode = Feature,
240 : : GradientSpread gradientSpread = Pad
241 : : );
242 : :
243 : : ~QgsGradientFillSymbolLayer() override;
244 : :
245 : : // static stuff
246 : :
247 : : /**
248 : : * Creates a new QgsGradientFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
249 : : *
250 : : * Caller takes ownership of the returned symbol layer.
251 : : */
252 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
253 : :
254 : : // implemented from base classes
255 : :
256 : : QString layerType() const override;
257 : : void startRender( QgsSymbolRenderContext &context ) override;
258 : : void stopRender( QgsSymbolRenderContext &context ) override;
259 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
260 : : QVariantMap properties() const override;
261 : : QgsGradientFillSymbolLayer *clone() const override SIP_FACTORY;
262 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
263 : : bool canCauseArtifactsBetweenAdjacentTiles() const override;
264 : :
265 : : //! Type of gradient, e.g., linear or radial
266 : : GradientType gradientType() const { return mGradientType; }
267 : : void setGradientType( GradientType gradientType ) { mGradientType = gradientType; }
268 : :
269 : : //! Gradient color mode, controls how gradient color stops are created
270 : : GradientColorType gradientColorType() const { return mGradientColorType; }
271 : : void setGradientColorType( GradientColorType gradientColorType ) { mGradientColorType = gradientColorType; }
272 : :
273 : : /**
274 : : * Returns the color ramp used for the gradient fill. This is only
275 : : * used if the gradient color type is set to ColorRamp.
276 : : * \see setColorRamp()
277 : : * \see gradientColorType()
278 : : */
279 : : QgsColorRamp *colorRamp() { return mGradientRamp; }
280 : :
281 : : /**
282 : : * Sets the color ramp used for the gradient fill. This is only
283 : : * used if the gradient color type is set to ColorRamp.
284 : : * \param ramp color ramp. Ownership is transferred.
285 : : * \see colorRamp()
286 : : * \see setGradientColorType()
287 : : */
288 : : void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
289 : :
290 : : //! Color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoColor
291 : : QColor color2() const { return mColor2; }
292 : : void setColor2( const QColor &color2 ) { mColor2 = color2; }
293 : :
294 : : //! Coordinate mode for gradient. Controls how the gradient stops are positioned.
295 : : GradientCoordinateMode coordinateMode() const { return mCoordinateMode; }
296 : : void setCoordinateMode( GradientCoordinateMode coordinateMode ) { mCoordinateMode = coordinateMode; }
297 : :
298 : : //! Gradient spread mode. Controls how the gradient behaves outside of the predefined stops
299 : : GradientSpread gradientSpread() const { return mGradientSpread; }
300 : : void setGradientSpread( GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }
301 : :
302 : : //! Starting point of gradient fill, in the range [0,0] - [1,1]
303 : 50 : void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }
304 : : QPointF referencePoint1() const { return mReferencePoint1; }
305 : :
306 : : //! Sets the starting point of the gradient to be the feature centroid
307 : 50 : void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }
308 : : bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }
309 : :
310 : : //! End point of gradient fill, in the range [0,0] - [1,1]
311 : 50 : void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }
312 : : QPointF referencePoint2() const { return mReferencePoint2; }
313 : :
314 : : //! Sets the end point of the gradient to be the feature centroid
315 : 50 : void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }
316 : : bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }
317 : :
318 : : /**
319 : : * Sets an \a offset by which polygons will be translated during rendering.
320 : : *
321 : : * Units are specified by offsetUnit().
322 : : *
323 : : * \see offset()
324 : : * \see setOffsetUnit()
325 : : */
326 : 50 : void setOffset( QPointF offset ) { mOffset = offset; }
327 : :
328 : : /**
329 : : * Returns the offset by which polygons will be translated during rendering.
330 : : *
331 : : * Units are specified by offsetUnit().
332 : : *
333 : : * \see setOffset()
334 : : * \see offsetUnit()
335 : : */
336 : : QPointF offset() const { return mOffset; }
337 : :
338 : : /**
339 : : * Sets the \a unit for the fill's offset.
340 : : * \see offset()
341 : : * \see offsetUnit()
342 : : */
343 : 50 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
344 : :
345 : : /**
346 : : * Returns the units for the fill's offset.
347 : : * \see setOffsetUnit()
348 : : * \see offset()
349 : : */
350 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
351 : :
352 : : /**
353 : : * Sets the map unit \a scale for the fill's offset.
354 : : * \see setOffset()
355 : : * \see offsetMapUnitScale()
356 : : */
357 : 50 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
358 : :
359 : : /**
360 : : * Returns the map unit scale for the fill's offset.
361 : : * \see offset()
362 : : * \see setOffsetMapUnitScale()
363 : : */
364 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
365 : :
366 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
367 : : QgsUnitTypes::RenderUnit outputUnit() const override;
368 : : bool usesMapUnits() const override;
369 : :
370 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
371 : : QgsMapUnitScale mapUnitScale() const override;
372 : :
373 : : protected:
374 : : QBrush mBrush;
375 : : QBrush mSelBrush;
376 : :
377 : : GradientColorType mGradientColorType;
378 : : QColor mColor2;
379 : : QgsColorRamp *mGradientRamp = nullptr;
380 : : GradientType mGradientType;
381 : : GradientCoordinateMode mCoordinateMode;
382 : : GradientSpread mGradientSpread;
383 : :
384 : : QPointF mReferencePoint1;
385 : : bool mReferencePoint1IsCentroid = false;
386 : : QPointF mReferencePoint2;
387 : : bool mReferencePoint2IsCentroid = false;
388 : :
389 : : QPointF mOffset;
390 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
391 : : QgsMapUnitScale mOffsetMapUnitScale;
392 : :
393 : : private:
394 : :
395 : : //helper functions for data defined symbology
396 : : void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );
397 : :
398 : : //! Applies the gradient to a brush
399 : : void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,
400 : : GradientColorType gradientColorType, QgsColorRamp *gradientRamp, GradientType gradientType,
401 : : GradientCoordinateMode coordinateMode, GradientSpread gradientSpread,
402 : : QPointF referencePoint1, QPointF referencePoint2, double angle );
403 : :
404 : : //! Rotates a reference point by a specified angle around the point (0.5, 0.5)
405 : : QPointF rotateReferencePoint( QPointF refPoint, double angle );
406 : : };
407 : :
408 : : /**
409 : : * \ingroup core
410 : : * \class QgsShapeburstFillSymbolLayer
411 : : */
412 : : class CORE_EXPORT QgsShapeburstFillSymbolLayer : public QgsFillSymbolLayer
413 : : {
414 : : public:
415 : :
416 : : enum ShapeburstColorType
417 : : {
418 : : SimpleTwoColor,
419 : : ColorRamp
420 : : };
421 : :
422 : : QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,
423 : : ShapeburstColorType colorType = SimpleTwoColor,
424 : : int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );
425 : :
426 : : ~QgsShapeburstFillSymbolLayer() override;
427 : :
428 : : /**
429 : : * QgsShapeburstFillSymbolLayer cannot be copied.
430 : : * \see clone()
431 : : */
432 : : QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other ) = delete;
433 : :
434 : : /**
435 : : * QgsShapeburstFillSymbolLayer cannot be copied.
436 : : * \see clone()
437 : : */
438 : : QgsShapeburstFillSymbolLayer &operator=( const QgsShapeburstFillSymbolLayer &other ) = delete;
439 : :
440 : : // static stuff
441 : :
442 : : /**
443 : : * Creates a new QgsShapeburstFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
444 : : *
445 : : * Caller takes ownership of the returned symbol layer.
446 : : */
447 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
448 : :
449 : : // implemented from base classes
450 : :
451 : : QString layerType() const override;
452 : : void startRender( QgsSymbolRenderContext &context ) override;
453 : : void stopRender( QgsSymbolRenderContext &context ) override;
454 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
455 : : QVariantMap properties() const override;
456 : : QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;
457 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
458 : : bool canCauseArtifactsBetweenAdjacentTiles() const override;
459 : :
460 : : /**
461 : : * Sets the blur radius, which controls the amount of blurring applied to the fill.
462 : : * \param blurRadius Radius for fill blur. Values between 0 - 17 are valid, where higher values results in a stronger blur. Set to 0 to disable blur.
463 : : * \see blurRadius
464 : : * \since QGIS 2.3
465 : : */
466 : : void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }
467 : :
468 : : /**
469 : : * Returns the blur radius, which controls the amount of blurring applied to the fill.
470 : : * \returns Integer representing the radius for fill blur. Higher values indicate a stronger blur. A 0 value indicates that blurring is disabled.
471 : : * \see setBlurRadius
472 : : * \since QGIS 2.3
473 : : */
474 : : int blurRadius() const { return mBlurRadius; }
475 : :
476 : : /**
477 : : * Sets whether the shapeburst fill should be drawn using the entire shape.
478 : : * \param useWholeShape Set to TRUE if shapeburst should cover entire shape. If FALSE, setMaxDistance is used to calculate how far from the boundary of the shape should
479 : : * be shaded
480 : : * \see useWholeShape
481 : : * \see setMaxDistance
482 : : * \since QGIS 2.3
483 : : */
484 : : void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }
485 : :
486 : : /**
487 : : * Returns whether the shapeburst fill is set to cover the entire shape.
488 : : * \returns TRUE if shapeburst fill will cover the entire shape. If FALSE, shapeburst is drawn to a distance of maxDistance from the polygon's boundary.
489 : : * \see setUseWholeShape
490 : : * \see maxDistance
491 : : * \since QGIS 2.3
492 : : */
493 : : bool useWholeShape() const { return mUseWholeShape; }
494 : :
495 : : /**
496 : : * Sets the maximum distance to shape inside of the shape from the polygon's boundary.
497 : : * \param maxDistance distance from boundary to shade. setUseWholeShape must be set to FALSE for this parameter to take effect. Distance unit is controlled by setDistanceUnit.
498 : : * \see maxDistance
499 : : * \see setUseWholeShape
500 : : * \see setDistanceUnit
501 : : * \since QGIS 2.3
502 : : */
503 : : void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }
504 : :
505 : : /**
506 : : * Returns the maximum distance from the shape's boundary which is shaded. This parameter is only effective if useWholeShape is FALSE.
507 : : * \returns the maximum distance from the polygon's boundary which is shaded. Distance units are indicated by distanceUnit.
508 : : * \see useWholeShape
509 : : * \see setMaxDistance
510 : : * \see distanceUnit
511 : : * \since QGIS 2.3
512 : : */
513 : : double maxDistance() const { return mMaxDistance; }
514 : :
515 : : /**
516 : : * Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
517 : : * \param unit distance unit for the maximum distance
518 : : * \see setMaxDistance
519 : : * \see distanceUnit
520 : : * \since QGIS 2.3
521 : : */
522 : 0 : void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
523 : :
524 : : /**
525 : : * Returns the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
526 : : * \returns distance unit for the maximum distance
527 : : * \see maxDistance
528 : : * \see setDistanceUnit
529 : : * \since QGIS 2.3
530 : : */
531 : : QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
532 : :
533 : 0 : void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
534 : : const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
535 : :
536 : : /**
537 : : * Sets the color mode to use for the shapeburst fill. Shapeburst can either be drawn using a QgsColorRamp color ramp
538 : : * or by simply specificing a start and end color. setColorType is used to specify which mode to use for the fill.
539 : : * \param colorType color type to use for shapeburst fill
540 : : * \see colorType
541 : : * \see setColor
542 : : * \see setColor2
543 : : * \see setColorRamp
544 : : * \since QGIS 2.3
545 : : */
546 : : void setColorType( ShapeburstColorType colorType ) { mColorType = colorType; }
547 : :
548 : : /**
549 : : * Returns the color mode used for the shapeburst fill. Shapeburst can either be drawn using a QgsColorRamp color ramp
550 : : * or by simply specificing a start and end color.
551 : : * \returns current color mode used for the shapeburst fill
552 : : * \see setColorType
553 : : * \see color
554 : : * \see color2
555 : : * \see colorRamp
556 : : * \since QGIS 2.3
557 : : */
558 : : ShapeburstColorType colorType() const { return mColorType; }
559 : :
560 : : /**
561 : : * Sets the color \a ramp used to draw the shapeburst fill. Color ramps are only used if setColorType is set ShapeburstColorType::ColorRamp.
562 : : *
563 : : * Ownership of \a ramp is transferred to the fill.
564 : : *
565 : : * \see setColorType
566 : : * \see colorRamp
567 : : * \since QGIS 2.3
568 : : */
569 : : void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
570 : :
571 : : /**
572 : : * Returns the color ramp used for the shapeburst fill. The color ramp is only used if the colorType is set to ShapeburstColorType::ColorRamp
573 : : * \returns a QgsColorRamp color ramp
574 : : * \see setColorRamp
575 : : * \see colorType
576 : : * \since QGIS 2.3
577 : : */
578 : : QgsColorRamp *colorRamp() { return mGradientRamp.get(); }
579 : :
580 : : /**
581 : : * Sets the color for the endpoint of the shapeburst fill. This color is only used if setColorType is set ShapeburstColorType::SimpleTwoColor.
582 : : * \param color2 QColor to use for endpoint of gradient
583 : : * \see setColorType
584 : : * \see color2
585 : : * \since QGIS 2.3
586 : : */
587 : : void setColor2( const QColor &color2 ) { mColor2 = color2; }
588 : :
589 : : /**
590 : : * Returns the color used for the endpoint of the shapeburst fill. This color is only used if the colorType is set to ShapeburstColorType::SimpleTwoColor
591 : : * \returns a QColor indicating the color of the endpoint of the gradient
592 : : * \see setColor2
593 : : * \see colorType
594 : : * \since QGIS 2.3
595 : : */
596 : : QColor color2() const { return mColor2; }
597 : :
598 : : /**
599 : : * Sets whether the shapeburst fill should ignore polygon rings when calculating
600 : : * the buffered shading.
601 : : * \param ignoreRings Set to TRUE if buffers should ignore interior rings for polygons.
602 : : * \see ignoreRings
603 : : * \since QGIS 2.3
604 : : */
605 : 0 : void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }
606 : :
607 : : /**
608 : : * Returns whether the shapeburst fill is set to ignore polygon interior rings.
609 : : * \returns TRUE if the shapeburst fill will ignore interior rings when calculating buffered shading.
610 : : * \see setIgnoreRings
611 : : * \since QGIS 2.3
612 : : */
613 : : bool ignoreRings() const { return mIgnoreRings; }
614 : :
615 : : /**
616 : : * Sets the offset for the shapeburst fill.
617 : : * \param offset QPointF indicating the horizontal/vertical offset amount
618 : : * \see offset
619 : : * \see setOffsetUnit
620 : : * \since QGIS 2.3
621 : : */
622 : 0 : void setOffset( QPointF offset ) { mOffset = offset; }
623 : :
624 : : /**
625 : : * Returns the offset for the shapeburst fill.
626 : : * \returns a QPointF indicating the horizontal/vertical offset amount
627 : : * \see setOffset
628 : : * \see offsetUnit
629 : : * \since QGIS 2.3
630 : : */
631 : : QPointF offset() const { return mOffset; }
632 : :
633 : : /**
634 : : * Sets the units used for the offset for the shapeburst fill.
635 : : * \param unit units for fill offset
636 : : * \see setOffset
637 : : * \see offsetUnit
638 : : * \since QGIS 2.3
639 : : */
640 : 0 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
641 : :
642 : : /**
643 : : * Returns the units used for the offset of the shapeburst fill.
644 : : * \returns units used for the fill offset
645 : : * \see offset
646 : : * \see setOffsetUnit
647 : : * \since QGIS 2.3
648 : : */
649 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
650 : :
651 : 0 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
652 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
653 : :
654 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
655 : : QgsUnitTypes::RenderUnit outputUnit() const override;
656 : : bool usesMapUnits() const override;
657 : :
658 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
659 : : QgsMapUnitScale mapUnitScale() const override;
660 : :
661 : : private:
662 : : QBrush mBrush;
663 : : QBrush mSelBrush;
664 : :
665 : : int mBlurRadius = 0;
666 : :
667 : : bool mUseWholeShape = true;
668 : : double mMaxDistance = 5.0;
669 : : QgsUnitTypes::RenderUnit mDistanceUnit = QgsUnitTypes::RenderMillimeters;
670 : : QgsMapUnitScale mDistanceMapUnitScale;
671 : :
672 : : ShapeburstColorType mColorType = SimpleTwoColor;
673 : : QColor mColor2;
674 : :
675 : : bool mIgnoreRings = false;
676 : :
677 : : QPointF mOffset;
678 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
679 : : QgsMapUnitScale mOffsetMapUnitScale;
680 : :
681 : : std::unique_ptr< QgsColorRamp > mGradientRamp;
682 : :
683 : : //helper functions for data defined symbology
684 : : void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,
685 : : double &maxDistance, bool &ignoreRings );
686 : :
687 : : /* distance transform of a 1d function using squared distance */
688 : : void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
689 : : /* distance transform of 2d function using squared distance */
690 : : void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );
691 : : /* distance transform of a binary QImage */
692 : : double *distanceTransform( QImage *im, QgsRenderContext &context );
693 : :
694 : : /* fills a QImage with values from an array of doubles containing squared distance transform values */
695 : : void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );
696 : :
697 : : #ifdef SIP_RUN
698 : : QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other );
699 : : #endif
700 : : };
701 : :
702 : : /**
703 : : * \ingroup core
704 : : * \brief Base class for polygon renderers generating texture images
705 : : */
706 : 60 : class CORE_EXPORT QgsImageFillSymbolLayer: public QgsFillSymbolLayer
707 : : {
708 : : public:
709 : :
710 : : QgsImageFillSymbolLayer();
711 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
712 : :
713 : 0 : QgsSymbol *subSymbol() override { return mStroke.get(); }
714 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
715 : :
716 : : /**
717 : : * Sets the \a units fo the symbol's stroke width.
718 : : * \see strokeWidthUnit()
719 : : * \see setStrokeWidthMapUnitScale()
720 : : */
721 : 100 : void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
722 : :
723 : : /**
724 : : * Returns the units for the symbol's stroke width.
725 : : * \see setStrokeWidthUnit()
726 : : * \see strokeWidthMapUnitScale()
727 : : */
728 : : QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
729 : :
730 : : /**
731 : : * Sets the stroke width map unit \a scale.
732 : : *
733 : : * \see strokeWidthMapUnitScale()
734 : : * \see setStrokeWidthUnit()
735 : : */
736 : 100 : void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
737 : :
738 : : /**
739 : : * Returns the stroke width map unit scale.
740 : : *
741 : : * \see setStrokeWidthMapUnitScale()
742 : : * \see strokeWidthUnit()
743 : : *
744 : : * \since QGIS 2.16
745 : : */
746 : : const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
747 : :
748 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
749 : : QgsUnitTypes::RenderUnit outputUnit() const override;
750 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
751 : : QgsMapUnitScale mapUnitScale() const override;
752 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
753 : : double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
754 : : QColor dxfColor( QgsSymbolRenderContext &context ) const override;
755 : : Qt::PenStyle dxfPenStyle() const override;
756 : : QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
757 : : bool hasDataDefinedProperties() const override;
758 : :
759 : : protected:
760 : : QBrush mBrush;
761 : : double mNextAngle = 0.0; // mAngle / data defined angle
762 : :
763 : : //! Stroke width
764 : : double mStrokeWidth = 0.0;
765 : : QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
766 : : QgsMapUnitScale mStrokeWidthMapUnitScale;
767 : :
768 : : //! Custom stroke
769 : : std::unique_ptr< QgsLineSymbol > mStroke;
770 : :
771 : 0 : virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }
772 : :
773 : : /**
774 : : * Returns TRUE if the image brush should be transformed using the render context's texture origin.
775 : : *
776 : : * \since QGIS 3.16
777 : : */
778 : : virtual bool applyBrushTransformFromContext() const;
779 : :
780 : : private:
781 : : #ifdef SIP_RUN
782 : : QgsImageFillSymbolLayer( const QgsImageFillSymbolLayer &other );
783 : : #endif
784 : : };
785 : :
786 : : /**
787 : : * \ingroup core
788 : : * \class QgsRasterFillSymbolLayer
789 : : * \brief A class for filling symbols with a repeated raster image.
790 : : * \since QGIS 2.7
791 : : */
792 : 0 : class CORE_EXPORT QgsRasterFillSymbolLayer: public QgsImageFillSymbolLayer
793 : : {
794 : : public:
795 : :
796 : : //! Fill coordinate modes, dictates fill tiling behavior
797 : : enum FillCoordinateMode
798 : : {
799 : : Feature, //!< Tiling is based on feature bounding box
800 : : Viewport, //!< Tiling is based on complete map viewport
801 : : };
802 : :
803 : : /**
804 : : * Constructor for QgsRasterFillSymbolLayer, using a raster fill from the
805 : : * specified \a imageFilePath.
806 : : */
807 : : QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );
808 : :
809 : : /**
810 : : * Creates a new QgsRasterFillSymbolLayer from a \a properties map. The caller takes
811 : : * ownership of the returned object.
812 : : */
813 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
814 : :
815 : : /**
816 : : * Turns relative paths in properties map to absolute when reading and vice versa when writing.
817 : : * Used internally when reading/writing symbols.
818 : : * \since QGIS 3.0
819 : : */
820 : : static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
821 : :
822 : : // implemented from base classes
823 : : QString layerType() const override;
824 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
825 : : void startRender( QgsSymbolRenderContext &context ) override;
826 : : void stopRender( QgsSymbolRenderContext &context ) override;
827 : : QVariantMap properties() const override;
828 : : QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;
829 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
830 : : bool usesMapUnits() const override;
831 : :
832 : : //override QgsImageFillSymbolLayer's support for sub symbols
833 : 0 : QgsSymbol *subSymbol() override { return nullptr; }
834 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
835 : :
836 : : /**
837 : : * Sets the path to the raster image used for the fill.
838 : : * \param imagePath path to image file
839 : : * \see imageFilePath
840 : : */
841 : : void setImageFilePath( const QString &imagePath );
842 : :
843 : : /**
844 : : * The path to the raster image used for the fill.
845 : : * \returns path to image file
846 : : * \see setImageFilePath
847 : : */
848 : : QString imageFilePath() const { return mImageFilePath; }
849 : :
850 : : /**
851 : : * Set the coordinate mode for fill. Controls how the top left corner of the image
852 : : * fill is positioned relative to the feature.
853 : : * \param mode coordinate mode
854 : : * \see coordinateMode
855 : : */
856 : : void setCoordinateMode( FillCoordinateMode mode );
857 : :
858 : : /**
859 : : * Coordinate mode for fill. Controls how the top left corner of the image
860 : : * fill is positioned relative to the feature.
861 : : * \returns coordinate mode
862 : : * \see setCoordinateMode
863 : : */
864 : : FillCoordinateMode coordinateMode() const { return mCoordinateMode; }
865 : :
866 : : /**
867 : : * Sets the \a opacity for the raster image used in the fill.
868 : : * \param opacity opacity value between 0 (fully transparent) and 1 (fully opaque)
869 : : * \see opacity()
870 : : */
871 : : void setOpacity( double opacity );
872 : :
873 : : /**
874 : : * Returns the opacity for the raster image used in the fill.
875 : : * \returns opacity value between 0 (fully transparent) and 1 (fully opaque)
876 : : * \see setOpacity()
877 : : */
878 : : double opacity() const { return mOpacity; }
879 : :
880 : : /**
881 : : * Sets the offset for the fill.
882 : : * \param offset offset for fill
883 : : * \see offset
884 : : * \see setOffsetUnit
885 : : * \see setOffsetMapUnitScale
886 : : */
887 : 0 : void setOffset( QPointF offset ) { mOffset = offset; }
888 : :
889 : : /**
890 : : * Returns the offset for the fill.
891 : : * \returns offset for fill
892 : : * \see setOffset
893 : : * \see offsetUnit
894 : : * \see offsetMapUnitScale
895 : : */
896 : : QPointF offset() const { return mOffset; }
897 : :
898 : : /**
899 : : * Sets the units for the fill's offset.
900 : : * \param unit units for offset
901 : : * \see offsetUnit
902 : : * \see setOffset
903 : : * \see setOffsetMapUnitScale
904 : : */
905 : 0 : void setOffsetUnit( const QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
906 : :
907 : : /**
908 : : * Returns the units for the fill's offset.
909 : : * \returns units for offset
910 : : * \see setOffsetUnit
911 : : * \see offset
912 : : * \see offsetMapUnitScale
913 : : */
914 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
915 : :
916 : : /**
917 : : * Sets the map unit scale for the fill's offset.
918 : : * \param scale map unit scale for offset
919 : : * \see offsetMapUnitScale
920 : : * \see setOffset
921 : : * \see setOffsetUnit
922 : : */
923 : 0 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
924 : :
925 : : /**
926 : : * Returns the map unit scale for the fill's offset.
927 : : * \returns map unit scale for offset
928 : : * \see setOffsetMapUnitScale
929 : : * \see offset
930 : : * \see offsetUnit
931 : : */
932 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
933 : :
934 : : /**
935 : : * Sets the width for scaling the image used in the fill. The image's height will also be
936 : : * scaled to maintain the image's aspect ratio.
937 : : * \param width width for scaling the image
938 : : * \see width
939 : : * \see setWidthUnit
940 : : * \see setWidthMapUnitScale
941 : : */
942 : 0 : void setWidth( const double width ) { mWidth = width; }
943 : :
944 : : /**
945 : : * Returns the width used for scaling the image used in the fill. The image's height is
946 : : * scaled to maintain the image's aspect ratio.
947 : : * \returns width used for scaling the image
948 : : * \see setWidth
949 : : * \see widthUnit
950 : : * \see widthMapUnitScale
951 : : */
952 : : double width() const { return mWidth; }
953 : :
954 : : /**
955 : : * Sets the units for the image's width.
956 : : * \param unit units for width
957 : : * \see widthUnit
958 : : * \see setWidth
959 : : * \see setWidthMapUnitScale
960 : : */
961 : 0 : void setWidthUnit( const QgsUnitTypes::RenderUnit unit ) { mWidthUnit = unit; }
962 : :
963 : : /**
964 : : * Returns the units for the image's width.
965 : : * \returns units for width
966 : : * \see setWidthUnit
967 : : * \see width
968 : : * \see widthMapUnitScale
969 : : */
970 : : QgsUnitTypes::RenderUnit widthUnit() const { return mWidthUnit; }
971 : :
972 : : /**
973 : : * Sets the map unit scale for the image's width.
974 : : * \param scale map unit scale for width
975 : : * \see widthMapUnitScale
976 : : * \see setWidth
977 : : * \see setWidthUnit
978 : : */
979 : 0 : void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
980 : :
981 : : /**
982 : : * Returns the map unit scale for the image's width.
983 : : * \returns map unit scale for width
984 : : * \see setWidthMapUnitScale
985 : : * \see width
986 : : * \see widthUnit
987 : : */
988 : : const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }
989 : :
990 : : protected:
991 : :
992 : : void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
993 : : bool applyBrushTransformFromContext() const override;
994 : : private:
995 : :
996 : : //! Path to the image file
997 : : QString mImageFilePath;
998 : : FillCoordinateMode mCoordinateMode = QgsRasterFillSymbolLayer::Feature;
999 : : double mOpacity = 1.0;
1000 : :
1001 : : QPointF mOffset;
1002 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
1003 : : QgsMapUnitScale mOffsetMapUnitScale;
1004 : :
1005 : : double mWidth = 0.0;
1006 : : QgsUnitTypes::RenderUnit mWidthUnit = QgsUnitTypes::RenderPixels;
1007 : : QgsMapUnitScale mWidthMapUnitScale;
1008 : :
1009 : : //! Applies the image pattern to the brush
1010 : : void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double opacity,
1011 : : const QgsSymbolRenderContext &context );
1012 : : };
1013 : :
1014 : : /**
1015 : : * \ingroup core
1016 : : * \brief A class for filling symbols with a repeated SVG file.
1017 : : */
1018 : 0 : class CORE_EXPORT QgsSVGFillSymbolLayer: public QgsImageFillSymbolLayer
1019 : : {
1020 : : public:
1021 : :
1022 : : /**
1023 : : * Constructor for QgsSVGFillSymbolLayer, using the SVG picture at the specified absolute file path.
1024 : : */
1025 : : QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );
1026 : :
1027 : : /**
1028 : : * Constructor for QgsSVGFillSymbolLayer, using the specified SVG picture data.
1029 : : */
1030 : : QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );
1031 : :
1032 : : /**
1033 : : * Creates a new QgsSVGFillSymbolLayer from a \a properties map. The caller takes
1034 : : * ownership of the returned object.
1035 : : */
1036 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1037 : :
1038 : : /**
1039 : : * Creates a new QgsSVGFillSymbolLayer from a SLD \a element. The caller takes
1040 : : * ownership of the returned object.
1041 : : */
1042 : : static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1043 : :
1044 : : /**
1045 : : * Turns relative paths in properties map to absolute when reading and vice versa when writing.
1046 : : * Used internally when reading/writing symbols.
1047 : : * \since QGIS 3.0
1048 : : */
1049 : : static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
1050 : :
1051 : : // implemented from base classes
1052 : :
1053 : : QString layerType() const override;
1054 : : void startRender( QgsSymbolRenderContext &context ) override;
1055 : : void stopRender( QgsSymbolRenderContext &context ) override;
1056 : : QVariantMap properties() const override;
1057 : : QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;
1058 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1059 : : bool usesMapUnits() const override;
1060 : :
1061 : : /**
1062 : : * Sets the path to the SVG file to render in the fill.
1063 : : *
1064 : : * This is usually an absolute file path. Other supported options include
1065 : : *
1066 : : * - relative paths to folders from the user's SVG search paths
1067 : : * - base64 encoded content, prefixed with a 'base64:' string
1068 : : * - http(s) paths
1069 : : *
1070 : : * \see svgFilePath()
1071 : : */
1072 : : void setSvgFilePath( const QString &svgPath );
1073 : :
1074 : : /**
1075 : : * Returns the path to the SVG file used to render the fill.
1076 : : *
1077 : : * \see setSvgFilePath()
1078 : : */
1079 : : QString svgFilePath() const { return mSvgFilePath; }
1080 : :
1081 : : /**
1082 : : * Sets the \a width to render the SVG content as within the fill (i.e. the pattern repeat/tile size).
1083 : : *
1084 : : * Units are specified by setPatternWidthUnit()
1085 : : *
1086 : : * \see patternWidth()
1087 : : * \see setPatternWidthUnit()
1088 : : * \see setPatternWidthMapUnitScale()
1089 : : */
1090 : : void setPatternWidth( double width ) { mPatternWidth = width;}
1091 : :
1092 : : /**
1093 : : * Returns the width of the rendered SVG content within the fill (i.e. the pattern repeat/tile size).
1094 : : *
1095 : : * Units are retrieved by patternWidthUnit()
1096 : : *
1097 : : * \see setPatternWidth()
1098 : : * \see patternWidthUnit()
1099 : : * \see patternWidthMapUnitScale()
1100 : : */
1101 : : double patternWidth() const { return mPatternWidth; }
1102 : :
1103 : : /**
1104 : : * Sets the fill color used for rendering the SVG content.
1105 : : *
1106 : : * Fill color is only supported for parametrized SVG files. Color opacity is
1107 : : * ignored if the SVG file does not support parametrized fill opacity.
1108 : : *
1109 : : * \see svgFillColor()
1110 : : * \see setSvgStrokeColor()
1111 : : */
1112 : 0 : void setSvgFillColor( const QColor &c ) { setColor( c ); }
1113 : :
1114 : : /**
1115 : : * Returns the fill color used for rendering the SVG content.
1116 : : *
1117 : : * Fill color is only supported for parametrized SVG files.
1118 : : *
1119 : : * \see setSvgFillColor()
1120 : : * \see svgStrokeColor()
1121 : : */
1122 : : QColor svgFillColor() const { return color(); }
1123 : :
1124 : : /**
1125 : : * Sets the stroke color used for rendering the SVG content.
1126 : : *
1127 : : * Stroke color is only supported for parametrized SVG files. Color opacity is
1128 : : * ignored if the SVG file does not support parametrized outline opacity.
1129 : : *
1130 : : * \see svgStrokeColor()
1131 : : * \see setSvgFillColor()
1132 : : */
1133 : 0 : void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }
1134 : :
1135 : : /**
1136 : : * Returns the stroke color used for rendering the SVG content.
1137 : : *
1138 : : * Stroke color is only supported for parametrized SVG files.
1139 : : *
1140 : : * \see setSvgStrokeColor()
1141 : : * \see svgFillColor()
1142 : : */
1143 : : QColor svgStrokeColor() const { return mSvgStrokeColor; }
1144 : :
1145 : : /**
1146 : : * Sets the stroke width used for rendering the SVG content.
1147 : : *
1148 : : * Stroke width is only supported for parametrized SVG files. Units are
1149 : : * specified via setSvgStrokeWidthUnit()
1150 : : *
1151 : : * \see svgStrokeWidth()
1152 : : * \see setSvgStrokeWidthUnit()
1153 : : * \see setSvgStrokeWidthMapUnitScale()
1154 : : */
1155 : 0 : void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }
1156 : :
1157 : : /**
1158 : : * Returns the stroke width used for rendering the SVG content.
1159 : : *
1160 : : * Stroke width is only supported for parametrized SVG files. Units are
1161 : : * retrieved via setSvgStrokeWidthUnit()
1162 : : *
1163 : : * \see setSvgStrokeWidth()
1164 : : * \see svgStrokeWidthUnit()
1165 : : * \see svgStrokeWidthMapUnitScale()
1166 : : */
1167 : : double svgStrokeWidth() const { return mSvgStrokeWidth; }
1168 : :
1169 : : /**
1170 : : * Sets the \a unit for the width of the SVG images in the pattern.
1171 : : *
1172 : : * \see patternWidthUnit()
1173 : : * \see setPatternWidth()
1174 : : * \see setPatternWidthMapUnitScale()
1175 : : */
1176 : 0 : void setPatternWidthUnit( QgsUnitTypes::RenderUnit unit ) { mPatternWidthUnit = unit; }
1177 : :
1178 : : /**
1179 : : * Returns the units for the width of the SVG images in the pattern.
1180 : : *
1181 : : * \see setPatternWidthUnit()
1182 : : * \see patternWidth()
1183 : : * \see patternWidthMapUnitScale()
1184 : : */
1185 : : QgsUnitTypes::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }
1186 : :
1187 : : /**
1188 : : * Sets the map unit \a scale for the pattern's width.
1189 : : *
1190 : : * \see patternWidthMapUnitScale()
1191 : : * \see setPatternWidth()
1192 : : * \see setPatternWidthUnit()
1193 : : */
1194 : 0 : void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }
1195 : :
1196 : : /**
1197 : : * Returns the map unit scale for the pattern's width.
1198 : : *
1199 : : * \see setPatternWidthMapUnitScale()
1200 : : * \see patternWidth()
1201 : : * \see patternWidthUnit()
1202 : : */
1203 : : const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }
1204 : :
1205 : : /**
1206 : : * Sets the \a unit for the stroke width.
1207 : : *
1208 : : * \see svgStrokeWidthUnit()
1209 : : * \see setSvgStrokeWidth()
1210 : : * \see setSvgStrokeWidthMapUnitScale()
1211 : : */
1212 : 0 : void setSvgStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }
1213 : :
1214 : : /**
1215 : : * Returns the units for the stroke width.
1216 : : *
1217 : : * \see setSvgStrokeWidthUnit()
1218 : : * \see svgStrokeWidth()
1219 : : * \see svgStrokeWidthMapUnitScale()
1220 : : */
1221 : : QgsUnitTypes::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }
1222 : :
1223 : : /**
1224 : : * Sets the map unit \a scale for the pattern's stroke.
1225 : : *
1226 : : * \see svgStrokeWidthMapUnitScale()
1227 : : * \see setSvgStrokeWidth()
1228 : : * \see setSvgStrokeWidthUnit()
1229 : : */
1230 : 0 : void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }
1231 : :
1232 : : /**
1233 : : * Returns the map unit scale for the pattern's stroke.
1234 : : *
1235 : : * \see setSvgStrokeWidthMapUnitScale()
1236 : : * \see svgStrokeWidth()
1237 : : * \see svgStrokeWidthUnit()
1238 : : */
1239 : : const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }
1240 : :
1241 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1242 : : QgsUnitTypes::RenderUnit outputUnit() const override;
1243 : :
1244 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1245 : : QgsMapUnitScale mapUnitScale() const override;
1246 : :
1247 : : /**
1248 : : * Returns the dynamic SVG parameters
1249 : : * \since QGIS 3.18
1250 : : */
1251 : : QMap<QString, QgsProperty> parameters() const { return mParameters; }
1252 : :
1253 : : /**
1254 : : * Sets the dynamic SVG parameters
1255 : : * \since QGIS 3.18
1256 : : */
1257 : : void setParameters( const QMap<QString, QgsProperty> ¶meters );
1258 : :
1259 : : protected:
1260 : :
1261 : : void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1262 : :
1263 : : private:
1264 : :
1265 : : //! Width of the pattern (in output units)
1266 : : double mPatternWidth = 20;
1267 : : QgsUnitTypes::RenderUnit mPatternWidthUnit = QgsUnitTypes::RenderMillimeters;
1268 : : QgsMapUnitScale mPatternWidthMapUnitScale;
1269 : : QMap<QString, QgsProperty> mParameters;
1270 : :
1271 : : //! SVG data
1272 : : QByteArray mSvgData;
1273 : : //! Path to the svg file (or empty if constructed directly from data)
1274 : : QString mSvgFilePath;
1275 : : //! SVG view box (to keep the aspect ratio
1276 : : QRectF mSvgViewBox;
1277 : :
1278 : : //param(fill), param(stroke), param(stroke-width) are going
1279 : : //to be replaced in memory
1280 : : QColor mSvgStrokeColor = QColor( 35, 35, 35 );
1281 : : double mSvgStrokeWidth = 0.2;
1282 : : QgsUnitTypes::RenderUnit mSvgStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
1283 : : QgsMapUnitScale mSvgStrokeWidthMapUnitScale;
1284 : :
1285 : : //! Helper function that gets the view box from the byte array
1286 : : void storeViewBox();
1287 : : void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath
1288 : :
1289 : : //! Applies the svg pattern to the brush
1290 : : void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, QgsUnitTypes::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,
1291 : : double svgStrokeWidth, QgsUnitTypes::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,
1292 : : const QgsStringMap svgParameters );
1293 : : };
1294 : :
1295 : : /**
1296 : : * \ingroup core
1297 : : * \class QgsLinePatternFillSymbolLayer
1298 : : * \brief A symbol fill consisting of repeated parallel lines.
1299 : : */
1300 : : class CORE_EXPORT QgsLinePatternFillSymbolLayer: public QgsImageFillSymbolLayer
1301 : : {
1302 : : public:
1303 : : QgsLinePatternFillSymbolLayer();
1304 : : ~QgsLinePatternFillSymbolLayer() override;
1305 : :
1306 : : /**
1307 : : * Creates a new QgsLinePatternFillSymbolLayer from a \a properties map. The caller takes
1308 : : * ownership of the returned object.
1309 : : */
1310 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1311 : :
1312 : : /**
1313 : : * Creates a new QgsLinePatternFillSymbolLayer from a SLD \a element. The caller takes
1314 : : * ownership of the returned object.
1315 : : */
1316 : : static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1317 : :
1318 : : QString layerType() const override;
1319 : : void startRender( QgsSymbolRenderContext &context ) override;
1320 : : void stopRender( QgsSymbolRenderContext &context ) override;
1321 : : QVariantMap properties() const override;
1322 : : QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;
1323 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1324 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
1325 : :
1326 : : QString ogrFeatureStyleWidth( double widthScaleFactor ) const;
1327 : :
1328 : : /**
1329 : : * Sets the angle for the parallel lines used to fill the symbol.
1330 : : *
1331 : : * Angles are in degrees, clockwise from North.
1332 : : *
1333 : : * \see lineAngle()
1334 : : */
1335 : 70 : void setLineAngle( double a ) { mLineAngle = a; }
1336 : :
1337 : : /**
1338 : : * Returns the angle for the parallel lines used to fill the symbol.
1339 : : *
1340 : : * Angles are in degrees, clockwise from North.
1341 : : *
1342 : : * \see setLineAngle()
1343 : : */
1344 : : double lineAngle() const { return mLineAngle; }
1345 : :
1346 : : /**
1347 : : * Sets the distance between lines in the fill pattern.
1348 : : * \param d distance. Units are specified by setDistanceUnit()
1349 : : * \see distance()
1350 : : * \see setDistanceUnit()
1351 : : */
1352 : 70 : void setDistance( double d ) { mDistance = d; }
1353 : :
1354 : : /**
1355 : : * Returns the distance between lines in the fill pattern. Units are retrieved by distanceUnit().
1356 : : * \see setDistance()
1357 : : * \see distanceUnit()
1358 : : */
1359 : : double distance() const { return mDistance; }
1360 : :
1361 : : /**
1362 : : * Sets the width of the line subsymbol used to render the parallel lines
1363 : : * in the fill.
1364 : : *
1365 : : * \see lineWidth()
1366 : : */
1367 : : void setLineWidth( double w );
1368 : :
1369 : : /**
1370 : : * Returns the width of the line subsymbol used to render the parallel lines
1371 : : * in the fill.
1372 : : *
1373 : : * \see setLineWidth()
1374 : : */
1375 : : double lineWidth() const { return mLineWidth; }
1376 : :
1377 : : void setColor( const QColor &c ) override;
1378 : : QColor color() const override;
1379 : :
1380 : : /**
1381 : : * Sets the \a offset distance for lines within the fill, which is
1382 : : * the distance to offset the parallel lines from their normal
1383 : : * position.
1384 : : *
1385 : : * Units are specified via setOffsetUnit().
1386 : : *
1387 : : * \see offset()
1388 : : * \see setOffsetUnit()
1389 : : * \see setOffsetMapUnitScale()
1390 : : */
1391 : 70 : void setOffset( double offset ) { mOffset = offset; }
1392 : :
1393 : : /**
1394 : : * Returns the offset distance for lines within the fill, which is
1395 : : * the distance to offset the parallel lines from their normal
1396 : : * position.
1397 : : *
1398 : : * Units are retrieved via offsetUnit().
1399 : : *
1400 : : * \see setOffset()
1401 : : * \see offsetUnit()
1402 : : * \see offsetMapUnitScale()
1403 : : */
1404 : : double offset() const { return mOffset; }
1405 : :
1406 : : /**
1407 : : * Sets the \a unit for the distance between lines in the fill pattern.
1408 : : *
1409 : : * \see distanceUnit()
1410 : : * \see setDistance()
1411 : : */
1412 : 70 : void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
1413 : :
1414 : : /**
1415 : : * Returns the units for the distance between lines in the fill pattern.
1416 : : *
1417 : : * \see setDistanceUnit()
1418 : : * \see distance()
1419 : : */
1420 : : QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
1421 : :
1422 : : /**
1423 : : * Sets the map unit \a scale for the pattern's line distance.
1424 : : *
1425 : : * \see distanceMapUnitScale()
1426 : : * \see setDistance()
1427 : : * \see setDistanceUnit()
1428 : : */
1429 : 70 : void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
1430 : :
1431 : : /**
1432 : : * Returns the map unit scale for the pattern's line distance.
1433 : : *
1434 : : * \see setDistanceMapUnitScale()
1435 : : * \see distance()
1436 : : * \see distanceUnit()
1437 : : */
1438 : : const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
1439 : :
1440 : : /**
1441 : : * Sets the \a unit for the line's width.
1442 : : *
1443 : : * \see lineWidthUnit()
1444 : : */
1445 : 70 : void setLineWidthUnit( QgsUnitTypes::RenderUnit unit ) { mLineWidthUnit = unit; }
1446 : :
1447 : : /**
1448 : : * Returns the units for the line's width.
1449 : : *
1450 : : * \see setLineWidthUnit()
1451 : : */
1452 : : QgsUnitTypes::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }
1453 : :
1454 : : /**
1455 : : * Sets the map unit \a scale for the pattern's line width.
1456 : : *
1457 : : * \see lineWidthMapUnitScale()
1458 : : * \see setLineWidth()
1459 : : * \see setLineWidthUnit()
1460 : : */
1461 : 70 : void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }
1462 : :
1463 : : /**
1464 : : * Returns the map unit scale for the pattern's line width.
1465 : : *
1466 : : * \see setLineWidthMapUnitScale()
1467 : : * \see lineWidth()
1468 : : * \see lineWidthUnit()
1469 : : */
1470 : : const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }
1471 : :
1472 : : /**
1473 : : * Sets the \a unit for the line pattern's offset.
1474 : :
1475 : : * \see offsetUnit()
1476 : : */
1477 : 70 : void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
1478 : :
1479 : : /**
1480 : : * Returns the units for the line pattern's offset.
1481 : : *
1482 : : * \see setOffsetUnit()
1483 : : */
1484 : : QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
1485 : :
1486 : : /**
1487 : : * Sets the map unit \a scale for the pattern's line offset.
1488 : : *
1489 : : * \see offsetMapUnitScale()
1490 : : * \see setOffset()
1491 : : * \see setOffsetUnit()
1492 : : */
1493 : 70 : void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1494 : :
1495 : : /**
1496 : : * Returns the map unit scale for the pattern's line offset.
1497 : : *
1498 : : * \see setOffsetMapUnitScale()
1499 : : * \see offset()
1500 : : * \see offsetUnit()
1501 : : */
1502 : : const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1503 : :
1504 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1505 : : QgsUnitTypes::RenderUnit outputUnit() const override;
1506 : : bool usesMapUnits() const override;
1507 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1508 : : QgsMapUnitScale mapUnitScale() const override;
1509 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1510 : : QgsSymbol *subSymbol() override;
1511 : : QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1512 : : bool hasDataDefinedProperties() const override;
1513 : :
1514 : : protected:
1515 : :
1516 : : void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1517 : :
1518 : : private:
1519 : : //! Distance (in mm or map units) between lines
1520 : : double mDistance = 5.0;
1521 : : QgsUnitTypes::RenderUnit mDistanceUnit = QgsUnitTypes::RenderMillimeters;
1522 : : QgsMapUnitScale mDistanceMapUnitScale;
1523 : : //! Line width (in mm or map units)
1524 : : double mLineWidth = 0;
1525 : : QgsUnitTypes::RenderUnit mLineWidthUnit = QgsUnitTypes::RenderMillimeters;
1526 : : QgsMapUnitScale mLineWidthMapUnitScale;
1527 : : //! Vector line angle in degrees (0 = horizontal, counterclockwise)
1528 : : double mLineAngle = 45.0;
1529 : : //! Offset perpendicular to line direction
1530 : : double mOffset = 0.0;
1531 : : QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
1532 : : QgsMapUnitScale mOffsetMapUnitScale;
1533 : :
1534 : : #ifdef SIP_RUN
1535 : : QgsLinePatternFillSymbolLayer( const QgsLinePatternFillSymbolLayer &other );
1536 : : #endif
1537 : :
1538 : : //! Applies the svg pattern to the brush
1539 : : void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );
1540 : :
1541 : : //! Fill line
1542 : : QgsLineSymbol *mFillLineSymbol = nullptr;
1543 : : };
1544 : :
1545 : : /**
1546 : : * \ingroup core
1547 : : * \class QgsPointPatternFillSymbolLayer
1548 : : */
1549 : : class CORE_EXPORT QgsPointPatternFillSymbolLayer: public QgsImageFillSymbolLayer
1550 : : {
1551 : : public:
1552 : : QgsPointPatternFillSymbolLayer();
1553 : : ~QgsPointPatternFillSymbolLayer() override;
1554 : :
1555 : : /**
1556 : : * Creates a new QgsPointPatternFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
1557 : : *
1558 : : * Caller takes ownership of the returned symbol layer.
1559 : : */
1560 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1561 : : static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1562 : :
1563 : : QString layerType() const override;
1564 : :
1565 : : void startRender( QgsSymbolRenderContext &context ) override;
1566 : : void stopRender( QgsSymbolRenderContext &context ) override;
1567 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1568 : :
1569 : : QVariantMap properties() const override;
1570 : :
1571 : : QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;
1572 : :
1573 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1574 : :
1575 : : double estimateMaxBleed( const QgsRenderContext &context ) const override;
1576 : :
1577 : : //getters and setters
1578 : : double distanceX() const { return mDistanceX; }
1579 : 30 : void setDistanceX( double d ) { mDistanceX = d; }
1580 : :
1581 : : double distanceY() const { return mDistanceY; }
1582 : 30 : void setDistanceY( double d ) { mDistanceY = d; }
1583 : :
1584 : : double displacementX() const { return mDisplacementX; }
1585 : 30 : void setDisplacementX( double d ) { mDisplacementX = d; }
1586 : :
1587 : : double displacementY() const { return mDisplacementY; }
1588 : 30 : void setDisplacementY( double d ) { mDisplacementY = d; }
1589 : :
1590 : : /**
1591 : : * Sets the horizontal offset values for points in the pattern.
1592 : : * \param offset offset value
1593 : : * \see offsetX()
1594 : : * \see setOffsetY()
1595 : : * \since QGIS 3.8
1596 : : */
1597 : 30 : void setOffsetX( double offset ) { mOffsetX = offset; }
1598 : :
1599 : : /**
1600 : : * Returns the horizontal offset values for points in the pattern.
1601 : : * \see setOffsetX()
1602 : : * \see offsetY()
1603 : : * \since QGIS 3.8
1604 : : */
1605 : : double offsetX() const { return mOffsetX; }
1606 : :
1607 : : /**
1608 : : * Sets the vertical offset values for points in the pattern.
1609 : : * \param offset offset value
1610 : : * \see offsetY()
1611 : : * \see setOffsetX()
1612 : : * \since QGIS 3.8
1613 : : */
1614 : 30 : void setOffsetY( double offset ) { mOffsetY = offset; }
1615 : :
1616 : : /**
1617 : : * Returns the vertical offset values for points in the pattern.
1618 : : * \see setOffsetY()
1619 : : * \see offsetX()
1620 : : * \since QGIS 3.8
1621 : : */
1622 : : double offsetY() const { return mOffsetY; }
1623 : :
1624 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1625 : 0 : QgsSymbol *subSymbol() override { return mMarkerSymbol; }
1626 : :
1627 : : /**
1628 : : * Sets the units for the horizontal distance between points in the pattern.
1629 : : * \param unit distance units
1630 : : * \see distanceXUnit()
1631 : : * \see setDistanceYUnit()
1632 : : */
1633 : 30 : void setDistanceXUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceXUnit = unit; }
1634 : :
1635 : : /**
1636 : : * Returns the units for the horizontal distance between points in the pattern.
1637 : : * \see setDistanceXUnit()
1638 : : * \see distanceYUnit()
1639 : : */
1640 : : QgsUnitTypes::RenderUnit distanceXUnit() const { return mDistanceXUnit; }
1641 : :
1642 : 30 : void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }
1643 : : const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }
1644 : :
1645 : : /**
1646 : : * Sets the units for the vertical distance between points in the pattern.
1647 : : * \param unit distance units
1648 : : * \see distanceYUnit()
1649 : : * \see setDistanceXUnit()
1650 : : */
1651 : 30 : void setDistanceYUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceYUnit = unit; }
1652 : :
1653 : : /**
1654 : : * Returns the units for the vertical distance between points in the pattern.
1655 : : * \see setDistanceYUnit()
1656 : : * \see distanceXUnit()
1657 : : */
1658 : : QgsUnitTypes::RenderUnit distanceYUnit() const { return mDistanceYUnit; }
1659 : :
1660 : 30 : void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }
1661 : : const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }
1662 : :
1663 : : /**
1664 : : * Sets the units for the horizontal displacement between rows in the pattern.
1665 : : * \param unit displacement units
1666 : : * \see displacementXUnit()
1667 : : * \see setDisplacementYUnit()
1668 : : */
1669 : 30 : void setDisplacementXUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementXUnit = unit; }
1670 : :
1671 : : /**
1672 : : * Returns the units for the horizontal displacement between rows in the pattern.
1673 : : * \see setDisplacementXUnit()
1674 : : * \see displacementYUnit()
1675 : : */
1676 : : QgsUnitTypes::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }
1677 : :
1678 : 30 : void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }
1679 : : const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }
1680 : :
1681 : : /**
1682 : : * Sets the units for the vertical displacement between rows in the pattern.
1683 : : * \param unit displacement units
1684 : : * \see displacementYUnit()
1685 : : * \see setDisplacementXUnit()
1686 : : */
1687 : 30 : void setDisplacementYUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementYUnit = unit; }
1688 : :
1689 : : /**
1690 : : * Returns the units for the vertical displacement between rows in the pattern.
1691 : : * \see setDisplacementYUnit()
1692 : : * \see displacementXUnit()
1693 : : */
1694 : : QgsUnitTypes::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }
1695 : :
1696 : 30 : void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }
1697 : : const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }
1698 : :
1699 : : /**
1700 : : * Sets the units for the horizontal offset between rows in the pattern.
1701 : : * \param unit offset units
1702 : : * \see offsetXUnit()
1703 : : * \see setOffsetYUnit()
1704 : : * \since QGIS 3.8
1705 : : */
1706 : 30 : void setOffsetXUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetXUnit = unit; }
1707 : :
1708 : : /**
1709 : : * Returns the units for the horizontal offset for rows in the pattern.
1710 : : * \see setOffsetXUnit()
1711 : : * \see offsetYUnit()
1712 : : * \since QGIS 3.8
1713 : : */
1714 : : QgsUnitTypes::RenderUnit offsetXUnit() const { return mOffsetXUnit; }
1715 : :
1716 : : /**
1717 : : * Sets the unit scale for the horizontal offset for rows in the pattern.
1718 : : * \param scale offset unit scale
1719 : : * \see offsetXMapUnitScale()
1720 : : * \see setOffsetYMapUnitScale()
1721 : : * \since QGIS 3.8
1722 : : */
1723 : 30 : void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }
1724 : :
1725 : : /**
1726 : : * Returns the unit scale for the horizontal offset for rows in the pattern.
1727 : : * \see setOffsetXMapUnitScale()
1728 : : * \see offsetYMapUnitScale()
1729 : : * \since QGIS 3.8
1730 : : */
1731 : : const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }
1732 : :
1733 : : /**
1734 : : * Sets the units for the vertical offset for rows in the pattern.
1735 : : * \param unit offset units
1736 : : * \see offsetYUnit()
1737 : : * \see setOffsetXUnit()
1738 : : * \since QGIS 3.8
1739 : : */
1740 : 30 : void setOffsetYUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetYUnit = unit; }
1741 : :
1742 : : /**
1743 : : * Returns the units for the vertical offset for rows in the pattern.
1744 : : * \see setOffsetYUnit()
1745 : : * \see offsetXUnit()
1746 : : * \since QGIS 3.8
1747 : : */
1748 : : QgsUnitTypes::RenderUnit offsetYUnit() const { return mOffsetYUnit; }
1749 : :
1750 : : /**
1751 : : * Sets the unit scale for the vertical offset for rows in the pattern.
1752 : : * \param scale offset unit scale
1753 : : * \see offsetYMapUnitScale()
1754 : : * \see setOffsetXMapUnitScale()
1755 : : * \since QGIS 3.8
1756 : : */
1757 : 30 : void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }
1758 : :
1759 : : /**
1760 : : * Returns the unit scale for the vertical offset between rows in the pattern.
1761 : : * \see setOffsetYMapUnitScale()
1762 : : * \see offsetXMapUnitScale()
1763 : : * \since QGIS 3.8
1764 : : */
1765 : : const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }
1766 : :
1767 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1768 : : QgsUnitTypes::RenderUnit outputUnit() const override;
1769 : : bool usesMapUnits() const override;
1770 : :
1771 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1772 : : QgsMapUnitScale mapUnitScale() const override;
1773 : :
1774 : : QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1775 : : bool hasDataDefinedProperties() const override;
1776 : : void setColor( const QColor &c ) override;
1777 : : QColor color() const override;
1778 : :
1779 : : protected:
1780 : : QgsMarkerSymbol *mMarkerSymbol = nullptr;
1781 : : double mDistanceX = 15;
1782 : : QgsUnitTypes::RenderUnit mDistanceXUnit = QgsUnitTypes::RenderMillimeters;
1783 : : QgsMapUnitScale mDistanceXMapUnitScale;
1784 : : double mDistanceY = 15;
1785 : : QgsUnitTypes::RenderUnit mDistanceYUnit = QgsUnitTypes::RenderMillimeters;
1786 : : QgsMapUnitScale mDistanceYMapUnitScale;
1787 : : double mDisplacementX = 0;
1788 : : QgsUnitTypes::RenderUnit mDisplacementXUnit = QgsUnitTypes::RenderMillimeters;
1789 : : QgsMapUnitScale mDisplacementXMapUnitScale;
1790 : : double mDisplacementY = 0;
1791 : : QgsUnitTypes::RenderUnit mDisplacementYUnit = QgsUnitTypes::RenderMillimeters;
1792 : : QgsMapUnitScale mDisplacementYMapUnitScale;
1793 : : double mOffsetX = 0;
1794 : : QgsUnitTypes::RenderUnit mOffsetXUnit = QgsUnitTypes::RenderMillimeters;
1795 : : QgsMapUnitScale mOffsetXMapUnitScale;
1796 : : double mOffsetY = 0;
1797 : : QgsUnitTypes::RenderUnit mOffsetYUnit = QgsUnitTypes::RenderMillimeters;
1798 : : QgsMapUnitScale mOffsetYMapUnitScale;
1799 : :
1800 : : void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1801 : :
1802 : : private:
1803 : : #ifdef SIP_RUN
1804 : : QgsPointPatternFillSymbolLayer( const QgsPointPatternFillSymbolLayer &other );
1805 : : #endif
1806 : :
1807 : : void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,
1808 : : double displacementX, double displacementY, double offsetX, double offsetY );
1809 : :
1810 : : bool mRenderUsingMarkers = false;
1811 : : };
1812 : :
1813 : : /**
1814 : : * \ingroup core
1815 : : * \class QgsRandomMarkerFillSymbolLayer
1816 : : *
1817 : : * \brief A fill symbol layer which places markers at random locations within polygons.
1818 : : *
1819 : : * \since QGIS 3.12
1820 : : */
1821 : 0 : class CORE_EXPORT QgsRandomMarkerFillSymbolLayer : public QgsFillSymbolLayer
1822 : : {
1823 : : public:
1824 : :
1825 : : //! Methods to define the number of points randomly filling the polygon
1826 : : enum CountMethod
1827 : : {
1828 : : AbsoluteCount, //!< The point count is used as an absolute count of markers
1829 : : DensityBasedCount, //!< The point count is part of a marker density count
1830 : : };
1831 : :
1832 : : /**
1833 : : * Constructor for QgsRandomMarkerFillSymbolLayer, with the specified \a pointCount.
1834 : : *
1835 : : * Optionally a specific random number \a seed can be used when generating points. A \a seed of 0 indicates that
1836 : : * a truly random sequence will be used on every rendering, causing points to appear in different locations with every map refresh.
1837 : : */
1838 : : QgsRandomMarkerFillSymbolLayer( int pointCount = 10, CountMethod method = AbsoluteCount, double densityArea = 250.0, unsigned long seed = 0 );
1839 : :
1840 : : /**
1841 : : * Creates a new QgsRandomMarkerFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
1842 : : *
1843 : : * Caller takes ownership of the returned symbol layer.
1844 : : */
1845 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1846 : :
1847 : : QString layerType() const override;
1848 : : void startRender( QgsSymbolRenderContext &context ) override;
1849 : : void stopRender( QgsSymbolRenderContext &context ) override;
1850 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1851 : : QVariantMap properties() const override;
1852 : : QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;
1853 : : bool canCauseArtifactsBetweenAdjacentTiles() const override;
1854 : :
1855 : : void setColor( const QColor &color ) override;
1856 : : QColor color() const override;
1857 : :
1858 : : QgsSymbol *subSymbol() override;
1859 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1860 : :
1861 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1862 : : QgsUnitTypes::RenderUnit outputUnit() const override;
1863 : : bool usesMapUnits() const override;
1864 : :
1865 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1866 : : QgsMapUnitScale mapUnitScale() const override;
1867 : :
1868 : : QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1869 : : bool hasDataDefinedProperties() const override;
1870 : :
1871 : : /**
1872 : : * Returns the count of random points to render in the fill.
1873 : : *
1874 : : * \see setPointCount()
1875 : : */
1876 : : int pointCount() const;
1877 : :
1878 : : /**
1879 : : * Sets the \a count of random points to render in the fill.
1880 : : *
1881 : : * \see pointCount()
1882 : : */
1883 : : void setPointCount( int count );
1884 : :
1885 : : /**
1886 : : * Returns the random number seed to use when generating points, or 0 if
1887 : : * a truly random sequence will be used (causing points to appear in different locations with every map refresh).
1888 : : * \see setSeed()
1889 : : */
1890 : : unsigned long seed() const;
1891 : :
1892 : : /**
1893 : : * Sets the random number \a seed to use when generating points, or 0 if
1894 : : * a truly random sequence will be used on every rendering (causing points to appear
1895 : : * in different locations with every map refresh).
1896 : : *
1897 : : * \see seed()
1898 : : */
1899 : : void setSeed( unsigned long seed );
1900 : :
1901 : : /**
1902 : : * Returns TRUE if point markers should be clipped to the polygon boundary.
1903 : : *
1904 : : * \see setClipPoints()
1905 : : */
1906 : : bool clipPoints() const;
1907 : :
1908 : : /**
1909 : : * Sets whether point markers should be \a clipped to the polygon boundary.
1910 : : *
1911 : : * \see clipPoints()
1912 : : */
1913 : : void setClipPoints( bool clipped );
1914 : :
1915 : : /**
1916 : : * Returns the count method used to randomly fill the polygon.
1917 : : *
1918 : : * \see setCountMethod()
1919 : : */
1920 : : CountMethod countMethod() const;
1921 : :
1922 : : /**
1923 : : * Sets the count \a method used to randomly fill the polygon.
1924 : : *
1925 : : * \see countMethod()
1926 : : */
1927 : : void setCountMethod( CountMethod method );
1928 : :
1929 : : /**
1930 : : * Returns the density area used to count the number of points to randomly fill the polygon.
1931 : : *
1932 : : * Only used when the count method is set to QgsRandomMarkerFillSymbolLayer::DensityBasedCount.
1933 : : *
1934 : : * Units are specified by setDensityAreaUnit().
1935 : : *
1936 : : * \see setDensityArea()
1937 : : */
1938 : : double densityArea() const;
1939 : :
1940 : : /**
1941 : : * Sets the density \a area used to count the number of points to randomly fill the polygon.
1942 : : *
1943 : : * \see densityArea()
1944 : : */
1945 : : void setDensityArea( double area );
1946 : :
1947 : : /**
1948 : : * Sets the units for the density area.
1949 : : * \param unit width units
1950 : : * \see densityAreaUnit()
1951 : : */
1952 : 0 : void setDensityAreaUnit( QgsUnitTypes::RenderUnit unit ) { mDensityAreaUnit = unit; }
1953 : :
1954 : : /**
1955 : : * Returns the units for the density area.
1956 : : * \see setDensityAreaUnit()
1957 : : */
1958 : : QgsUnitTypes::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }
1959 : :
1960 : : /**
1961 : : * Sets the map scale for the density area.
1962 : : * \param scale density area map unit scale
1963 : : * \see densityAreaUnitScale()
1964 : : * \see setDensityArea()
1965 : : * \see setDensityAreaUnit()
1966 : : */
1967 : 0 : void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }
1968 : :
1969 : : /**
1970 : : * Returns the map scale for the density area.
1971 : : * \see setDensityAreaUnitScale()
1972 : : * \see densityArea()
1973 : : * \see densityAreaUnit()
1974 : : */
1975 : : const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }
1976 : :
1977 : : void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1978 : : void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1979 : :
1980 : : private:
1981 : : #ifdef SIP_RUN
1982 : : QgsRandomMarkerFillSymbolLayer( const QgsRandomMarkerFillSymbolLayer &other );
1983 : : #endif
1984 : :
1985 : 0 : struct Part
1986 : : {
1987 : : QPolygonF exterior;
1988 : : QVector<QPolygonF> rings;
1989 : : };
1990 : :
1991 : : QVector< Part > mCurrentParts;
1992 : :
1993 : : void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );
1994 : :
1995 : : std::unique_ptr< QgsMarkerSymbol > mMarker;
1996 : : CountMethod mCountMethod = AbsoluteCount;
1997 : : int mPointCount = 10;
1998 : : double mDensityArea = 250.0;
1999 : : QgsUnitTypes::RenderUnit mDensityAreaUnit = QgsUnitTypes::RenderMillimeters;
2000 : : QgsMapUnitScale mDensityAreaUnitScale;
2001 : : unsigned long mSeed = 0;
2002 : : bool mClipPoints = false;
2003 : :
2004 : : bool mRenderingFeature = false;
2005 : : double mFeatureSymbolOpacity = 1;
2006 : : };
2007 : :
2008 : :
2009 : : /**
2010 : : * \ingroup core
2011 : : * \class QgsCentroidFillSymbolLayer
2012 : : */
2013 : 0 : class CORE_EXPORT QgsCentroidFillSymbolLayer : public QgsFillSymbolLayer
2014 : : {
2015 : : public:
2016 : : QgsCentroidFillSymbolLayer();
2017 : :
2018 : : // static stuff
2019 : :
2020 : : /**
2021 : : * Creates a new QgsCentroidFillSymbolLayer using the specified \a properties map containing symbol properties (see properties()).
2022 : : *
2023 : : * Caller takes ownership of the returned symbol layer.
2024 : : */
2025 : : static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2026 : : static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
2027 : :
2028 : : // implemented from base classes
2029 : :
2030 : : QString layerType() const override;
2031 : : void startRender( QgsSymbolRenderContext &context ) override;
2032 : : void stopRender( QgsSymbolRenderContext &context ) override;
2033 : : void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2034 : : QVariantMap properties() const override;
2035 : : QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;
2036 : : void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
2037 : : void setColor( const QColor &color ) override;
2038 : : QColor color() const override;
2039 : : QgsSymbol *subSymbol() override;
2040 : : bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
2041 : : void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
2042 : : QgsUnitTypes::RenderUnit outputUnit() const override;
2043 : : bool usesMapUnits() const override;
2044 : : void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2045 : : QgsMapUnitScale mapUnitScale() const override;
2046 : : QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2047 : : bool hasDataDefinedProperties() const override;
2048 : : bool canCauseArtifactsBetweenAdjacentTiles() const override;
2049 : :
2050 : 0 : void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }
2051 : : bool pointOnSurface() const { return mPointOnSurface; }
2052 : :
2053 : : /**
2054 : : * Sets whether a point is drawn for all parts or only on the biggest part of multi-part features.
2055 : : * \see pointOnAllParts()
2056 : : * \since QGIS 2.16
2057 : : */
2058 : 0 : void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }
2059 : :
2060 : : /**
2061 : : * Returns whether a point is drawn for all parts or only on the biggest part of multi-part features.
2062 : : * \see setPointOnAllParts()
2063 : : * \since QGIS 2.16
2064 : : */
2065 : : bool pointOnAllParts() const { return mPointOnAllParts; }
2066 : :
2067 : : /**
2068 : : * Returns TRUE if point markers should be clipped to the polygon boundary.
2069 : : *
2070 : : * \see setClipPoints()
2071 : : * \since 3.14
2072 : : */
2073 : : bool clipPoints() const { return mClipPoints; }
2074 : :
2075 : : /**
2076 : : * Sets whether point markers should be \a clipped to the polygon boundary.
2077 : : *
2078 : : * \see clipPoints()
2079 : : * \since 3.14
2080 : : */
2081 : 0 : void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }
2082 : :
2083 : : /**
2084 : : * Returns TRUE if point markers should be clipped to the current part boundary only.
2085 : : *
2086 : : * \see setClipPoints()
2087 : : * \since 3.14
2088 : : */
2089 : : bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }
2090 : :
2091 : : /**
2092 : : * Sets whether point markers should be \a clipped to the current part boundary only.
2093 : : *
2094 : : * \see clipOnCurrentPartOnly()
2095 : : * \since 3.14
2096 : : */
2097 : 0 : void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }
2098 : :
2099 : : void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2100 : : void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2101 : :
2102 : : protected:
2103 : :
2104 : : std::unique_ptr< QgsMarkerSymbol > mMarker;
2105 : : bool mPointOnSurface = false;
2106 : : bool mPointOnAllParts = true;
2107 : : bool mClipPoints = false;
2108 : : bool mClipOnCurrentPartOnly = false;
2109 : :
2110 : : bool mRenderingFeature = false;
2111 : : double mFeatureSymbolOpacity = 1;
2112 : :
2113 : : QgsFeatureId mCurrentFeatureId = -1;
2114 : : int mBiggestPartIndex = -1;
2115 : :
2116 : : private:
2117 : : #ifdef SIP_RUN
2118 : : QgsCentroidFillSymbolLayer( const QgsCentroidFillSymbolLayer &other );
2119 : : #endif
2120 : 0 : struct Part
2121 : : {
2122 : : QPolygonF exterior;
2123 : : QVector<QPolygonF> rings;
2124 : : };
2125 : :
2126 : : void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );
2127 : : QVector<Part> mCurrentParts;
2128 : : };
2129 : :
2130 : : #endif
2131 : :
2132 : :
|
