QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsfillsymbollayer.h
Go to the documentation of this file.
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
35class QgsMarkerSymbol;
36class QgsLineSymbol;
37class QgsPathResolver;
38
45{
46 public:
48 Qt::BrushStyle style = DEFAULT_SIMPLEFILL_STYLE,
49 const QColor &strokeColor = DEFAULT_SIMPLEFILL_BORDERCOLOR,
50 Qt::PenStyle strokeStyle = DEFAULT_SIMPLEFILL_BORDERSTYLE,
51 double strokeWidth = DEFAULT_SIMPLEFILL_BORDERWIDTH,
52 Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEFILL_JOINSTYLE
53 );
54
56
57 // static stuff
58
64 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
65 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
66
67 // implemented from base classes
68
69 QString layerType() const override;
70 Qgis::SymbolLayerFlags flags() const override;
71 void startRender( QgsSymbolRenderContext &context ) override;
72 void stopRender( QgsSymbolRenderContext &context ) override;
73 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
74 QVariantMap properties() const override;
75 QgsSimpleFillSymbolLayer *clone() const override SIP_FACTORY;
76 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
77 QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;
78
79 Qt::BrushStyle brushStyle() const { return mBrushStyle; }
80 void setBrushStyle( Qt::BrushStyle style ) { mBrushStyle = style; }
81
82 QColor strokeColor() const override { return mStrokeColor; }
83 void setStrokeColor( const QColor &strokeColor ) override { mStrokeColor = strokeColor; }
84 QColor fillColor() const override { return color(); }
85 void setFillColor( const QColor &color ) override { setColor( color ); }
86
87 Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
88 void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
89
90 double strokeWidth() const { return mStrokeWidth; }
91 void setStrokeWidth( double strokeWidth ) { mStrokeWidth = strokeWidth; }
92
93 Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
94 void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
95
104 void setOffset( QPointF offset ) { mOffset = offset; }
105
114 QPointF offset() const { return mOffset; }
115
121 void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }
122
127 Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
128
129 void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
130 const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
131
137 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
138
144 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
145
151 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
152
158 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
159
160 void setOutputUnit( Qgis::RenderUnit unit ) override;
161 Qgis::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 QImage toTiledPatternImage( ) const override;
177
178 protected:
179 QBrush mBrush;
180 QBrush mSelBrush;
181 Qt::BrushStyle mBrushStyle;
183 Qt::PenStyle mStrokeStyle;
187 Qt::PenJoinStyle mPenJoinStyle;
188 QPen mPen;
190
191 QPointF mOffset;
194
195 private:
196 //helper functions for data defined symbology
197 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );
198
199};
200
201class QgsColorRamp;
202
209{
210 public:
211
216 const QColor &color2 = Qt::white,
221 );
222
224
225 // static stuff
226
232 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
233
234 // implemented from base classes
235
236 Qgis::SymbolLayerFlags flags() const override;
237 QString layerType() const override;
238 void startRender( QgsSymbolRenderContext &context ) override;
239 void stopRender( QgsSymbolRenderContext &context ) override;
240 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
241 QVariantMap properties() const override;
243 double estimateMaxBleed( const QgsRenderContext &context ) const override;
244 bool canCauseArtifactsBetweenAdjacentTiles() const override;
245
251 Qgis::GradientType gradientType() const { return mGradientType; }
252
258 void setGradientType( Qgis::GradientType gradientType ) { mGradientType = gradientType; }
259
265 Qgis::GradientColorSource gradientColorType() const { return mGradientColorType; }
266
272 void setGradientColorType( Qgis::GradientColorSource gradientColorType ) { mGradientColorType = gradientColorType; }
273
280 QgsColorRamp *colorRamp() { return mGradientRamp; }
281
289 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
290
296 QColor color2() const { return mColor2; }
297
303 void setColor2( const QColor &color2 ) { mColor2 = color2; }
304
310 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
311
317 void setCoordinateMode( Qgis::SymbolCoordinateReference coordinateMode ) { mCoordinateMode = coordinateMode; }
318
324 Qgis::GradientSpread gradientSpread() const { return mGradientSpread; }
325
331 void setGradientSpread( Qgis::GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }
332
338 void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }
339
345 QPointF referencePoint1() const { return mReferencePoint1; }
346
352 void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }
353
359 bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }
360
366 void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }
367
373 QPointF referencePoint2() const { return mReferencePoint2; }
374
380 void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }
381
382
388 bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }
389
398 void setOffset( QPointF offset ) { mOffset = offset; }
399
408 QPointF offset() const { return mOffset; }
409
415 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
416
422 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
423
429 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
430
436 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
437
438 void setOutputUnit( Qgis::RenderUnit unit ) override;
439 Qgis::RenderUnit outputUnit() const override;
440 bool usesMapUnits() const override;
441
442 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
443 QgsMapUnitScale mapUnitScale() const override;
444
445 protected:
446 QBrush mBrush;
447 QBrush mSelBrush;
448
450 QColor mColor2;
451 QgsColorRamp *mGradientRamp = nullptr;
455
457 bool mReferencePoint1IsCentroid = false;
459 bool mReferencePoint2IsCentroid = false;
460
461 QPointF mOffset;
464
465 private:
466
467 //helper functions for data defined symbology
468 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );
469
471 void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,
472 Qgis::GradientColorSource gradientColorType, QgsColorRamp *gradientRamp, Qgis::GradientType gradientType,
473 Qgis::SymbolCoordinateReference coordinateMode, Qgis::GradientSpread gradientSpread,
474 QPointF referencePoint1, QPointF referencePoint2, double angle );
475
477 QPointF rotateReferencePoint( QPointF refPoint, double angle );
478};
479
485{
486 public:
487
491 QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,
493 int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );
494
496
502
508
509 // static stuff
510
516 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
517
518 // implemented from base classes
519
520 QString layerType() const override;
521 Qgis::SymbolLayerFlags flags() const override;
522 void startRender( QgsSymbolRenderContext &context ) override;
523 void stopRender( QgsSymbolRenderContext &context ) override;
524 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
525 QVariantMap properties() const override;
526 QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;
527 double estimateMaxBleed( const QgsRenderContext &context ) const override;
528 bool canCauseArtifactsBetweenAdjacentTiles() const override;
529
535 void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }
536
542 int blurRadius() const { return mBlurRadius; }
543
551 void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }
552
559 bool useWholeShape() const { return mUseWholeShape; }
560
568 void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }
569
577 double maxDistance() const { return mMaxDistance; }
578
585 void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }
586
593 Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }
594
595 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
596 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
597
607 void setColorType( Qgis::GradientColorSource colorType ) { mColorType = colorType; }
608
618 Qgis::GradientColorSource colorType() const { return mColorType; }
619
628 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
629
636 QgsColorRamp *colorRamp() { return mGradientRamp.get(); }
637
644 void setColor2( const QColor &color2 ) { mColor2 = color2; }
645
652 QColor color2() const { return mColor2; }
653
660 void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }
661
667 bool ignoreRings() const { return mIgnoreRings; }
668
675 void setOffset( QPointF offset ) { mOffset = offset; }
676
683 QPointF offset() const { return mOffset; }
684
691 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
692
699 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
700
701 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
702 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
703
704 void setOutputUnit( Qgis::RenderUnit unit ) override;
705 Qgis::RenderUnit outputUnit() const override;
706 bool usesMapUnits() const override;
707
708 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
709 QgsMapUnitScale mapUnitScale() const override;
710
711 private:
712 QBrush mBrush;
713 QBrush mSelBrush;
714
715 int mBlurRadius = 0;
716
717 bool mUseWholeShape = true;
718 double mMaxDistance = 5.0;
720 QgsMapUnitScale mDistanceMapUnitScale;
721
723 QColor mColor2;
724
725 bool mIgnoreRings = false;
726
727 QPointF mOffset;
729 QgsMapUnitScale mOffsetMapUnitScale;
730
731 std::unique_ptr< QgsColorRamp > mGradientRamp;
732
733 //helper functions for data defined symbology
734 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,
735 double &maxDistance, bool &ignoreRings );
736
737 /* distance transform of a 1d function using squared distance */
738 void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
739 /* distance transform of 2d function using squared distance */
740 void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );
741 /* distance transform of a binary QImage */
742 double *distanceTransform( QImage *im, QgsRenderContext &context );
743
744 /* fills a QImage with values from an array of doubles containing squared distance transform values */
745 void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );
746
747#ifdef SIP_RUN
749#endif
750};
751
757{
758 public:
759
762
763 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
764
770 void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }
771
777 Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
778
785 void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
786
794 const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
795
803 void setCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference ) { mCoordinateReference = coordinateReference; }
804
812 Qgis::SymbolCoordinateReference coordinateReference() const { return mCoordinateReference; }
813
814 void setOutputUnit( Qgis::RenderUnit unit ) override;
815 Qgis::RenderUnit outputUnit() const override;
816 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
817 QgsMapUnitScale mapUnitScale() const override;
818 double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
819 Qt::PenStyle dxfPenStyle() const override;
820 QVariantMap properties() const override;
821
822 protected:
823 QBrush mBrush;
825 double mNextAngle = 0.0; // mAngle / data defined angle
826
828 double mStrokeWidth = 0.0;
831
835 virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }
836
842 virtual bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const;
843
844 private:
845#ifdef SIP_RUN
847#endif
848};
849
856{
857 public:
858
863 QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );
864
866
871 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
872
878 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
879
884 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
885
886 // implemented from base classes
887 QString layerType() const override;
888 Qgis::SymbolLayerFlags flags() const override;
889 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
890 void startRender( QgsSymbolRenderContext &context ) override;
891 void stopRender( QgsSymbolRenderContext &context ) override;
892 QVariantMap properties() const override;
893 QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;
894 double estimateMaxBleed( const QgsRenderContext &context ) const override;
895 bool usesMapUnits() const override;
896 QColor color() const override;
897 void setOutputUnit( Qgis::RenderUnit unit ) override;
898
899 //override QgsImageFillSymbolLayer's support for sub symbols
900 QgsSymbol *subSymbol() override { return nullptr; }
901 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
902
908 void setImageFilePath( const QString &imagePath );
909
915 QString imageFilePath() const { return mImageFilePath; }
916
923 void setCoordinateMode( Qgis::SymbolCoordinateReference mode );
924
931 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
932
938 void setOpacity( double opacity );
939
945 double opacity() const { return mOpacity; }
946
954 void setOffset( QPointF offset ) { mOffset = offset; }
955
963 QPointF offset() const { return mOffset; }
964
972 void setOffsetUnit( const Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
973
981 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
982
990 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
991
999 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1000
1012 void setWidth( double width ) { mWidth = width; }
1013
1024 double width() const { return mWidth; }
1025
1037 void setHeight( double height ) { mHeight = height; }
1038
1049 double height() const { return mHeight; }
1050
1060 Q_DECL_DEPRECATED void setWidthUnit( Qgis::RenderUnit unit ) SIP_DEPRECATED { mSizeUnit = unit; }
1061
1071 void setSizeUnit( Qgis::RenderUnit unit ) { mSizeUnit = unit; }
1072
1082 Q_DECL_DEPRECATED Qgis::RenderUnit widthUnit() const SIP_DEPRECATED { return mSizeUnit; }
1083
1094 Qgis::RenderUnit sizeUnit() const { return mSizeUnit; }
1095
1105 Q_DECL_DEPRECATED void setWidthMapUnitScale( const QgsMapUnitScale &scale ) SIP_DEPRECATED { mSizeMapUnitScale = scale; }
1106
1117 void setSizeMapUnitScale( const QgsMapUnitScale &scale ) { mSizeMapUnitScale = scale; }
1118
1128 Q_DECL_DEPRECATED const QgsMapUnitScale &widthMapUnitScale() const SIP_DEPRECATED { return mSizeMapUnitScale; }
1129
1140 const QgsMapUnitScale &sizeMapUnitScale() const { return mSizeMapUnitScale; }
1141
1142 protected:
1143
1144 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1145 bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const override;
1146 private:
1147
1149 QString mImageFilePath;
1151 double mOpacity = 1.0;
1152
1153 QPointF mOffset;
1155 QgsMapUnitScale mOffsetMapUnitScale;
1156
1157 double mWidth = 0.0;
1159 QgsMapUnitScale mSizeMapUnitScale;
1160
1161 double mHeight = 0.0;
1162
1164 void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double height, double opacity,
1165 const QgsSymbolRenderContext &context );
1166};
1167
1173{
1174 public:
1175
1179 QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );
1180
1184 QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );
1185
1187
1192 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1193
1198 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1199
1204 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
1205
1206 // implemented from base classes
1207
1208 QString layerType() const override;
1209 void startRender( QgsSymbolRenderContext &context ) override;
1210 void stopRender( QgsSymbolRenderContext &context ) override;
1211 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1212 QVariantMap properties() const override;
1213 QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;
1214 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1215 bool usesMapUnits() const override;
1216 QgsSymbol *subSymbol() override;
1217 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1218 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1219 QColor dxfColor( QgsSymbolRenderContext &context ) const override;
1220 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1221 bool hasDataDefinedProperties() const override;
1222
1234 void setSvgFilePath( const QString &svgPath );
1235
1241 QString svgFilePath() const { return mSvgFilePath; }
1242
1252 void setPatternWidth( double width ) { mPatternWidth = width;}
1253
1263 double patternWidth() const { return mPatternWidth; }
1264
1274 void setSvgFillColor( const QColor &c ) { setColor( c ); }
1275
1284 QColor svgFillColor() const { return color(); }
1285
1295 void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }
1296
1305 QColor svgStrokeColor() const { return mSvgStrokeColor; }
1306
1317 void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }
1318
1329 double svgStrokeWidth() const { return mSvgStrokeWidth; }
1330
1338 void setPatternWidthUnit( Qgis::RenderUnit unit ) { mPatternWidthUnit = unit; }
1339
1347 Qgis::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }
1348
1356 void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }
1357
1365 const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }
1366
1374 void setSvgStrokeWidthUnit( Qgis::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }
1375
1383 Qgis::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }
1384
1392 void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }
1393
1401 const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }
1402
1403 void setOutputUnit( Qgis::RenderUnit unit ) override;
1404 Qgis::RenderUnit outputUnit() const override;
1405
1406 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1407 QgsMapUnitScale mapUnitScale() const override;
1408
1413 QMap<QString, QgsProperty> parameters() const { return mParameters; }
1414
1419 void setParameters( const QMap<QString, QgsProperty> &parameters );
1420
1421 protected:
1422
1423 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1424
1425 private:
1426
1428 double mPatternWidth = 20;
1430 QgsMapUnitScale mPatternWidthMapUnitScale;
1431 QMap<QString, QgsProperty> mParameters;
1432
1434 QByteArray mSvgData;
1436 QString mSvgFilePath;
1438 QRectF mSvgViewBox;
1439
1440 //param(fill), param(stroke), param(stroke-width) are going
1441 //to be replaced in memory
1442 QColor mSvgStrokeColor = QColor( 35, 35, 35 );
1443 double mSvgStrokeWidth = 0.2;
1444 Qgis::RenderUnit mSvgStrokeWidthUnit = Qgis::RenderUnit::Millimeters;
1445 QgsMapUnitScale mSvgStrokeWidthMapUnitScale;
1446
1448 std::unique_ptr< QgsLineSymbol > mStroke;
1449
1451 void storeViewBox();
1452 void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath
1453
1455 void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, Qgis::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,
1456 double svgStrokeWidth, Qgis::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,
1457 const QgsStringMap svgParameters );
1458};
1459
1466{
1467 public:
1470
1475 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1476
1481 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1482
1483 QString layerType() const override;
1484 void startRender( QgsSymbolRenderContext &context ) override;
1485 void stopRender( QgsSymbolRenderContext &context ) override;
1486 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1487 QVariantMap properties() const override;
1488 QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;
1489 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1490 QImage toTiledPatternImage( ) const override;
1491 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1492
1493 QString ogrFeatureStyleWidth( double widthScaleFactor ) const;
1494
1502 void setLineAngle( double a ) { mLineAngle = a; }
1503
1511 double lineAngle() const { return mLineAngle; }
1512
1519 void setDistance( double d ) { mDistance = d; }
1520
1526 double distance() const { return mDistance; }
1527
1534 void setLineWidth( double w );
1535
1542 double lineWidth() const { return mLineWidth; }
1543
1544 void setColor( const QColor &c ) override;
1545 QColor color() const override;
1546
1558 void setOffset( double offset ) { mOffset = offset; }
1559
1571 double offset() const { return mOffset; }
1572
1579 void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }
1580
1587 Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }
1588
1596 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
1597
1605 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
1606
1612 void setLineWidthUnit( Qgis::RenderUnit unit ) { mLineWidthUnit = unit; }
1613
1619 Qgis::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }
1620
1628 void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }
1629
1637 const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }
1638
1644 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
1645
1651 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
1652
1660 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1661
1669 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1670
1677 Qgis::LineClipMode clipMode() const { return mClipMode; }
1678
1685 void setClipMode( Qgis::LineClipMode mode ) { mClipMode = mode; }
1686
1687 void setOutputUnit( Qgis::RenderUnit unit ) override;
1688 Qgis::RenderUnit outputUnit() const override;
1689 bool usesMapUnits() const override;
1690 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1691 QgsMapUnitScale mapUnitScale() const override;
1692 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1693 QgsSymbol *subSymbol() override;
1694 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1695 bool hasDataDefinedProperties() const override;
1696 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1697 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1698
1699 protected:
1700
1701 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1702
1703 private:
1705 double mDistance = 5.0;
1707 QgsMapUnitScale mDistanceMapUnitScale;
1709 double mLineWidth = 0;
1711 QgsMapUnitScale mLineWidthMapUnitScale;
1713 double mLineAngle = 45.0;
1715 double mOffset = 0.0;
1717 QgsMapUnitScale mOffsetMapUnitScale;
1718
1719 bool mRenderUsingLines = false;
1720
1721#ifdef SIP_RUN
1723#endif
1724
1726 bool applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );
1727
1729 std::unique_ptr< QgsLineSymbol > mFillLineSymbol;
1730 bool mFillLineSymbolRenderStarted = false;
1731
1733};
1734
1741{
1742 public:
1745
1751 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1752 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1753
1754 QString layerType() const override;
1755 void startRender( QgsSymbolRenderContext &context ) override;
1756 void stopRender( QgsSymbolRenderContext &context ) override;
1757 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1758 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1759 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1760 QVariantMap properties() const override;
1761 QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;
1762 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1763 QImage toTiledPatternImage( ) const override;
1764 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1765 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1766 QgsSymbol *subSymbol() override;
1767 void setOutputUnit( Qgis::RenderUnit unit ) override;
1768 Qgis::RenderUnit outputUnit() const override;
1769 bool usesMapUnits() const override;
1770 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1771 QgsMapUnitScale mapUnitScale() const override;
1772 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1773 bool hasDataDefinedProperties() const override;
1774 void setColor( const QColor &c ) override;
1775 QColor color() const override;
1776
1786 double distanceX() const { return mDistanceX; }
1787
1797 void setDistanceX( double d ) { mDistanceX = d; }
1798
1805 void setDistanceXUnit( Qgis::RenderUnit unit ) { mDistanceXUnit = unit; }
1806
1812 Qgis::RenderUnit distanceXUnit() const { return mDistanceXUnit; }
1813
1820 void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }
1821
1828 const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }
1829
1839 double distanceY() const { return mDistanceY; }
1840
1850 void setDistanceY( double d ) { mDistanceY = d; }
1851
1858 void setDistanceYUnit( Qgis::RenderUnit unit ) { mDistanceYUnit = unit; }
1859
1865 Qgis::RenderUnit distanceYUnit() const { return mDistanceYUnit; }
1866
1873 void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }
1874
1881 const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }
1882
1892 double displacementX() const { return mDisplacementX; }
1893
1903 void setDisplacementX( double d ) { mDisplacementX = d; }
1904
1911 void setDisplacementXUnit( Qgis::RenderUnit unit ) { mDisplacementXUnit = unit; }
1912
1918 Qgis::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }
1919
1926 void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }
1927
1934 const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }
1935
1945 double displacementY() const { return mDisplacementY; }
1946
1956 void setDisplacementY( double d ) { mDisplacementY = d; }
1957
1964 void setDisplacementYUnit( Qgis::RenderUnit unit ) { mDisplacementYUnit = unit; }
1965
1971 Qgis::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }
1972
1979 void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }
1980
1987 const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }
1988
1996 void setOffsetX( double offset ) { mOffsetX = offset; }
1997
2004 double offsetX() const { return mOffsetX; }
2005
2013 void setOffsetY( double offset ) { mOffsetY = offset; }
2014
2021 double offsetY() const { return mOffsetY; }
2022
2030 void setOffsetXUnit( Qgis::RenderUnit unit ) { mOffsetXUnit = unit; }
2031
2038 Qgis::RenderUnit offsetXUnit() const { return mOffsetXUnit; }
2039
2047 void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }
2048
2055 const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }
2056
2064 void setOffsetYUnit( Qgis::RenderUnit unit ) { mOffsetYUnit = unit; }
2065
2072 Qgis::RenderUnit offsetYUnit() const { return mOffsetYUnit; }
2073
2081 void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }
2082
2089 const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }
2090
2097 Qgis::MarkerClipMode clipMode() const { return mClipMode; }
2098
2105 void setClipMode( Qgis::MarkerClipMode mode ) { mClipMode = mode; }
2106
2116 void setMaximumRandomDeviationX( double deviation ) { mRandomDeviationX = deviation; }
2117
2127 double maximumRandomDeviationX() const { return mRandomDeviationX; }
2128
2138 void setMaximumRandomDeviationY( double deviation ) { mRandomDeviationY = deviation; }
2139
2149 double maximumRandomDeviationY() const { return mRandomDeviationY; }
2150
2158 void setRandomDeviationXUnit( Qgis::RenderUnit unit ) { mRandomDeviationXUnit = unit; }
2159
2167 Qgis::RenderUnit randomDeviationXUnit() const { return mRandomDeviationXUnit; }
2168
2176 void setRandomDeviationYUnit( Qgis::RenderUnit unit ) { mRandomDeviationYUnit = unit; }
2177
2186 Qgis::RenderUnit randomDeviationYUnit() const { return mRandomDeviationYUnit; }
2187
2195 const QgsMapUnitScale &randomDeviationXMapUnitScale() const { return mRandomDeviationXMapUnitScale; }
2196
2204 const QgsMapUnitScale &randomDeviationYMapUnitScale() const { return mRandomDeviationYMapUnitScale; }
2205
2213 void setRandomDeviationXMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationXMapUnitScale = scale; }
2214
2222 void setRandomDeviationYMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationYMapUnitScale = scale; }
2223
2230 unsigned long seed() const { return mSeed; }
2231
2240 void setSeed( unsigned long seed ) { mSeed = seed; }
2241
2242 protected:
2243 std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;
2244 bool mMarkerSymbolRenderStarted = false;
2245 double mDistanceX = 15;
2248 double mDistanceY = 15;
2251 double mDisplacementX = 0;
2254 double mDisplacementY = 0;
2257 double mOffsetX = 0;
2260 double mOffsetY = 0;
2263
2264 double mRandomDeviationX = 0;
2267 double mRandomDeviationY = 0;
2270 unsigned long mSeed = 0;
2271
2272 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
2273
2274 private:
2275#ifdef SIP_RUN
2277#endif
2278
2279 bool applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,
2280 double displacementX, double displacementY, double offsetX, double offsetY );
2281
2283
2284 bool mRenderUsingMarkers = false;
2285};
2286
2296{
2297 public:
2298
2305 QgsRandomMarkerFillSymbolLayer( int pointCount = 10, Qgis::PointCountMethod method = Qgis::PointCountMethod::Absolute, double densityArea = 250.0, unsigned long seed = 0 );
2306
2308
2314 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2315
2316 QString layerType() const override;
2317 void startRender( QgsSymbolRenderContext &context ) override;
2318 void stopRender( QgsSymbolRenderContext &context ) override;
2319 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2320 QVariantMap properties() const override;
2321 QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;
2322 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2323
2324 void setColor( const QColor &color ) override;
2325 QColor color() const override;
2326
2327 QgsSymbol *subSymbol() override;
2328 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) FINAL;
2329
2330 void setOutputUnit( Qgis::RenderUnit unit ) override;
2331 Qgis::RenderUnit outputUnit() const override;
2332 bool usesMapUnits() const override;
2333
2334 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2335 QgsMapUnitScale mapUnitScale() const override;
2336
2337 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2338 bool hasDataDefinedProperties() const override;
2339
2345 int pointCount() const;
2346
2352 void setPointCount( int count );
2353
2359 unsigned long seed() const;
2360
2368 void setSeed( unsigned long seed );
2369
2375 bool clipPoints() const;
2376
2382 void setClipPoints( bool clipped );
2383
2389 Qgis::PointCountMethod countMethod() const;
2390
2396 void setCountMethod( Qgis::PointCountMethod method );
2397
2407 double densityArea() const;
2408
2414 void setDensityArea( double area );
2415
2421 void setDensityAreaUnit( Qgis::RenderUnit unit ) { mDensityAreaUnit = unit; }
2422
2427 Qgis::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }
2428
2436 void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }
2437
2444 const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }
2445
2446 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2447 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2448
2449 private:
2450#ifdef SIP_RUN
2452#endif
2453
2454 struct Part
2455 {
2456 QPolygonF exterior;
2457 QVector<QPolygonF> rings;
2458 };
2459
2460 QVector< Part > mCurrentParts;
2461
2462 void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );
2463
2464 std::unique_ptr< QgsMarkerSymbol > mMarker;
2466 int mPointCount = 10;
2467 double mDensityArea = 250.0;
2469 QgsMapUnitScale mDensityAreaUnitScale;
2470 unsigned long mSeed = 0;
2471 bool mClipPoints = false;
2472
2473 bool mRenderingFeature = false;
2474 double mFeatureSymbolOpacity = 1;
2475};
2476
2477
2485{
2486 public:
2489
2490 // static stuff
2491
2497 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2498 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
2499
2500 // implemented from base classes
2501
2502 QString layerType() const override;
2503 void startRender( QgsSymbolRenderContext &context ) override;
2504 void stopRender( QgsSymbolRenderContext &context ) override;
2505 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2506 QVariantMap properties() const override;
2507 QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;
2508 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
2509 void setColor( const QColor &color ) override;
2510 QColor color() const override;
2511 QgsSymbol *subSymbol() override;
2512 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) FINAL;
2513 void setOutputUnit( Qgis::RenderUnit unit ) override;
2514 Qgis::RenderUnit outputUnit() const override;
2515 bool usesMapUnits() const override;
2516 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2517 QgsMapUnitScale mapUnitScale() const override;
2518 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2519 bool hasDataDefinedProperties() const override;
2520 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2521
2522 void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }
2523 bool pointOnSurface() const { return mPointOnSurface; }
2524
2529 void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }
2530
2535 bool pointOnAllParts() const { return mPointOnAllParts; }
2536
2543 bool clipPoints() const { return mClipPoints; }
2544
2551 void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }
2552
2559 bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }
2560
2567 void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }
2568
2569 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2570 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2571
2572 protected:
2573
2574 std::unique_ptr< QgsMarkerSymbol > mMarker;
2575 bool mPointOnSurface = false;
2576 bool mPointOnAllParts = true;
2577 bool mClipPoints = false;
2578 bool mClipOnCurrentPartOnly = false;
2579
2580 bool mRenderingFeature = false;
2581 double mFeatureSymbolOpacity = 1;
2582 bool mUseSelectedColor = false;
2583
2584 private:
2585#ifdef SIP_RUN
2587#endif
2588 struct Part
2589 {
2590 QPolygonF exterior;
2591 QVector<QPolygonF> rings;
2592 };
2593
2594 void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );
2595 QVector<Part> mCurrentParts;
2596};
2597
2598#endif
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
MarkerClipMode
Marker clipping modes.
Definition qgis.h:3018
@ Shape
Clip to polygon shape.
LineClipMode
Line clipping modes.
Definition qgis.h:3032
@ ClipPainterOnly
Applying clipping on the painter only (i.e. line endpoints will coincide with polygon bounding box,...
GradientColorSource
Gradient color sources.
Definition qgis.h:2947
@ SimpleTwoColor
Simple two color gradient.
GradientSpread
Gradient spread options, which control how gradients are rendered outside of their start and end poin...
Definition qgis.h:2991
@ Pad
Pad out gradient using colors at endpoint of gradient.
PointCountMethod
Methods which define the number of points randomly filling a polygon.
Definition qgis.h:3006
@ Absolute
The point count is used as an absolute count of markers.
QFlags< SymbolLayerFlag > SymbolLayerFlags
Symbol layer flags.
Definition qgis.h:821
RenderUnit
Rendering size units.
Definition qgis.h:4839
@ Millimeters
Millimeters.
GradientType
Gradient types.
Definition qgis.h:2961
@ Linear
Linear gradient.
SymbolCoordinateReference
Symbol coordinate reference modes.
Definition qgis.h:2976
@ Feature
Relative to feature/shape being rendered.
A fill symbol layer which renders a marker symbol at the centroid of a polygon geometry.
void setPointOnAllParts(bool pointOnAllParts)
Sets whether a point is drawn for all parts or only on the biggest part of multi-part features.
void setClipOnCurrentPartOnly(bool clipOnCurrentPartOnly)
Sets whether point markers should be clipped to the current part boundary only.
void setClipPoints(bool clipPoints)
Sets whether point markers should be clipped to the polygon boundary.
std::unique_ptr< QgsMarkerSymbol > mMarker
bool pointOnAllParts() const
Returns whether a point is drawn for all parts or only on the biggest part of multi-part features.
bool clipPoints() const
Returns true if point markers should be clipped to the polygon boundary.
~QgsCentroidFillSymbolLayer() override
bool clipOnCurrentPartOnly() const
Returns true if point markers should be clipped to the current part boundary only.
Abstract base class for color ramps.
Exports QGIS layers to the DXF format.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
Abstract base class for fill symbol layers.
virtual void renderPolygon(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)=0
Renders the fill symbol layer for the polygon whose outer ring is defined by points,...
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
A fill symbol layer which draws a smooth color gradient over a polygon.
QColor color2() const
Returns the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoC...
void setGradientSpread(Qgis::GradientSpread gradientSpread)
Sets the gradient spread mode, which controls how the gradient behaves outside of the predefined stop...
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
Qgis::SymbolCoordinateReference coordinateMode() const
Returns the coordinate mode for gradient, which controls how the gradient stops are positioned.
bool referencePoint2IsCentroid() const
Returns whether the end point for the gradient is taken from the feature centroid.
void setGradientType(Qgis::GradientType gradientType)
Sets the type of gradient, e.g., linear or radial.
void setReferencePoint2(QPointF referencePoint)
Sets the end point of gradient fill, in the range [0,0] - [1,1].
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
void setCoordinateMode(Qgis::SymbolCoordinateReference coordinateMode)
Sets the coordinate mode for gradient, which controls how the gradient stops are positioned.
Qgis::SymbolCoordinateReference mCoordinateMode
Qgis::GradientSpread mGradientSpread
void setReferencePoint2IsCentroid(bool isCentroid)
Sets whether the end point for the gradient is taken from the feature centroid.
void setReferencePoint1IsCentroid(bool isCentroid)
Sets whether the starting point for the gradient is taken from the feature centroid.
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
void setGradientColorType(Qgis::GradientColorSource gradientColorType)
Sets the gradient color mode, which controls how gradient color stops are created.
QPointF referencePoint1() const
Returns the starting point of gradient fill, in the range [0,0] - [1,1].
Qgis::GradientSpread gradientSpread() const
Returns the gradient spread mode, which controls how the gradient behaves outside of the predefined s...
QgsColorRamp * colorRamp()
Returns the color ramp used for the gradient fill.
void setReferencePoint1(QPointF referencePoint)
Sets the starting point of gradient fill, in the range [0,0] - [1,1].
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
Qgis::GradientColorSource gradientColorType() const
Returns the gradient color mode, which controls how gradient color stops are created.
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Qgis::GradientColorSource mGradientColorType
Qgis::GradientType gradientType() const
Returns the type of gradient, e.g., linear or radial.
bool referencePoint1IsCentroid() const
Returns whether the starting point for the gradient is taken from the feature centroid.
QPointF referencePoint2() const
Returns the end point of gradient fill, in the range [0,0] - [1,1].
void setColor2(const QColor &color2)
Sets the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoColo...
Base class for polygon renderers generating texture images.
QgsMapUnitScale mStrokeWidthMapUnitScale
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units for the symbol's stroke width.
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the stroke width map unit scale.
Qgis::SymbolCoordinateReference coordinateReference() const
Returns the coordinate reference mode for fill which controls how the top left corner of the image fi...
void setCoordinateReference(Qgis::SymbolCoordinateReference coordinateReference)
Sets the coordinate reference mode for fill which controls how the top left corner of the image fill ...
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the symbol's stroke width.
virtual void applyDataDefinedSettings(QgsSymbolRenderContext &context)
Applies data defined settings prior to generating the fill symbol brush.
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Returns the stroke width map unit scale.
~QgsImageFillSymbolLayer() override
A symbol fill consisting of repeated parallel lines.
Qgis::RenderUnit distanceUnit() const
Returns the units for the distance between lines in the fill pattern.
void setLineWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line width.
double lineWidth() const
Returns the width of the line subsymbol used to render the parallel lines in the fill.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line distance.
Qgis::LineClipMode clipMode() const
Returns the line clipping mode, which defines how lines are clipped at the edges of shapes.
double lineAngle() const
Returns the angle for the parallel lines used to fill the symbol.
Qgis::RenderUnit lineWidthUnit() const
Returns the units for the line's width.
void setLineWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the line's width.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the pattern's line offset.
void setDistance(double d)
Sets the distance between lines in the fill pattern.
const QgsMapUnitScale & lineWidthMapUnitScale() const
Returns the map unit scale for the pattern's line width.
void setClipMode(Qgis::LineClipMode mode)
Sets the line clipping mode, which defines how lines are clipped at the edges of shapes.
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the line pattern's offset.
const QgsMapUnitScale & distanceMapUnitScale() const
Returns the map unit scale for the pattern's line distance.
double offset() const
Returns the offset distance for lines within the fill, which is the distance to offset the parallel l...
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the distance between lines in the fill pattern.
double distance() const
Returns the distance between lines in the fill pattern.
void setOffset(double offset)
Sets the offset distance for lines within the fill, which is the distance to offset the parallel line...
Qgis::RenderUnit offsetUnit() const
Returns the units for the line pattern's offset.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line offset.
~QgsLinePatternFillSymbolLayer() override
A line symbol type, for rendering LineString and MultiLineString geometries.
Struct for storing maximum and minimum scales for measurements in map units.
A marker symbol type, for rendering Point and MultiPoint geometries.
Resolves relative paths into absolute paths and vice versa.
A fill symbol layer which fills polygon shapes with repeating marker symbols.
const QgsMapUnitScale & distanceYMapUnitScale() const
Returns the map unit scale for the vertical distance between points in the pattern.
void setDisplacementX(double d)
Sets the horizontal displacement for odd numbered rows in the pattern.
void setOffsetXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal offset between rows in the pattern.
Qgis::RenderUnit offsetYUnit() const
Returns the units for the vertical offset for rows in the pattern.
const QgsMapUnitScale & randomDeviationXMapUnitScale() const
Returns the unit scale for the horizontal random deviation of points in the pattern.
void setOffsetX(double offset)
Sets the horizontal offset values for points in the pattern.
double maximumRandomDeviationY() const
Returns the maximum vertical random deviation of points in the pattern.
void setDistanceYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical distance between points in the pattern.
Qgis::RenderUnit randomDeviationYUnit() const
Returns the units for the vertical random deviation of points in the pattern.
double displacementY() const
Returns the vertical displacement for odd numbered columns in the pattern.
void setDisplacementYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical displacement between rows in the pattern.
void setRandomDeviationYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical random deviation of points in the pattern.
const QgsMapUnitScale & distanceXMapUnitScale() const
Returns the map unit scale for the horizontal distance between points in the pattern.
void setRandomDeviationYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical random deviation of points in the pattern.
unsigned long seed() const
Returns the random number seed to use when randomly shifting points, or 0 if a truly random sequence ...
Qgis::MarkerClipMode clipMode() const
Returns the marker clipping mode, which defines how markers are clipped at the edges of shapes.
void setRandomDeviationXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal random deviation of points in the pattern.
Qgis::RenderUnit distanceXUnit() const
Returns the units for the horizontal distance between points in the pattern.
double offsetY() const
Returns the vertical offset values for points in the pattern.
void setDisplacementY(double d)
Sets the vertical displacement for odd numbered columns in the pattern.
void setMaximumRandomDeviationX(double deviation)
Sets the maximum horizontal random deviation of points in the pattern.
void setDisplacementYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical displacement between odd numbered columns in the pattern.
void setSeed(unsigned long seed)
Sets the random number seed to use when randomly shifting points, or 0 if a truly random sequence wil...
void setOffsetY(double offset)
Sets the vertical offset values for points in the pattern.
const QgsMapUnitScale & offsetXMapUnitScale() const
Returns the unit scale for the horizontal offset for rows in the pattern.
const QgsMapUnitScale & displacementXMapUnitScale() const
Returns the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
const QgsMapUnitScale & offsetYMapUnitScale() const
Returns the unit scale for the vertical offset between rows in the pattern.
void setDistanceXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal distance between points in the pattern.
Qgis::RenderUnit distanceYUnit() const
Returns the units for the vertical distance between points in the pattern.
const QgsMapUnitScale & displacementYMapUnitScale() const
Returns the map unit scale for the vertical displacement between odd numbered columns in the pattern.
void setDistanceXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal distance between points in the pattern.
void setOffsetYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical offset for rows in the pattern.
const QgsMapUnitScale & randomDeviationYMapUnitScale() const
Returns the unit scale for the vertical random deviation of points in the pattern.
Qgis::RenderUnit offsetXUnit() const
Returns the units for the horizontal offset for rows in the pattern.
void setOffsetYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical offset for rows in the pattern.
void setDistanceY(double d)
Sets the vertical distance between rendered markers in the fill.
Qgis::RenderUnit displacementXUnit() const
Returns the units for the horizontal displacement between rows in the pattern.
Qgis::RenderUnit randomDeviationXUnit() const
Returns the units for the horizontal random deviation of points in the pattern.
void setDisplacementXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal displacement between rows in the pattern.
void setDistanceX(double d)
Sets the horizontal distance between rendered markers in the fill.
double offsetX() const
Returns the horizontal offset values for points in the pattern.
void setRandomDeviationXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal random deviation of points in the pattern.
double maximumRandomDeviationX() const
Returns the maximum horizontal random deviation of points in the pattern.
std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol
void setDisplacementXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
void setMaximumRandomDeviationY(double deviation)
Sets the maximum vertical random deviation of points in the pattern.
void setDistanceYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical distance between points in the pattern.
Qgis::RenderUnit displacementYUnit() const
Returns the units for the vertical displacement between rows in the pattern.
double displacementX() const
Returns the horizontal displacement for odd numbered rows in the pattern.
void setOffsetXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal offset for rows in the pattern.
~QgsPointPatternFillSymbolLayer() override
double distanceY() const
Returns the vertical distance between rendered markers in the fill.
void setClipMode(Qgis::MarkerClipMode mode)
Sets the marker clipping mode, which defines how markers are clipped at the edges of shapes.
A fill symbol layer which places markers at random locations within polygons.
~QgsRandomMarkerFillSymbolLayer() override
void setDensityAreaUnitScale(const QgsMapUnitScale &scale)
Sets the map scale for the density area.
Qgis::RenderUnit densityAreaUnit() const
Returns the units for the density area.
const QgsMapUnitScale & densityAreaUnitScale() const
Returns the map scale for the density area.
A class for filling symbols with a repeated raster image.
const QgsMapUnitScale & sizeMapUnitScale() const
Returns the map unit scale for the image's width and height.
double width() const
Returns the width used for scaling the image used in the fill.
Q_DECL_DEPRECATED void setWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the image's width.
void setOffsetUnit(const Qgis::RenderUnit unit)
Sets the units for the fill's offset.
void setHeight(double height)
Sets the height for scaling the image.
Q_DECL_DEPRECATED const QgsMapUnitScale & widthMapUnitScale() const
Returns the map unit scale for the image's width.
Qgis::SymbolCoordinateReference coordinateMode() const
Coordinate mode for fill.
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
double opacity() const
Returns the opacity for the raster image used in the fill.
void setSizeUnit(Qgis::RenderUnit unit)
Sets the unit for the image's width and height.
~QgsRasterFillSymbolLayer() override
Q_DECL_DEPRECATED Qgis::RenderUnit widthUnit() const
Returns the units for the image's width.
Qgis::RenderUnit sizeUnit() const
Returns the units for the image's width and height.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
QString imageFilePath() const
The path to the raster image used for the fill.
Q_DECL_DEPRECATED void setWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the image's width.
double height() const
Returns the height used for scaling the image used in the fill.
void setWidth(double width)
Sets the width for scaling the image used in the fill.
void setSizeMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the image's width and height.
QPointF offset() const
Returns the offset for the fill.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
void setOffset(QPointF offset)
Sets the offset for the fill.
Contains information about the context of a rendering operation.
A class for filling symbols with a repeated SVG file.
void setSvgStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's stroke.
QColor svgStrokeColor() const
Returns the stroke color used for rendering the SVG content.
void setSvgStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the stroke width.
Qgis::RenderUnit patternWidthUnit() const
Returns the units for the width of the SVG images in the pattern.
void setSvgFillColor(const QColor &c)
Sets the fill color used for rendering the SVG content.
const QgsMapUnitScale & svgStrokeWidthMapUnitScale() const
Returns the map unit scale for the pattern's stroke.
double svgStrokeWidth() const
Returns the stroke width used for rendering the SVG content.
QMap< QString, QgsProperty > parameters() const
Returns the dynamic SVG parameters.
void setSvgStrokeWidth(double w)
Sets the stroke width used for rendering the SVG content.
void setPatternWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the width of the SVG images in the pattern.
QColor svgFillColor() const
Returns the fill color used for rendering the SVG content.
void setSvgStrokeColor(const QColor &c)
Sets the stroke color used for rendering the SVG content.
const QgsMapUnitScale & patternWidthMapUnitScale() const
Returns the map unit scale for the pattern's width.
Qgis::RenderUnit svgStrokeWidthUnit() const
Returns the units for the stroke width.
void setPatternWidth(double width)
Sets the width to render the SVG content as within the fill (i.e.
double patternWidth() const
Returns the width of the rendered SVG content within the fill (i.e.
~QgsSVGFillSymbolLayer() override
void setPatternWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's width.
~QgsShapeburstFillSymbolLayer() override
Qgis::RenderUnit offsetUnit() const
Returns the units used for the offset of the shapeburst fill.
QgsColorRamp * colorRamp()
Returns the color ramp used for the shapeburst fill.
int blurRadius() const
Returns the blur radius, which controls the amount of blurring applied to the fill.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the units used for the offset for the shapeburst fill.
void setOffset(QPointF offset)
Sets the offset for the shapeburst fill.
void setUseWholeShape(bool useWholeShape)
Sets whether the shapeburst fill should be drawn using the entire shape.
QColor color2() const
Returns the color used for the endpoint of the shapeburst fill.
void setIgnoreRings(bool ignoreRings)
Sets whether the shapeburst fill should ignore polygon rings when calculating the buffered shading.
void setMaxDistance(double maxDistance)
Sets the maximum distance to shape inside of the shape from the polygon's boundary.
void setColor2(const QColor &color2)
Sets the color for the endpoint of the shapeburst fill.
QgsShapeburstFillSymbolLayer & operator=(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.
Qgis::RenderUnit distanceUnit() const
Returns the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
QPointF offset() const
Returns the offset for the shapeburst fill.
bool useWholeShape() const
Returns whether the shapeburst fill is set to cover the entire shape.
bool ignoreRings() const
Returns whether the shapeburst fill is set to ignore polygon interior rings.
double maxDistance() const
Returns the maximum distance from the shape's boundary which is shaded.
const QgsMapUnitScale & offsetMapUnitScale() const
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
void setColorType(Qgis::GradientColorSource colorType)
Sets the color mode to use for the shapeburst fill.
Qgis::GradientColorSource colorType() const
Returns the color mode used for the shapeburst fill.
QgsShapeburstFillSymbolLayer(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.
const QgsMapUnitScale & distanceMapUnitScale() const
Renders polygons using a single fill and stroke color.
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the width of the fill's stroke.
Qt::PenJoinStyle penJoinStyle() const
QColor strokeColor() const override
Returns the stroke color for the symbol layer.
void setBrushStyle(Qt::BrushStyle style)
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
const QgsMapUnitScale & strokeWidthMapUnitScale() const
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units for the width of the fill's stroke.
~QgsSimpleFillSymbolLayer() override
void setPenJoinStyle(Qt::PenJoinStyle style)
QColor fillColor() const override
Returns the fill color for the symbol layer.
Qt::PenStyle strokeStyle() const
QgsMapUnitScale mOffsetMapUnitScale
void setStrokeWidth(double strokeWidth)
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
void setStrokeStyle(Qt::PenStyle strokeStyle)
QgsMapUnitScale mStrokeWidthMapUnitScale
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
void setFillColor(const QColor &color) override
Sets the fill color for the symbol layer.
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
void setStrokeColor(const QColor &strokeColor) override
Sets the stroke color for the symbol layer.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
virtual QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
virtual QgsMapUnitScale mapUnitScale() const
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
virtual double estimateMaxBleed(const QgsRenderContext &context) const
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.
virtual QVariantMap properties() const =0
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
virtual QString layerType() const =0
Returns a string that represents this layer type.
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.
virtual Qgis::RenderUnit outputUnit() const
Returns the units to use for sizes and widths within the symbol layer.
virtual void setColor(const QColor &color)
Sets the "representative" color for the symbol layer.
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
virtual QColor color() const
Returns the "representative" color of the symbol layer.
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
virtual double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
virtual QColor strokeColor() const
Returns the stroke color for the symbol layer.
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
virtual void setMapUnitScale(const QgsMapUnitScale &scale)
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
virtual void setOutputUnit(Qgis::RenderUnit unit)
Sets the units to use for sizes and widths within the symbol layer.
virtual Qgis::SymbolLayerFlags flags() const
Returns flags which control the symbol layer's behavior.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:231
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QMap< QString, QString > QgsStringMap
Definition qgis.h:6455
#define SIP_DEPRECATED
Definition qgis_sip.h:106
#define FINAL
Definition qgis_sip.h:242
#define SIP_TRANSFER
Definition qgis_sip.h:36
#define SIP_ABSTRACT
Definition qgis_sip.h:213
#define SIP_FACTORY
Definition qgis_sip.h:76
#define DEFAULT_SIMPLEFILL_JOINSTYLE
#define DEFAULT_SIMPLEFILL_COLOR
#define DEFAULT_SIMPLEFILL_STYLE
#define DEFAULT_SIMPLEFILL_BORDERSTYLE
#define DEFAULT_SIMPLEFILL_BORDERCOLOR
#define DEFAULT_SIMPLEFILL_BORDERWIDTH