api/3.30/qgsfillsymbollayer_8h_source.html

/***************************************************************************

 qgsfillsymbollayer.h

 ---------------------

 begin                : November 2009

 copyright            : (C) 2009 by Martin Dobias

 email                : wonder dot sk at gmail dot com

 ***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/


#ifndef QGSFILLSYMBOLLAYER_H

#define QGSFILLSYMBOLLAYER_H


#include "qgis_core.h"

#include "qgis.h"

#include "qgssymbollayer.h"


#define DEFAULT_SIMPLEFILL_COLOR        QColor(0,0,255)

#define DEFAULT_SIMPLEFILL_STYLE        Qt::SolidPattern

#define DEFAULT_SIMPLEFILL_BORDERCOLOR  QColor( 35, 35, 35 )

#define DEFAULT_SIMPLEFILL_BORDERSTYLE  Qt::SolidLine

#define DEFAULT_SIMPLEFILL_BORDERWIDTH  DEFAULT_LINE_WIDTH

#define DEFAULT_SIMPLEFILL_JOINSTYLE    Qt::BevelJoin


#define INF 1E20


#include <QPen>

#include <QBrush>


class QgsMarkerSymbol;

class QgsLineSymbol;

class QgsPathResolver;


class CORE_EXPORT QgsSimpleFillSymbolLayer : public QgsFillSymbolLayer

{

  public:

    QgsSimpleFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,

                              Qt::BrushStyle style = DEFAULT_SIMPLEFILL_STYLE,

                              const QColor &strokeColor = DEFAULT_SIMPLEFILL_BORDERCOLOR,

                              Qt::PenStyle strokeStyle = DEFAULT_SIMPLEFILL_BORDERSTYLE,

                              double strokeWidth = DEFAULT_SIMPLEFILL_BORDERWIDTH,

                              Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEFILL_JOINSTYLE

                            );


    ~QgsSimpleFillSymbolLayer() override;


    // static stuff


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;

    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    // implemented from base classes


    QString layerType() const override;


    void startRender( QgsSymbolRenderContext &context ) override;


    void stopRender( QgsSymbolRenderContext &context ) override;


    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;


    QVariantMap properties() const override;


    QgsSimpleFillSymbolLayer *clone() const override SIP_FACTORY;


    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;


    QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;


    Qt::BrushStyle brushStyle() const { return mBrushStyle; }

    void setBrushStyle( Qt::BrushStyle style ) { mBrushStyle = style; }


    QColor strokeColor() const override { return mStrokeColor; }

    void setStrokeColor( const QColor &strokeColor ) override { mStrokeColor = strokeColor; }


    QColor fillColor() const override { return color(); }

    void setFillColor( const QColor &color ) override { setColor( color ); }


    Qt::PenStyle strokeStyle() const { return mStrokeStyle; }

    void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }


    double strokeWidth() const { return mStrokeWidth; }

    void setStrokeWidth( double strokeWidth ) { mStrokeWidth = strokeWidth; }


    Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }

    void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }


    void setOffset( QPointF offset ) { mOffset = offset; }


    QPointF offset() const { return mOffset; }


    void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }


    Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }


    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }

    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }


    void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }


    Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }


    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }


    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;


    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;


    double estimateMaxBleed( const QgsRenderContext &context ) const override;


    double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;

    QColor dxfColor( QgsSymbolRenderContext &context ) const override;

    double dxfAngle( QgsSymbolRenderContext &context ) const override;


    Qt::PenStyle dxfPenStyle() const override;

    QColor dxfBrushColor( QgsSymbolRenderContext &context ) const override;

    Qt::BrushStyle dxfBrushStyle() const override;

    QImage toTiledPatternImage( ) const override;


  protected:

    QBrush mBrush;

    QBrush mSelBrush;

    Qt::BrushStyle mBrushStyle;

    QColor mStrokeColor;

    Qt::PenStyle mStrokeStyle;

    double mStrokeWidth;

    Qgis::RenderUnit mStrokeWidthUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mStrokeWidthMapUnitScale;

    Qt::PenJoinStyle mPenJoinStyle;

    QPen mPen;

    QPen mSelPen;


    QPointF mOffset;

    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetMapUnitScale;


  private:

    //helper functions for data defined symbology

    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );


};


class QgsColorRamp;


class CORE_EXPORT QgsGradientFillSymbolLayer : public QgsFillSymbolLayer

{

  public:


    QgsGradientFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,

                                const QColor &color2 = Qt::white,

                                Qgis::GradientColorSource gradientColorType = Qgis::GradientColorSource::SimpleTwoColor,

                                Qgis::GradientType gradientType = Qgis::GradientType::Linear,

                                Qgis::SymbolCoordinateReference coordinateMode = Qgis::SymbolCoordinateReference::Feature,

                                Qgis::GradientSpread gradientSpread = Qgis::GradientSpread::Pad

                              );


    ~QgsGradientFillSymbolLayer() override;


    // static stuff


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    // implemented from base classes


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsGradientFillSymbolLayer *clone() const override SIP_FACTORY;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


    Qgis::GradientType gradientType() const { return mGradientType; }


    void setGradientType( Qgis::GradientType gradientType ) { mGradientType = gradientType; }


    Qgis::GradientColorSource gradientColorType() const { return mGradientColorType; }


    void setGradientColorType( Qgis::GradientColorSource gradientColorType ) { mGradientColorType = gradientColorType; }


    QgsColorRamp *colorRamp() { return mGradientRamp; }


    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );


    QColor color2() const { return mColor2; }


    void setColor2( const QColor &color2 ) { mColor2 = color2; }


    Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }


    void setCoordinateMode( Qgis::SymbolCoordinateReference coordinateMode ) { mCoordinateMode = coordinateMode; }


    Qgis::GradientSpread gradientSpread() const { return mGradientSpread; }


    void setGradientSpread( Qgis::GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }


    void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }


    QPointF referencePoint1() const { return mReferencePoint1; }


    void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }


    bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }


    void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }


    QPointF referencePoint2() const { return mReferencePoint2; }


    void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }


    bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }


    void setOffset( QPointF offset ) { mOffset = offset; }


    QPointF offset() const { return mOffset; }


    void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }


    Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }


    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }


    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;


    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;


  protected:

    QBrush mBrush;

    QBrush mSelBrush;


    Qgis::GradientColorSource mGradientColorType;

    QColor mColor2;

    QgsColorRamp *mGradientRamp = nullptr;

    Qgis::GradientType mGradientType;

    Qgis::SymbolCoordinateReference mCoordinateMode;

    Qgis::GradientSpread mGradientSpread;


    QPointF mReferencePoint1;

    bool mReferencePoint1IsCentroid = false;

    QPointF mReferencePoint2;

    bool mReferencePoint2IsCentroid = false;


    QPointF mOffset;

    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetMapUnitScale;


  private:


    //helper functions for data defined symbology

    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );


    void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,

                        Qgis::GradientColorSource gradientColorType, QgsColorRamp *gradientRamp, Qgis::GradientType gradientType,

                        Qgis::SymbolCoordinateReference coordinateMode, Qgis::GradientSpread gradientSpread,

                        QPointF referencePoint1, QPointF referencePoint2, double angle );


    QPointF rotateReferencePoint( QPointF refPoint, double angle );

};


class CORE_EXPORT QgsShapeburstFillSymbolLayer : public QgsFillSymbolLayer

{

  public:


    QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,

                                  Qgis::GradientColorSource colorType = Qgis::GradientColorSource::SimpleTwoColor,

                                  int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );


    ~QgsShapeburstFillSymbolLayer() override;


    QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other ) = delete;


    QgsShapeburstFillSymbolLayer &operator=( const QgsShapeburstFillSymbolLayer &other ) = delete;


    // static stuff


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    // implemented from base classes


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


    void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }


    int blurRadius() const { return mBlurRadius; }


    void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }


    bool useWholeShape() const { return mUseWholeShape; }


    void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }


    double maxDistance() const { return mMaxDistance; }


    void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }


    Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }


    void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }

    const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }


    void setColorType( Qgis::GradientColorSource colorType ) { mColorType = colorType; }


    Qgis::GradientColorSource colorType() const { return mColorType; }


    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );


    QgsColorRamp *colorRamp() { return mGradientRamp.get(); }


    void setColor2( const QColor &color2 ) { mColor2 = color2; }


    QColor color2() const { return mColor2; }


    void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }


    bool ignoreRings() const { return mIgnoreRings; }


    void setOffset( QPointF offset ) { mOffset = offset; }


    QPointF offset() const { return mOffset; }


    void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }


    Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }


    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }

    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;


    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;


  private:

    QBrush mBrush;

    QBrush mSelBrush;


    int mBlurRadius = 0;


    bool mUseWholeShape = true;

    double mMaxDistance = 5.0;

    Qgis::RenderUnit mDistanceUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDistanceMapUnitScale;


    Qgis::GradientColorSource mColorType = Qgis::GradientColorSource::SimpleTwoColor;

    QColor mColor2;


    bool mIgnoreRings = false;


    QPointF mOffset;

    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetMapUnitScale;


    std::unique_ptr< QgsColorRamp > mGradientRamp;


    //helper functions for data defined symbology

    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,

                                    double &maxDistance, bool &ignoreRings );


    /* distance transform of a 1d function using squared distance */

    void distanceTransform1d( double *f, int n, int *v, double *z, double *d );

    /* distance transform of 2d function using squared distance */

    void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );

    /* distance transform of a binary QImage */

    double *distanceTransform( QImage *im, QgsRenderContext &context );


    /* fills a QImage with values from an array of doubles containing squared distance transform values */

    void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );


#ifdef SIP_RUN

    QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other );

#endif

};


class CORE_EXPORT QgsImageFillSymbolLayer: public QgsFillSymbolLayer SIP_ABSTRACT

{

  public:


    QgsImageFillSymbolLayer();

    ~QgsImageFillSymbolLayer() override;


    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;


    void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }


    Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }


    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }


    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }


    void setCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference ) { mCoordinateReference = coordinateReference; }


    Qgis::SymbolCoordinateReference coordinateReference() const { return mCoordinateReference; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;

    double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;

    Qt::PenStyle dxfPenStyle() const override;

    QVariantMap properties() const override;


  protected:

    QBrush mBrush;

    Qgis::SymbolCoordinateReference mCoordinateReference = Qgis::SymbolCoordinateReference::Feature;

    double mNextAngle = 0.0; // mAngle / data defined angle


    double mStrokeWidth = 0.0;

    Qgis::RenderUnit mStrokeWidthUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mStrokeWidthMapUnitScale;


    virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }


    virtual bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const;


  private:

#ifdef SIP_RUN

    QgsImageFillSymbolLayer( const QgsImageFillSymbolLayer &other );

#endif

};


class CORE_EXPORT QgsRasterFillSymbolLayer: public QgsImageFillSymbolLayer

{

  public:


    QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );


    ~QgsRasterFillSymbolLayer() override;


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );


    // implemented from base classes

    QString layerType() const override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    bool usesMapUnits() const override;

    QColor color() const override;

    void setOutputUnit( Qgis::RenderUnit unit ) override;


    //override QgsImageFillSymbolLayer's support for sub symbols

    QgsSymbol *subSymbol() override { return nullptr; }

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;


    void setImageFilePath( const QString &imagePath );


    QString imageFilePath() const { return mImageFilePath; }


    void setCoordinateMode( Qgis::SymbolCoordinateReference mode );


    Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }


    void setOpacity( double opacity );


    double opacity() const { return mOpacity; }


    void setOffset( QPointF offset ) { mOffset = offset; }


    QPointF offset() const { return mOffset; }


    void setOffsetUnit( const Qgis::RenderUnit unit ) { mOffsetUnit = unit; }


    Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }


    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }


    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }


    void setWidth( const double width ) { mWidth = width; }


    double width() const { return mWidth; }


    void setWidthUnit( const Qgis::RenderUnit unit ) { mWidthUnit = unit; }


    Qgis::RenderUnit widthUnit() const { return mWidthUnit; }


    void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }


    const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }


  protected:


    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;

    bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const override;

  private:


    QString mImageFilePath;

    Qgis::SymbolCoordinateReference mCoordinateMode = Qgis::SymbolCoordinateReference::Feature;

    double mOpacity = 1.0;


    QPointF mOffset;

    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetMapUnitScale;


    double mWidth = 0.0;

    Qgis::RenderUnit mWidthUnit = Qgis::RenderUnit::Pixels;

    QgsMapUnitScale mWidthMapUnitScale;


    void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double opacity,

                       const QgsSymbolRenderContext &context );

};


class CORE_EXPORT QgsSVGFillSymbolLayer: public QgsImageFillSymbolLayer

{

  public:


    QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );


    QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );


    ~QgsSVGFillSymbolLayer() override;


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );


    // implemented from base classes


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;

    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;

    bool usesMapUnits() const override;

    QgsSymbol *subSymbol() override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    QColor dxfColor( QgsSymbolRenderContext &context ) const override;

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;

    bool hasDataDefinedProperties() const override;


    void setSvgFilePath( const QString &svgPath );


    QString svgFilePath() const { return mSvgFilePath; }


    void setPatternWidth( double width ) { mPatternWidth = width;}


    double patternWidth() const { return mPatternWidth; }


    void setSvgFillColor( const QColor &c ) { setColor( c );  }


    QColor svgFillColor() const { return color(); }


    void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }


    QColor svgStrokeColor() const { return mSvgStrokeColor; }


    void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }


    double svgStrokeWidth() const { return mSvgStrokeWidth; }


    void setPatternWidthUnit( Qgis::RenderUnit unit ) { mPatternWidthUnit = unit; }


    Qgis::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }


    void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }


    const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }


    void setSvgStrokeWidthUnit( Qgis::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }


    Qgis::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }


    void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }


    const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;


    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;


    QMap<QString, QgsProperty> parameters() const { return mParameters; }


    void setParameters( const QMap<QString, QgsProperty> &parameters );


  protected:


    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;


  private:


    double mPatternWidth = 20;

    Qgis::RenderUnit mPatternWidthUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mPatternWidthMapUnitScale;

    QMap<QString, QgsProperty> mParameters;


    QByteArray mSvgData;

    QString mSvgFilePath;

    QRectF mSvgViewBox;


    //param(fill), param(stroke), param(stroke-width) are going

    //to be replaced in memory

    QColor mSvgStrokeColor = QColor( 35, 35, 35 );

    double mSvgStrokeWidth = 0.2;

    Qgis::RenderUnit mSvgStrokeWidthUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mSvgStrokeWidthMapUnitScale;


    std::unique_ptr< QgsLineSymbol > mStroke;


    void storeViewBox();

    void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath


    void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, Qgis::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,

                       double svgStrokeWidth, Qgis::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,

                       const QgsStringMap svgParameters );

};


class CORE_EXPORT QgsLinePatternFillSymbolLayer: public QgsImageFillSymbolLayer

{

  public:

    QgsLinePatternFillSymbolLayer();

    ~QgsLinePatternFillSymbolLayer() override;


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;

    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;

    QImage toTiledPatternImage( ) const override;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;


    QString ogrFeatureStyleWidth( double widthScaleFactor ) const;


    void setLineAngle( double a ) { mLineAngle = a; }


    double lineAngle() const { return mLineAngle; }


    void setDistance( double d ) { mDistance = d; }


    double distance() const { return mDistance; }


    void setLineWidth( double w );


    double lineWidth() const { return mLineWidth; }


    void setColor( const QColor &c ) override;

    QColor color() const override;


    void setOffset( double offset ) { mOffset = offset; }


    double offset() const { return mOffset; }


    void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }


    Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }


    void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }


    const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }


    void setLineWidthUnit( Qgis::RenderUnit unit ) { mLineWidthUnit = unit; }


    Qgis::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }


    void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }


    const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }


    void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }


    Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }


    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }


    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }


    Qgis::LineClipMode clipMode() const { return mClipMode; }


    void setClipMode( Qgis::LineClipMode mode ) { mClipMode = mode; }


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;

    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;

    QgsSymbol *subSymbol() override;

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;

    bool hasDataDefinedProperties() const override;

    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;

    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;


  protected:


    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;


  private:

    double mDistance = 5.0;

    Qgis::RenderUnit mDistanceUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDistanceMapUnitScale;

    double mLineWidth = 0;

    Qgis::RenderUnit mLineWidthUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mLineWidthMapUnitScale;

    double mLineAngle = 45.0;

    double mOffset = 0.0;

    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetMapUnitScale;


    bool mRenderUsingLines = false;


#ifdef SIP_RUN

    QgsLinePatternFillSymbolLayer( const QgsLinePatternFillSymbolLayer &other );

#endif


    void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );


    std::unique_ptr< QgsLineSymbol > mFillLineSymbol;


    Qgis::LineClipMode mClipMode = Qgis::LineClipMode::ClipPainterOnly;

};


class CORE_EXPORT QgsPointPatternFillSymbolLayer: public QgsImageFillSymbolLayer

{

  public:

    QgsPointPatternFillSymbolLayer();

    ~QgsPointPatternFillSymbolLayer() override;


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;

    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;

    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;

    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;

    QImage toTiledPatternImage( ) const override;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;

    QgsSymbol *subSymbol() override;

    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;

    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;

    bool hasDataDefinedProperties() const override;

    void setColor( const QColor &c ) override;

    QColor color() const override;


    double distanceX() const { return mDistanceX; }


    void setDistanceX( double d ) { mDistanceX = d; }


    void setDistanceXUnit( Qgis::RenderUnit unit ) { mDistanceXUnit = unit; }


    Qgis::RenderUnit distanceXUnit() const { return mDistanceXUnit; }


    void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }


    const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }


    double distanceY() const { return mDistanceY; }


    void setDistanceY( double d ) { mDistanceY = d; }


    void setDistanceYUnit( Qgis::RenderUnit unit ) { mDistanceYUnit = unit; }


    Qgis::RenderUnit distanceYUnit() const { return mDistanceYUnit; }


    void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }


    const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }


    double displacementX() const { return mDisplacementX; }


    void setDisplacementX( double d ) { mDisplacementX = d; }


    void setDisplacementXUnit( Qgis::RenderUnit unit ) { mDisplacementXUnit = unit; }


    Qgis::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }


    void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }


    const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }


    double displacementY() const { return mDisplacementY; }


    void setDisplacementY( double d ) { mDisplacementY = d; }


    void setDisplacementYUnit( Qgis::RenderUnit unit ) { mDisplacementYUnit = unit; }


    Qgis::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }


    void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }


    const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }


    void setOffsetX( double offset ) { mOffsetX = offset; }


    double offsetX() const { return mOffsetX; }


    void setOffsetY( double offset ) { mOffsetY = offset; }


    double offsetY() const { return mOffsetY; }


    void setOffsetXUnit( Qgis::RenderUnit unit ) { mOffsetXUnit = unit; }


    Qgis::RenderUnit offsetXUnit() const { return mOffsetXUnit; }


    void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }


    const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }


    void setOffsetYUnit( Qgis::RenderUnit unit ) { mOffsetYUnit = unit; }


    Qgis::RenderUnit offsetYUnit() const { return mOffsetYUnit; }


    void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }


    const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }


    Qgis::MarkerClipMode clipMode() const { return mClipMode; }


    void setClipMode( Qgis::MarkerClipMode mode ) { mClipMode = mode; }


    void setMaximumRandomDeviationX( double deviation ) { mRandomDeviationX = deviation; }


    double maximumRandomDeviationX() const { return mRandomDeviationX; }


    void setMaximumRandomDeviationY( double deviation ) { mRandomDeviationY = deviation; }


    double maximumRandomDeviationY() const { return mRandomDeviationY; }


    void setRandomDeviationXUnit( Qgis::RenderUnit unit ) { mRandomDeviationXUnit = unit; }


    Qgis::RenderUnit randomDeviationXUnit() const { return mRandomDeviationXUnit; }


    void setRandomDeviationYUnit( Qgis::RenderUnit unit ) { mRandomDeviationYUnit = unit; }


    Qgis::RenderUnit randomDeviationYUnit() const { return mRandomDeviationYUnit; }


    const QgsMapUnitScale &randomDeviationXMapUnitScale() const { return mRandomDeviationXMapUnitScale; }


    const QgsMapUnitScale &randomDeviationYMapUnitScale() const { return mRandomDeviationYMapUnitScale; }


    void setRandomDeviationXMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationXMapUnitScale = scale; }


    void setRandomDeviationYMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationYMapUnitScale = scale; }


    unsigned long seed() const { return mSeed; }


    void setSeed( unsigned long seed ) { mSeed = seed; }


    double angle() const { return mAngle; }


    void setAngle( double angle ) { mAngle = angle; }


  protected:

    std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;

    double mDistanceX = 15;

    Qgis::RenderUnit mDistanceXUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDistanceXMapUnitScale;

    double mDistanceY = 15;

    Qgis::RenderUnit mDistanceYUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDistanceYMapUnitScale;

    double mDisplacementX = 0;

    Qgis::RenderUnit mDisplacementXUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDisplacementXMapUnitScale;

    double mDisplacementY = 0;

    Qgis::RenderUnit mDisplacementYUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDisplacementYMapUnitScale;

    double mOffsetX = 0;

    Qgis::RenderUnit mOffsetXUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetXMapUnitScale;

    double mOffsetY = 0;

    Qgis::RenderUnit mOffsetYUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mOffsetYMapUnitScale;


    double mRandomDeviationX = 0;

    Qgis::RenderUnit mRandomDeviationXUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mRandomDeviationXMapUnitScale;

    double mRandomDeviationY = 0;

    Qgis::RenderUnit mRandomDeviationYUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mRandomDeviationYMapUnitScale;

    unsigned long mSeed = 0;


    double mAngle = 0;


    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;


  private:

#ifdef SIP_RUN

    QgsPointPatternFillSymbolLayer( const QgsPointPatternFillSymbolLayer &other );

#endif


    void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,

                       double displacementX, double displacementY, double offsetX, double offsetY );


    Qgis::MarkerClipMode mClipMode = Qgis::MarkerClipMode::Shape;


    bool mRenderUsingMarkers = false;

};


class CORE_EXPORT QgsRandomMarkerFillSymbolLayer : public QgsFillSymbolLayer

{

  public:


    QgsRandomMarkerFillSymbolLayer( int pointCount = 10, Qgis::PointCountMethod method = Qgis::PointCountMethod::Absolute, double densityArea = 250.0, unsigned long seed = 0 );


    ~QgsRandomMarkerFillSymbolLayer() override;


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


    void setColor( const QColor &color ) override;

    QColor color() const override;


    QgsSymbol *subSymbol() override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;


    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;


    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;


    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;

    bool hasDataDefinedProperties() const override;


    int pointCount() const;


    void setPointCount( int count );


    unsigned long seed() const;


    void setSeed( unsigned long seed );


    bool clipPoints() const;


    void setClipPoints( bool clipped );


    Qgis::PointCountMethod countMethod() const;


    void setCountMethod( Qgis::PointCountMethod method );


    double densityArea() const;


    void setDensityArea( double area );


    void setDensityAreaUnit( Qgis::RenderUnit unit ) { mDensityAreaUnit = unit; }


    Qgis::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }


    void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }


    const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }


    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;

    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;


  private:

#ifdef SIP_RUN

    QgsRandomMarkerFillSymbolLayer( const QgsRandomMarkerFillSymbolLayer &other );

#endif


    struct Part

    {

      QPolygonF exterior;

      QVector<QPolygonF> rings;

    };


    QVector< Part > mCurrentParts;


    void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );


    std::unique_ptr< QgsMarkerSymbol > mMarker;

    Qgis::PointCountMethod mCountMethod = Qgis::PointCountMethod::Absolute;

    int mPointCount = 10;

    double mDensityArea = 250.0;

    Qgis::RenderUnit mDensityAreaUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale mDensityAreaUnitScale;

    unsigned long mSeed = 0;

    bool mClipPoints = false;


    bool mRenderingFeature = false;

    double mFeatureSymbolOpacity = 1;

};


class CORE_EXPORT QgsCentroidFillSymbolLayer : public QgsFillSymbolLayer

{

  public:

    QgsCentroidFillSymbolLayer();

    ~QgsCentroidFillSymbolLayer() override;


    // static stuff


    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;

    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;


    // implemented from base classes


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;

    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;

    void setColor( const QColor &color ) override;

    QColor color() const override;

    QgsSymbol *subSymbol() override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;

    void setOutputUnit( Qgis::RenderUnit unit ) override;

    Qgis::RenderUnit outputUnit() const override;

    bool usesMapUnits() const override;

    void setMapUnitScale( const QgsMapUnitScale &scale ) override;

    QgsMapUnitScale mapUnitScale() const override;

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;

    bool hasDataDefinedProperties() const override;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


    void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }

    bool pointOnSurface() const { return mPointOnSurface; }


    void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }


    bool pointOnAllParts() const { return mPointOnAllParts; }


    bool clipPoints() const { return mClipPoints; }


    void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }


    bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }


    void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }


    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;

    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;


  protected:


    std::unique_ptr< QgsMarkerSymbol > mMarker;

    bool mPointOnSurface = false;

    bool mPointOnAllParts = true;

    bool mClipPoints = false;

    bool mClipOnCurrentPartOnly = false;


    bool mRenderingFeature = false;

    double mFeatureSymbolOpacity = 1;


  private:

#ifdef SIP_RUN

    QgsCentroidFillSymbolLayer( const QgsCentroidFillSymbolLayer &other );

#endif

    struct Part

    {

      QPolygonF exterior;

      QVector<QPolygonF> rings;

    };


    void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );

    QVector<Part> mCurrentParts;

};


#endif

Qgis
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:55

Qgis::MarkerClipMode
MarkerClipMode
Marker clipping modes.
Definition: qgis.h:2051

Qgis::MarkerClipMode::Shape
@ Shape
Clip to polygon shape.

Qgis::LineClipMode
LineClipMode
Line clipping modes.
Definition: qgis.h:2065

Qgis::LineClipMode::ClipPainterOnly
@ ClipPainterOnly
Applying clipping on the painter only (i.e. line endpoints will coincide with polygon bounding box,...

Qgis::GradientColorSource
GradientColorSource
Gradient color sources.
Definition: qgis.h:1980

Qgis::GradientColorSource::SimpleTwoColor
@ SimpleTwoColor
Simple two color gradient.

Qgis::GradientSpread
GradientSpread
Gradient spread options, which control how gradients are rendered outside of their start and end poin...
Definition: qgis.h:2024

Qgis::GradientSpread::Pad
@ Pad
Pad out gradient using colors at endpoint of gradient.

Qgis::PointCountMethod
PointCountMethod
Methods which define the number of points randomly filling a polygon.
Definition: qgis.h:2039

Qgis::RenderUnit
RenderUnit
Rendering size units.
Definition: qgis.h:3176

Qgis::GradientType
GradientType
Gradient types.
Definition: qgis.h:1994

Qgis::GradientType::Linear
@ Linear
Linear gradient.

Qgis::SymbolCoordinateReference
SymbolCoordinateReference
Symbol coordinate reference modes.
Definition: qgis.h:2009

Qgis::SymbolCoordinateReference::Feature
@ Feature
Relative to feature/shape being rendered.

QgsCentroidFillSymbolLayer
Definition: qgsfillsymbollayer.h:2438

QgsCentroidFillSymbolLayer::setPointOnAllParts
void setPointOnAllParts(bool pointOnAllParts)
Sets whether a point is drawn for all parts or only on the biggest part of multi-part features.
Definition: qgsfillsymbollayer.h:2483

QgsCentroidFillSymbolLayer::pointOnSurface
bool pointOnSurface() const
Definition: qgsfillsymbollayer.h:2476

QgsCentroidFillSymbolLayer::setClipOnCurrentPartOnly
void setClipOnCurrentPartOnly(bool clipOnCurrentPartOnly)
Sets whether point markers should be clipped to the current part boundary only.
Definition: qgsfillsymbollayer.h:2522

QgsCentroidFillSymbolLayer::setClipPoints
void setClipPoints(bool clipPoints)
Sets whether point markers should be clipped to the polygon boundary.
Definition: qgsfillsymbollayer.h:2506

QgsCentroidFillSymbolLayer::mMarker
std::unique_ptr< QgsMarkerSymbol > mMarker
Definition: qgsfillsymbollayer.h:2529

QgsCentroidFillSymbolLayer::pointOnAllParts
bool pointOnAllParts() const
Returns whether a point is drawn for all parts or only on the biggest part of multi-part features.
Definition: qgsfillsymbollayer.h:2490

QgsCentroidFillSymbolLayer::clipPoints
bool clipPoints() const
Returns true if point markers should be clipped to the polygon boundary.
Definition: qgsfillsymbollayer.h:2498

QgsCentroidFillSymbolLayer::~QgsCentroidFillSymbolLayer
~QgsCentroidFillSymbolLayer() override

QgsCentroidFillSymbolLayer::clipOnCurrentPartOnly
bool clipOnCurrentPartOnly() const
Returns true if point markers should be clipped to the current part boundary only.
Definition: qgsfillsymbollayer.h:2514

QgsColorRamp
Abstract base class for color ramps.
Definition: qgscolorramp.h:30

QgsDxfExport
Exports QGIS layers to the DXF format.
Definition: qgsdxfexport.h:65

QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56

QgsFillSymbolLayer
Definition: qgssymbollayer.h:1257

QgsFillSymbolLayer::renderPolygon
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,...

QgsFillSymbolLayer::mAngle
double mAngle
Definition: qgssymbollayer.h:1295

QgsFillSymbolLayer::toTiledPatternImage
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
Definition: qgssymbollayer.cpp:836

QgsFillSymbolLayer::angle
double angle() const
Definition: qgssymbollayer.h:1276

QgsGradientFillSymbolLayer
Definition: qgsfillsymbollayer.h:214

QgsGradientFillSymbolLayer::color2
QColor color2() const
Returns the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoC...
Definition: qgsfillsymbollayer.h:300

QgsGradientFillSymbolLayer::setGradientSpread
void setGradientSpread(Qgis::GradientSpread gradientSpread)
Sets the gradient spread mode, which controls how the gradient behaves outside of the predefined stop...
Definition: qgsfillsymbollayer.h:335

QgsGradientFillSymbolLayer::offsetUnit
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
Definition: qgsfillsymbollayer.h:426

QgsGradientFillSymbolLayer::mOffset
QPointF mOffset
Definition: qgsfillsymbollayer.h:465

QgsGradientFillSymbolLayer::coordinateMode
Qgis::SymbolCoordinateReference coordinateMode() const
Returns the coordinate mode for gradient, which controls how the gradient stops are positioned.
Definition: qgsfillsymbollayer.h:314

QgsGradientFillSymbolLayer::referencePoint2IsCentroid
bool referencePoint2IsCentroid() const
Returns whether the end point for the gradient is taken from the feature centroid.
Definition: qgsfillsymbollayer.h:392

QgsGradientFillSymbolLayer::setGradientType
void setGradientType(Qgis::GradientType gradientType)
Sets the type of gradient, e.g., linear or radial.
Definition: qgsfillsymbollayer.h:262

QgsGradientFillSymbolLayer::setReferencePoint2
void setReferencePoint2(QPointF referencePoint)
Sets the end point of gradient fill, in the range [0,0] - [1,1].
Definition: qgsfillsymbollayer.h:370

QgsGradientFillSymbolLayer::setOffsetUnit
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
Definition: qgsfillsymbollayer.h:419

QgsGradientFillSymbolLayer::setCoordinateMode
void setCoordinateMode(Qgis::SymbolCoordinateReference coordinateMode)
Sets the coordinate mode for gradient, which controls how the gradient stops are positioned.
Definition: qgsfillsymbollayer.h:321

QgsGradientFillSymbolLayer::mCoordinateMode
Qgis::SymbolCoordinateReference mCoordinateMode
Definition: qgsfillsymbollayer.h:457

QgsGradientFillSymbolLayer::mGradientSpread
Qgis::GradientSpread mGradientSpread
Definition: qgsfillsymbollayer.h:458

QgsGradientFillSymbolLayer::setReferencePoint2IsCentroid
void setReferencePoint2IsCentroid(bool isCentroid)
Sets whether the end point for the gradient is taken from the feature centroid.
Definition: qgsfillsymbollayer.h:384

QgsGradientFillSymbolLayer::mGradientType
Qgis::GradientType mGradientType
Definition: qgsfillsymbollayer.h:456

QgsGradientFillSymbolLayer::setReferencePoint1IsCentroid
void setReferencePoint1IsCentroid(bool isCentroid)
Sets whether the starting point for the gradient is taken from the feature centroid.
Definition: qgsfillsymbollayer.h:356

QgsGradientFillSymbolLayer::setOffset
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
Definition: qgsfillsymbollayer.h:402

QgsGradientFillSymbolLayer::setGradientColorType
void setGradientColorType(Qgis::GradientColorSource gradientColorType)
Sets the gradient color mode, which controls how gradient color stops are created.
Definition: qgsfillsymbollayer.h:276

QgsGradientFillSymbolLayer::referencePoint1
QPointF referencePoint1() const
Returns the starting point of gradient fill, in the range [0,0] - [1,1].
Definition: qgsfillsymbollayer.h:349

QgsGradientFillSymbolLayer::mReferencePoint2
QPointF mReferencePoint2
Definition: qgsfillsymbollayer.h:462

QgsGradientFillSymbolLayer::gradientSpread
Qgis::GradientSpread gradientSpread() const
Returns the gradient spread mode, which controls how the gradient behaves outside of the predefined s...
Definition: qgsfillsymbollayer.h:328

QgsGradientFillSymbolLayer::mReferencePoint1
QPointF mReferencePoint1
Definition: qgsfillsymbollayer.h:460

QgsGradientFillSymbolLayer::mBrush
QBrush mBrush
Definition: qgsfillsymbollayer.h:450

QgsGradientFillSymbolLayer::colorRamp
QgsColorRamp * colorRamp()
Returns the color ramp used for the gradient fill.
Definition: qgsfillsymbollayer.h:284

QgsGradientFillSymbolLayer::setReferencePoint1
void setReferencePoint1(QPointF referencePoint)
Sets the starting point of gradient fill, in the range [0,0] - [1,1].
Definition: qgsfillsymbollayer.h:342

QgsGradientFillSymbolLayer::mOffsetMapUnitScale
QgsMapUnitScale mOffsetMapUnitScale
Definition: qgsfillsymbollayer.h:467

QgsGradientFillSymbolLayer::mSelBrush
QBrush mSelBrush
Definition: qgsfillsymbollayer.h:451

QgsGradientFillSymbolLayer::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:433

QgsGradientFillSymbolLayer::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:440

QgsGradientFillSymbolLayer::gradientColorType
Qgis::GradientColorSource gradientColorType() const
Returns the gradient color mode, which controls how gradient color stops are created.
Definition: qgsfillsymbollayer.h:269

QgsGradientFillSymbolLayer::offset
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Definition: qgsfillsymbollayer.h:412

QgsGradientFillSymbolLayer::mGradientColorType
Qgis::GradientColorSource mGradientColorType
Definition: qgsfillsymbollayer.h:453

QgsGradientFillSymbolLayer::mColor2
QColor mColor2
Definition: qgsfillsymbollayer.h:454

QgsGradientFillSymbolLayer::gradientType
Qgis::GradientType gradientType() const
Returns the type of gradient, e.g., linear or radial.
Definition: qgsfillsymbollayer.h:255

QgsGradientFillSymbolLayer::referencePoint1IsCentroid
bool referencePoint1IsCentroid() const
Returns whether the starting point for the gradient is taken from the feature centroid.
Definition: qgsfillsymbollayer.h:363

QgsGradientFillSymbolLayer::referencePoint2
QPointF referencePoint2() const
Returns the end point of gradient fill, in the range [0,0] - [1,1].
Definition: qgsfillsymbollayer.h:377

QgsGradientFillSymbolLayer::setColor2
void setColor2(const QColor &color2)
Sets the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoColo...
Definition: qgsfillsymbollayer.h:307

QgsImageFillSymbolLayer
Base class for polygon renderers generating texture images.
Definition: qgsfillsymbollayer.h:780

QgsImageFillSymbolLayer::mStrokeWidthMapUnitScale
QgsMapUnitScale mStrokeWidthMapUnitScale
Definition: qgsfillsymbollayer.h:854

QgsImageFillSymbolLayer::setStrokeWidthUnit
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units fo the symbol's stroke width.
Definition: qgsfillsymbollayer.h:793

QgsImageFillSymbolLayer::setStrokeWidthMapUnitScale
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the stroke width map unit scale.
Definition: qgsfillsymbollayer.h:808

QgsImageFillSymbolLayer::coordinateReference
Qgis::SymbolCoordinateReference coordinateReference() const
Returns the coordinate reference mode for fill which controls how the top left corner of the image fi...
Definition: qgsfillsymbollayer.h:836

QgsImageFillSymbolLayer::setCoordinateReference
void setCoordinateReference(Qgis::SymbolCoordinateReference coordinateReference)
Sets the coordinate reference mode for fill which controls how the top left corner of the image fill ...
Definition: qgsfillsymbollayer.h:827

QgsImageFillSymbolLayer::strokeWidthUnit
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the symbol's stroke width.
Definition: qgsfillsymbollayer.h:800

QgsImageFillSymbolLayer::applyDataDefinedSettings
virtual void applyDataDefinedSettings(QgsSymbolRenderContext &context)
Applies data defined settings prior to generating the fill symbol brush.
Definition: qgsfillsymbollayer.h:859

QgsImageFillSymbolLayer::mBrush
QBrush mBrush
Definition: qgsfillsymbollayer.h:847

QgsImageFillSymbolLayer::strokeWidthMapUnitScale
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Returns the stroke width map unit scale.
Definition: qgsfillsymbollayer.h:818

QgsImageFillSymbolLayer::~QgsImageFillSymbolLayer
~QgsImageFillSymbolLayer() override

QgsLinePatternFillSymbolLayer
A symbol fill consisting of repeated parallel lines.
Definition: qgsfillsymbollayer.h:1405

QgsLinePatternFillSymbolLayer::distanceUnit
Qgis::RenderUnit distanceUnit() const
Returns the units for the distance between lines in the fill pattern.
Definition: qgsfillsymbollayer.h:1526

QgsLinePatternFillSymbolLayer::setLineWidthMapUnitScale
void setLineWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line width.
Definition: qgsfillsymbollayer.h:1567

QgsLinePatternFillSymbolLayer::lineWidth
double lineWidth() const
Returns the width of the line subsymbol used to render the parallel lines in the fill.
Definition: qgsfillsymbollayer.h:1481

QgsLinePatternFillSymbolLayer::setDistanceMapUnitScale
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line distance.
Definition: qgsfillsymbollayer.h:1535

QgsLinePatternFillSymbolLayer::clipMode
Qgis::LineClipMode clipMode() const
Returns the line clipping mode, which defines how lines are clipped at the edges of shapes.
Definition: qgsfillsymbollayer.h:1616

QgsLinePatternFillSymbolLayer::lineAngle
double lineAngle() const
Returns the angle for the parallel lines used to fill the symbol.
Definition: qgsfillsymbollayer.h:1450

QgsLinePatternFillSymbolLayer::lineWidthUnit
Qgis::RenderUnit lineWidthUnit() const
Returns the units for the line's width.
Definition: qgsfillsymbollayer.h:1558

QgsLinePatternFillSymbolLayer::setLineWidthUnit
void setLineWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the line's width.
Definition: qgsfillsymbollayer.h:1551

QgsLinePatternFillSymbolLayer::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the pattern's line offset.
Definition: qgsfillsymbollayer.h:1608

QgsLinePatternFillSymbolLayer::setDistance
void setDistance(double d)
Sets the distance between lines in the fill pattern.
Definition: qgsfillsymbollayer.h:1458

QgsLinePatternFillSymbolLayer::lineWidthMapUnitScale
const QgsMapUnitScale & lineWidthMapUnitScale() const
Returns the map unit scale for the pattern's line width.
Definition: qgsfillsymbollayer.h:1576

QgsLinePatternFillSymbolLayer::setClipMode
void setClipMode(Qgis::LineClipMode mode)
Sets the line clipping mode, which defines how lines are clipped at the edges of shapes.
Definition: qgsfillsymbollayer.h:1624

QgsLinePatternFillSymbolLayer::setOffsetUnit
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the line pattern's offset.
Definition: qgsfillsymbollayer.h:1583

QgsLinePatternFillSymbolLayer::distanceMapUnitScale
const QgsMapUnitScale & distanceMapUnitScale() const
Returns the map unit scale for the pattern's line distance.
Definition: qgsfillsymbollayer.h:1544

QgsLinePatternFillSymbolLayer::offset
double offset() const
Returns the offset distance for lines within the fill, which is the distance to offset the parallel l...
Definition: qgsfillsymbollayer.h:1510

QgsLinePatternFillSymbolLayer::setDistanceUnit
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the distance between lines in the fill pattern.
Definition: qgsfillsymbollayer.h:1518

QgsLinePatternFillSymbolLayer::distance
double distance() const
Returns the distance between lines in the fill pattern.
Definition: qgsfillsymbollayer.h:1465

QgsLinePatternFillSymbolLayer::setOffset
void setOffset(double offset)
Sets the offset distance for lines within the fill, which is the distance to offset the parallel line...
Definition: qgsfillsymbollayer.h:1497

QgsLinePatternFillSymbolLayer::offsetUnit
Qgis::RenderUnit offsetUnit() const
Returns the units for the line pattern's offset.
Definition: qgsfillsymbollayer.h:1590

QgsLinePatternFillSymbolLayer::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line offset.
Definition: qgsfillsymbollayer.h:1599

QgsLinePatternFillSymbolLayer::~QgsLinePatternFillSymbolLayer
~QgsLinePatternFillSymbolLayer() override

QgsLineSymbol
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30

QgsMapUnitScale
Struct for storing maximum and minimum scales for measurements in map units.
Definition: qgsmapunitscale.h:37

QgsMarkerSymbol
A marker symbol type, for rendering Point and MultiPoint geometries.
Definition: qgsmarkersymbol.h:31

QgsPathResolver
Resolves relative paths into absolute paths and vice versa.
Definition: qgspathresolver.h:32

QgsPointPatternFillSymbolLayer
A fill symbol layer which fills polygon shapes with repeating marker symbols.
Definition: qgsfillsymbollayer.h:1679

QgsPointPatternFillSymbolLayer::distanceYMapUnitScale
const QgsMapUnitScale & distanceYMapUnitScale() const
Returns the map unit scale for the vertical distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1819

QgsPointPatternFillSymbolLayer::setDisplacementX
void setDisplacementX(double d)
Sets the horizontal displacement for odd numbered rows in the pattern.
Definition: qgsfillsymbollayer.h:1841

QgsPointPatternFillSymbolLayer::mDisplacementYMapUnitScale
QgsMapUnitScale mDisplacementYMapUnitScale
Definition: qgsfillsymbollayer.h:2209

QgsPointPatternFillSymbolLayer::setOffsetXUnit
void setOffsetXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal offset between rows in the pattern.
Definition: qgsfillsymbollayer.h:1968

QgsPointPatternFillSymbolLayer::offsetYUnit
Qgis::RenderUnit offsetYUnit() const
Returns the units for the vertical offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:2010

QgsPointPatternFillSymbolLayer::mDisplacementXMapUnitScale
QgsMapUnitScale mDisplacementXMapUnitScale
Definition: qgsfillsymbollayer.h:2206

QgsPointPatternFillSymbolLayer::randomDeviationXMapUnitScale
const QgsMapUnitScale & randomDeviationXMapUnitScale() const
Returns the unit scale for the horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2133

QgsPointPatternFillSymbolLayer::setOffsetX
void setOffsetX(double offset)
Sets the horizontal offset values for points in the pattern.
Definition: qgsfillsymbollayer.h:1934

QgsPointPatternFillSymbolLayer::maximumRandomDeviationY
double maximumRandomDeviationY() const
Returns the maximum vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2087

QgsPointPatternFillSymbolLayer::setDistanceYUnit
void setDistanceYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1796

QgsPointPatternFillSymbolLayer::randomDeviationYUnit
Qgis::RenderUnit randomDeviationYUnit() const
Returns the units for the vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2124

QgsPointPatternFillSymbolLayer::mDistanceYMapUnitScale
QgsMapUnitScale mDistanceYMapUnitScale
Definition: qgsfillsymbollayer.h:2203

QgsPointPatternFillSymbolLayer::displacementY
double displacementY() const
Returns the vertical displacement for odd numbered columns in the pattern.
Definition: qgsfillsymbollayer.h:1883

QgsPointPatternFillSymbolLayer::setDisplacementYUnit
void setDisplacementYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical displacement between rows in the pattern.
Definition: qgsfillsymbollayer.h:1902

QgsPointPatternFillSymbolLayer::setRandomDeviationYUnit
void setRandomDeviationYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2114

QgsPointPatternFillSymbolLayer::distanceXMapUnitScale
const QgsMapUnitScale & distanceXMapUnitScale() const
Returns the map unit scale for the horizontal distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1766

QgsPointPatternFillSymbolLayer::setRandomDeviationYMapUnitScale
void setRandomDeviationYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2160

QgsPointPatternFillSymbolLayer::seed
unsigned long seed() const
Returns the random number seed to use when randomly shifting points, or 0 if a truly random sequence ...
Definition: qgsfillsymbollayer.h:2168

QgsPointPatternFillSymbolLayer::clipMode
Qgis::MarkerClipMode clipMode() const
Returns the marker clipping mode, which defines how markers are clipped at the edges of shapes.
Definition: qgsfillsymbollayer.h:2035

QgsPointPatternFillSymbolLayer::setRandomDeviationXMapUnitScale
void setRandomDeviationXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2151

QgsPointPatternFillSymbolLayer::distanceXUnit
Qgis::RenderUnit distanceXUnit() const
Returns the units for the horizontal distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1750

QgsPointPatternFillSymbolLayer::offsetY
double offsetY() const
Returns the vertical offset values for points in the pattern.
Definition: qgsfillsymbollayer.h:1959

QgsPointPatternFillSymbolLayer::setDisplacementY
void setDisplacementY(double d)
Sets the vertical displacement for odd numbered columns in the pattern.
Definition: qgsfillsymbollayer.h:1894

QgsPointPatternFillSymbolLayer::setMaximumRandomDeviationX
void setMaximumRandomDeviationX(double deviation)
Sets the maximum horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2054

QgsPointPatternFillSymbolLayer::mDistanceXMapUnitScale
QgsMapUnitScale mDistanceXMapUnitScale
Definition: qgsfillsymbollayer.h:2200

QgsPointPatternFillSymbolLayer::setDisplacementYMapUnitScale
void setDisplacementYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical displacement between odd numbered columns in the pattern.
Definition: qgsfillsymbollayer.h:1917

QgsPointPatternFillSymbolLayer::setSeed
void setSeed(unsigned long seed)
Sets the random number seed to use when randomly shifting points, or 0 if a truly random sequence wil...
Definition: qgsfillsymbollayer.h:2178

QgsPointPatternFillSymbolLayer::setOffsetY
void setOffsetY(double offset)
Sets the vertical offset values for points in the pattern.
Definition: qgsfillsymbollayer.h:1951

QgsPointPatternFillSymbolLayer::offsetXMapUnitScale
const QgsMapUnitScale & offsetXMapUnitScale() const
Returns the unit scale for the horizontal offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:1993

QgsPointPatternFillSymbolLayer::displacementXMapUnitScale
const QgsMapUnitScale & displacementXMapUnitScale() const
Returns the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
Definition: qgsfillsymbollayer.h:1872

QgsPointPatternFillSymbolLayer::offsetYMapUnitScale
const QgsMapUnitScale & offsetYMapUnitScale() const
Returns the unit scale for the vertical offset between rows in the pattern.
Definition: qgsfillsymbollayer.h:2027

QgsPointPatternFillSymbolLayer::setDistanceXMapUnitScale
void setDistanceXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1758

QgsPointPatternFillSymbolLayer::mOffsetXMapUnitScale
QgsMapUnitScale mOffsetXMapUnitScale
Definition: qgsfillsymbollayer.h:2212

QgsPointPatternFillSymbolLayer::distanceYUnit
Qgis::RenderUnit distanceYUnit() const
Returns the units for the vertical distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1803

QgsPointPatternFillSymbolLayer::displacementYMapUnitScale
const QgsMapUnitScale & displacementYMapUnitScale() const
Returns the map unit scale for the vertical displacement between odd numbered columns in the pattern.
Definition: qgsfillsymbollayer.h:1925

QgsPointPatternFillSymbolLayer::setDistanceXUnit
void setDistanceXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1743

QgsPointPatternFillSymbolLayer::setOffsetYUnit
void setOffsetYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:2002

QgsPointPatternFillSymbolLayer::randomDeviationYMapUnitScale
const QgsMapUnitScale & randomDeviationYMapUnitScale() const
Returns the unit scale for the vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2142

QgsPointPatternFillSymbolLayer::offsetXUnit
Qgis::RenderUnit offsetXUnit() const
Returns the units for the horizontal offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:1976

QgsPointPatternFillSymbolLayer::mRandomDeviationXMapUnitScale
QgsMapUnitScale mRandomDeviationXMapUnitScale
Definition: qgsfillsymbollayer.h:2219

QgsPointPatternFillSymbolLayer::setOffsetYMapUnitScale
void setOffsetYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:2019

QgsPointPatternFillSymbolLayer::setDistanceY
void setDistanceY(double d)
Sets the vertical distance between rendered markers in the fill.
Definition: qgsfillsymbollayer.h:1788

QgsPointPatternFillSymbolLayer::displacementXUnit
Qgis::RenderUnit displacementXUnit() const
Returns the units for the horizontal displacement between rows in the pattern.
Definition: qgsfillsymbollayer.h:1856

QgsPointPatternFillSymbolLayer::randomDeviationXUnit
Qgis::RenderUnit randomDeviationXUnit() const
Returns the units for the horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2105

QgsPointPatternFillSymbolLayer::setDisplacementXUnit
void setDisplacementXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal displacement between rows in the pattern.
Definition: qgsfillsymbollayer.h:1849

QgsPointPatternFillSymbolLayer::setDistanceX
void setDistanceX(double d)
Sets the horizontal distance between rendered markers in the fill.
Definition: qgsfillsymbollayer.h:1735

QgsPointPatternFillSymbolLayer::offsetX
double offsetX() const
Returns the horizontal offset values for points in the pattern.
Definition: qgsfillsymbollayer.h:1942

QgsPointPatternFillSymbolLayer::setRandomDeviationXUnit
void setRandomDeviationXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2096

QgsPointPatternFillSymbolLayer::maximumRandomDeviationX
double maximumRandomDeviationX() const
Returns the maximum horizontal random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2065

QgsPointPatternFillSymbolLayer::mMarkerSymbol
std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol
Definition: qgsfillsymbollayer.h:2197

QgsPointPatternFillSymbolLayer::setDisplacementXMapUnitScale
void setDisplacementXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
Definition: qgsfillsymbollayer.h:1864

QgsPointPatternFillSymbolLayer::setMaximumRandomDeviationY
void setMaximumRandomDeviationY(double deviation)
Sets the maximum vertical random deviation of points in the pattern.
Definition: qgsfillsymbollayer.h:2076

QgsPointPatternFillSymbolLayer::setDistanceYMapUnitScale
void setDistanceYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical distance between points in the pattern.
Definition: qgsfillsymbollayer.h:1811

QgsPointPatternFillSymbolLayer::mRandomDeviationYMapUnitScale
QgsMapUnitScale mRandomDeviationYMapUnitScale
Definition: qgsfillsymbollayer.h:2222

QgsPointPatternFillSymbolLayer::displacementYUnit
Qgis::RenderUnit displacementYUnit() const
Returns the units for the vertical displacement between rows in the pattern.
Definition: qgsfillsymbollayer.h:1909

QgsPointPatternFillSymbolLayer::displacementX
double displacementX() const
Returns the horizontal displacement for odd numbered rows in the pattern.
Definition: qgsfillsymbollayer.h:1830

QgsPointPatternFillSymbolLayer::setOffsetXMapUnitScale
void setOffsetXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal offset for rows in the pattern.
Definition: qgsfillsymbollayer.h:1985

QgsPointPatternFillSymbolLayer::angle
double angle() const
Returns the rotation angle of the pattern, in degrees clockwise.
Definition: qgsfillsymbollayer.h:2186

QgsPointPatternFillSymbolLayer::~QgsPointPatternFillSymbolLayer
~QgsPointPatternFillSymbolLayer() override

QgsPointPatternFillSymbolLayer::mOffsetYMapUnitScale
QgsMapUnitScale mOffsetYMapUnitScale
Definition: qgsfillsymbollayer.h:2215

QgsPointPatternFillSymbolLayer::setAngle
void setAngle(double angle)
Sets the rotation angle of the pattern, in degrees clockwise.
Definition: qgsfillsymbollayer.h:2194

QgsPointPatternFillSymbolLayer::distanceY
double distanceY() const
Returns the vertical distance between rendered markers in the fill.
Definition: qgsfillsymbollayer.h:1777

QgsPointPatternFillSymbolLayer::setClipMode
void setClipMode(Qgis::MarkerClipMode mode)
Sets the marker clipping mode, which defines how markers are clipped at the edges of shapes.
Definition: qgsfillsymbollayer.h:2043

QgsRandomMarkerFillSymbolLayer
A fill symbol layer which places markers at random locations within polygons.
Definition: qgsfillsymbollayer.h:2251

QgsRandomMarkerFillSymbolLayer::~QgsRandomMarkerFillSymbolLayer
~QgsRandomMarkerFillSymbolLayer() override

QgsRandomMarkerFillSymbolLayer::setDensityAreaUnitScale
void setDensityAreaUnitScale(const QgsMapUnitScale &scale)
Sets the map scale for the density area.
Definition: qgsfillsymbollayer.h:2391

QgsRandomMarkerFillSymbolLayer::densityAreaUnit
Qgis::RenderUnit densityAreaUnit() const
Returns the units for the density area.
Definition: qgsfillsymbollayer.h:2382

QgsRandomMarkerFillSymbolLayer::densityAreaUnitScale
const QgsMapUnitScale & densityAreaUnitScale() const
Returns the map scale for the density area.
Definition: qgsfillsymbollayer.h:2399

QgsRasterFillSymbolLayer
A class for filling symbols with a repeated raster image.
Definition: qgsfillsymbollayer.h:881

QgsRasterFillSymbolLayer::width
double width() const
Returns the width used for scaling the image used in the fill.
Definition: qgsfillsymbollayer.h:1044

QgsRasterFillSymbolLayer::setOffsetUnit
void setOffsetUnit(const Qgis::RenderUnit unit)
Sets the units for the fill's offset.
Definition: qgsfillsymbollayer.h:997

QgsRasterFillSymbolLayer::coordinateMode
Qgis::SymbolCoordinateReference coordinateMode() const
Coordinate mode for fill.
Definition: qgsfillsymbollayer.h:956

QgsRasterFillSymbolLayer::widthMapUnitScale
const QgsMapUnitScale & widthMapUnitScale() const
Returns the map unit scale for the image's width.
Definition: qgsfillsymbollayer.h:1080

QgsRasterFillSymbolLayer::setWidthUnit
void setWidthUnit(const Qgis::RenderUnit unit)
Sets the units for the image's width.
Definition: qgsfillsymbollayer.h:1053

QgsRasterFillSymbolLayer::widthUnit
Qgis::RenderUnit widthUnit() const
Returns the units for the image's width.
Definition: qgsfillsymbollayer.h:1062

QgsRasterFillSymbolLayer::setWidth
void setWidth(const double width)
Sets the width for scaling the image used in the fill.
Definition: qgsfillsymbollayer.h:1034

QgsRasterFillSymbolLayer::offsetUnit
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
Definition: qgsfillsymbollayer.h:1006

QgsRasterFillSymbolLayer::opacity
double opacity() const
Returns the opacity for the raster image used in the fill.
Definition: qgsfillsymbollayer.h:970

QgsRasterFillSymbolLayer::~QgsRasterFillSymbolLayer
~QgsRasterFillSymbolLayer() override

QgsRasterFillSymbolLayer::setWidthMapUnitScale
void setWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the image's width.
Definition: qgsfillsymbollayer.h:1071

QgsRasterFillSymbolLayer::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:1015

QgsRasterFillSymbolLayer::imageFilePath
QString imageFilePath() const
The path to the raster image used for the fill.
Definition: qgsfillsymbollayer.h:940

QgsRasterFillSymbolLayer::offset
QPointF offset() const
Returns the offset for the fill.
Definition: qgsfillsymbollayer.h:988

QgsRasterFillSymbolLayer::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:1024

QgsRasterFillSymbolLayer::setOffset
void setOffset(QPointF offset)
Sets the offset for the fill.
Definition: qgsfillsymbollayer.h:979

QgsRenderContext
Contains information about the context of a rendering operation.
Definition: qgsrendercontext.h:61

QgsSVGFillSymbolLayer
A class for filling symbols with a repeated SVG file.
Definition: qgsfillsymbollayer.h:1111

QgsSVGFillSymbolLayer::setSvgStrokeWidthMapUnitScale
void setSvgStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's stroke.
Definition: qgsfillsymbollayer.h:1331

QgsSVGFillSymbolLayer::svgStrokeColor
QColor svgStrokeColor() const
Returns the stroke color used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1244

QgsSVGFillSymbolLayer::setSvgStrokeWidthUnit
void setSvgStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the stroke width.
Definition: qgsfillsymbollayer.h:1313

QgsSVGFillSymbolLayer::patternWidthUnit
Qgis::RenderUnit patternWidthUnit() const
Returns the units for the width of the SVG images in the pattern.
Definition: qgsfillsymbollayer.h:1286

QgsSVGFillSymbolLayer::setSvgFillColor
void setSvgFillColor(const QColor &c)
Sets the fill color used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1213

QgsSVGFillSymbolLayer::svgStrokeWidthMapUnitScale
const QgsMapUnitScale & svgStrokeWidthMapUnitScale() const
Returns the map unit scale for the pattern's stroke.
Definition: qgsfillsymbollayer.h:1340

QgsSVGFillSymbolLayer::svgStrokeWidth
double svgStrokeWidth() const
Returns the stroke width used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1268

QgsSVGFillSymbolLayer::parameters
QMap< QString, QgsProperty > parameters() const
Returns the dynamic SVG parameters.
Definition: qgsfillsymbollayer.h:1352

QgsSVGFillSymbolLayer::setSvgStrokeWidth
void setSvgStrokeWidth(double w)
Sets the stroke width used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1256

QgsSVGFillSymbolLayer::setPatternWidthUnit
void setPatternWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the width of the SVG images in the pattern.
Definition: qgsfillsymbollayer.h:1277

QgsSVGFillSymbolLayer::svgFillColor
QColor svgFillColor() const
Returns the fill color used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1223

QgsSVGFillSymbolLayer::setSvgStrokeColor
void setSvgStrokeColor(const QColor &c)
Sets the stroke color used for rendering the SVG content.
Definition: qgsfillsymbollayer.h:1234

QgsSVGFillSymbolLayer::patternWidthMapUnitScale
const QgsMapUnitScale & patternWidthMapUnitScale() const
Returns the map unit scale for the pattern's width.
Definition: qgsfillsymbollayer.h:1304

QgsSVGFillSymbolLayer::svgStrokeWidthUnit
Qgis::RenderUnit svgStrokeWidthUnit() const
Returns the units for the stroke width.
Definition: qgsfillsymbollayer.h:1322

QgsSVGFillSymbolLayer::setPatternWidth
void setPatternWidth(double width)
Sets the width to render the SVG content as within the fill (i.e.
Definition: qgsfillsymbollayer.h:1191

QgsSVGFillSymbolLayer::patternWidth
double patternWidth() const
Returns the width of the rendered SVG content within the fill (i.e.
Definition: qgsfillsymbollayer.h:1202

QgsSVGFillSymbolLayer::~QgsSVGFillSymbolLayer
~QgsSVGFillSymbolLayer() override

QgsSVGFillSymbolLayer::setPatternWidthMapUnitScale
void setPatternWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's width.
Definition: qgsfillsymbollayer.h:1295

QgsShapeburstFillSymbolLayer
Definition: qgsfillsymbollayer.h:489

QgsShapeburstFillSymbolLayer::~QgsShapeburstFillSymbolLayer
~QgsShapeburstFillSymbolLayer() override

QgsShapeburstFillSymbolLayer::offsetUnit
Qgis::RenderUnit offsetUnit() const
Returns the units used for the offset of the shapeburst fill.
Definition: qgsfillsymbollayer.h:722

QgsShapeburstFillSymbolLayer::colorRamp
QgsColorRamp * colorRamp()
Returns the color ramp used for the shapeburst fill.
Definition: qgsfillsymbollayer.h:651

QgsShapeburstFillSymbolLayer::blurRadius
int blurRadius() const
Returns the blur radius, which controls the amount of blurring applied to the fill.
Definition: qgsfillsymbollayer.h:547

QgsShapeburstFillSymbolLayer::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Definition: qgsfillsymbollayer.h:724

QgsShapeburstFillSymbolLayer::setOffsetUnit
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the units used for the offset for the shapeburst fill.
Definition: qgsfillsymbollayer.h:713

QgsShapeburstFillSymbolLayer::setOffset
void setOffset(QPointF offset)
Sets the offset for the shapeburst fill.
Definition: qgsfillsymbollayer.h:695

QgsShapeburstFillSymbolLayer::setUseWholeShape
void setUseWholeShape(bool useWholeShape)
Sets whether the shapeburst fill should be drawn using the entire shape.
Definition: qgsfillsymbollayer.h:557

QgsShapeburstFillSymbolLayer::color2
QColor color2() const
Returns the color used for the endpoint of the shapeburst fill.
Definition: qgsfillsymbollayer.h:669

QgsShapeburstFillSymbolLayer::setIgnoreRings
void setIgnoreRings(bool ignoreRings)
Sets whether the shapeburst fill should ignore polygon rings when calculating the buffered shading.
Definition: qgsfillsymbollayer.h:678

QgsShapeburstFillSymbolLayer::setMaxDistance
void setMaxDistance(double maxDistance)
Sets the maximum distance to shape inside of the shape from the polygon's boundary.
Definition: qgsfillsymbollayer.h:576

QgsShapeburstFillSymbolLayer::setColor2
void setColor2(const QColor &color2)
Sets the color for the endpoint of the shapeburst fill.
Definition: qgsfillsymbollayer.h:660

QgsShapeburstFillSymbolLayer::operator=
QgsShapeburstFillSymbolLayer & operator=(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.

QgsShapeburstFillSymbolLayer::distanceUnit
Qgis::RenderUnit distanceUnit() const
Returns the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
Definition: qgsfillsymbollayer.h:604

QgsShapeburstFillSymbolLayer::offset
QPointF offset() const
Returns the offset for the shapeburst fill.
Definition: qgsfillsymbollayer.h:704

QgsShapeburstFillSymbolLayer::useWholeShape
bool useWholeShape() const
Returns whether the shapeburst fill is set to cover the entire shape.
Definition: qgsfillsymbollayer.h:566

QgsShapeburstFillSymbolLayer::ignoreRings
bool ignoreRings() const
Returns whether the shapeburst fill is set to ignore polygon interior rings.
Definition: qgsfillsymbollayer.h:686

QgsShapeburstFillSymbolLayer::maxDistance
double maxDistance() const
Returns the maximum distance from the shape's boundary which is shaded.
Definition: qgsfillsymbollayer.h:586

QgsShapeburstFillSymbolLayer::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Definition: qgsfillsymbollayer.h:725

QgsShapeburstFillSymbolLayer::setDistanceUnit
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
Definition: qgsfillsymbollayer.h:595

QgsShapeburstFillSymbolLayer::setDistanceMapUnitScale
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
Definition: qgsfillsymbollayer.h:606

QgsShapeburstFillSymbolLayer::setColorType
void setColorType(Qgis::GradientColorSource colorType)
Sets the color mode to use for the shapeburst fill.
Definition: qgsfillsymbollayer.h:619

QgsShapeburstFillSymbolLayer::colorType
Qgis::GradientColorSource colorType() const
Returns the color mode used for the shapeburst fill.
Definition: qgsfillsymbollayer.h:631

QgsShapeburstFillSymbolLayer::QgsShapeburstFillSymbolLayer
QgsShapeburstFillSymbolLayer(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.

QgsShapeburstFillSymbolLayer::distanceMapUnitScale
const QgsMapUnitScale & distanceMapUnitScale() const
Definition: qgsfillsymbollayer.h:607

QgsSimpleFillSymbolLayer
Definition: qgsfillsymbollayer.h:44

QgsSimpleFillSymbolLayer::strokeWidthUnit
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the width of the fill's stroke.
Definition: qgsfillsymbollayer.h:133

QgsSimpleFillSymbolLayer::penJoinStyle
Qt::PenJoinStyle penJoinStyle() const
Definition: qgsfillsymbollayer.h:99

QgsSimpleFillSymbolLayer::strokeColor
QColor strokeColor() const override
Returns the stroke color for the symbol layer.
Definition: qgsfillsymbollayer.h:87

QgsSimpleFillSymbolLayer::setBrushStyle
void setBrushStyle(Qt::BrushStyle style)
Definition: qgsfillsymbollayer.h:85

QgsSimpleFillSymbolLayer::setStrokeWidthMapUnitScale
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Definition: qgsfillsymbollayer.h:135

QgsSimpleFillSymbolLayer::strokeWidthMapUnitScale
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Definition: qgsfillsymbollayer.h:136

QgsSimpleFillSymbolLayer::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:157

QgsSimpleFillSymbolLayer::setStrokeWidthUnit
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units for the width of the fill's stroke.
Definition: qgsfillsymbollayer.h:127

QgsSimpleFillSymbolLayer::~QgsSimpleFillSymbolLayer
~QgsSimpleFillSymbolLayer() override

QgsSimpleFillSymbolLayer::setPenJoinStyle
void setPenJoinStyle(Qt::PenJoinStyle style)
Definition: qgsfillsymbollayer.h:100

QgsSimpleFillSymbolLayer::mBrush
QBrush mBrush
Definition: qgsfillsymbollayer.h:185

QgsSimpleFillSymbolLayer::mStrokeColor
QColor mStrokeColor
Definition: qgsfillsymbollayer.h:188

QgsSimpleFillSymbolLayer::fillColor
QColor fillColor() const override
Returns the fill color for the symbol layer.
Definition: qgsfillsymbollayer.h:90

QgsSimpleFillSymbolLayer::strokeStyle
Qt::PenStyle strokeStyle() const
Definition: qgsfillsymbollayer.h:93

QgsSimpleFillSymbolLayer::mOffsetMapUnitScale
QgsMapUnitScale mOffsetMapUnitScale
Definition: qgsfillsymbollayer.h:199

QgsSimpleFillSymbolLayer::strokeWidth
double strokeWidth() const
Definition: qgsfillsymbollayer.h:96

QgsSimpleFillSymbolLayer::setStrokeWidth
void setStrokeWidth(double strokeWidth)
Definition: qgsfillsymbollayer.h:97

QgsSimpleFillSymbolLayer::offset
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Definition: qgsfillsymbollayer.h:120

QgsSimpleFillSymbolLayer::offsetUnit
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
Definition: qgsfillsymbollayer.h:150

QgsSimpleFillSymbolLayer::setStrokeStyle
void setStrokeStyle(Qt::PenStyle strokeStyle)
Definition: qgsfillsymbollayer.h:94

QgsSimpleFillSymbolLayer::mStrokeWidthMapUnitScale
QgsMapUnitScale mStrokeWidthMapUnitScale
Definition: qgsfillsymbollayer.h:192

QgsSimpleFillSymbolLayer::setOffsetUnit
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
Definition: qgsfillsymbollayer.h:143

QgsSimpleFillSymbolLayer::mStrokeWidth
double mStrokeWidth
Definition: qgsfillsymbollayer.h:190

QgsSimpleFillSymbolLayer::mPen
QPen mPen
Definition: qgsfillsymbollayer.h:194

QgsSimpleFillSymbolLayer::setFillColor
void setFillColor(const QColor &color) override
Sets the fill color for the symbol layer.
Definition: qgsfillsymbollayer.h:91

QgsSimpleFillSymbolLayer::mStrokeStyle
Qt::PenStyle mStrokeStyle
Definition: qgsfillsymbollayer.h:189

QgsSimpleFillSymbolLayer::setOffset
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
Definition: qgsfillsymbollayer.h:110

QgsSimpleFillSymbolLayer::setStrokeColor
void setStrokeColor(const QColor &strokeColor) override
Sets the stroke color for the symbol layer.
Definition: qgsfillsymbollayer.h:88

QgsSimpleFillSymbolLayer::mSelPen
QPen mSelPen
Definition: qgsfillsymbollayer.h:195

QgsSimpleFillSymbolLayer::mPenJoinStyle
Qt::PenJoinStyle mPenJoinStyle
Definition: qgsfillsymbollayer.h:193

QgsSimpleFillSymbolLayer::mBrushStyle
Qt::BrushStyle mBrushStyle
Definition: qgsfillsymbollayer.h:187

QgsSimpleFillSymbolLayer::mOffset
QPointF mOffset
Definition: qgsfillsymbollayer.h:197

QgsSimpleFillSymbolLayer::mSelBrush
QBrush mSelBrush
Definition: qgsfillsymbollayer.h:186

QgsSimpleFillSymbolLayer::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
Definition: qgsfillsymbollayer.h:164

QgsSymbolLayer
Definition: qgssymbollayer.h:55

QgsSymbolLayer::clone
virtual QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.

QgsSymbolLayer::setSubSymbol
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
Definition: qgssymbollayer.cpp:147

QgsSymbolLayer::startFeatureRender
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
Definition: qgssymbollayer.cpp:126

QgsSymbolLayer::mapUnitScale
virtual QgsMapUnitScale mapUnitScale() const
Definition: qgssymbollayer.h:505

QgsSymbolLayer::dxfBrushColor
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
Definition: qgssymbollayer.cpp:200

QgsSymbolLayer::usedAttributes
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
Definition: qgssymbollayer.cpp:317

QgsSymbolLayer::estimateMaxBleed
virtual double estimateMaxBleed(const QgsRenderContext &context) const
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
Definition: qgssymbollayer.h:475

QgsSymbolLayer::startRender
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.

QgsSymbolLayer::properties
virtual QVariantMap properties() const =0
Should be reimplemented by subclasses to return a string map that contains the configuration informat...

QgsSymbolLayer::dxfPenStyle
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
Definition: qgssymbollayer.cpp:195

QgsSymbolLayer::dxfColor
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
Definition: qgssymbollayer.cpp:177

QgsSymbolLayer::layerType
virtual QString layerType() const =0
Returns a string that represents this layer type.

QgsSymbolLayer::stopRender
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.

QgsSymbolLayer::outputUnit
virtual Qgis::RenderUnit outputUnit() const
Returns the units to use for sizes and widths within the symbol layer.
Definition: qgssymbollayer.h:495

QgsSymbolLayer::setColor
virtual void setColor(const QColor &color)
Sets the "representative" color for the symbol layer.
Definition: qgssymbollayer.cpp:241

QgsSymbolLayer::subSymbol
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
Definition: qgssymbollayer.cpp:142

QgsSymbolLayer::color
virtual QColor color() const
Returns the "representative" color of the symbol layer.
Definition: qgssymbollayer.cpp:236

QgsSymbolLayer::stopFeatureRender
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
Definition: qgssymbollayer.cpp:134

QgsSymbolLayer::dxfWidth
virtual double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
Definition: qgssymbollayer.cpp:163

QgsSymbolLayer::strokeColor
virtual QColor strokeColor() const
Returns the stroke color for the symbol layer.
Definition: qgssymbollayer.cpp:251

QgsSymbolLayer::dxfAngle
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
Definition: qgssymbollayer.cpp:183

QgsSymbolLayer::canCauseArtifactsBetweenAdjacentTiles
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
Definition: qgssymbollayer.cpp:297

QgsSymbolLayer::setMapUnitScale
virtual void setMapUnitScale(const QgsMapUnitScale &scale)
Definition: qgssymbollayer.h:504

QgsSymbolLayer::usesMapUnits
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
Definition: qgssymbollayer.cpp:302

QgsSymbolLayer::setOutputUnit
virtual void setOutputUnit(Qgis::RenderUnit unit)
Sets the units to use for sizes and widths within the symbol layer.
Definition: qgssymbollayer.h:485

QgsSymbolLayer::dxfBrushStyle
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
Definition: qgssymbollayer.cpp:206

QgsSymbolLayer::hasDataDefinedProperties
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
Definition: qgssymbollayer.cpp:276

QgsSymbolRenderContext
Definition: qgssymbolrendercontext.h:35

QgsSymbol
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:93

MathUtils::angle
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786

c
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
Definition: porting_processing.dox:1

qgis.h

QgsStringMap
QMap< QString, QString > QgsStringMap
Definition: qgis.h:4054

SIP_TRANSFER
#define SIP_TRANSFER
Definition: qgis_sip.h:36

SIP_ABSTRACT
#define SIP_ABSTRACT
Definition: qgis_sip.h:208

SIP_FACTORY
#define SIP_FACTORY
Definition: qgis_sip.h:76

DEFAULT_SIMPLEFILL_JOINSTYLE
#define DEFAULT_SIMPLEFILL_JOINSTYLE
Definition: qgsfillsymbollayer.h:28

DEFAULT_SIMPLEFILL_COLOR
#define DEFAULT_SIMPLEFILL_COLOR
Definition: qgsfillsymbollayer.h:23

DEFAULT_SIMPLEFILL_STYLE
#define DEFAULT_SIMPLEFILL_STYLE
Definition: qgsfillsymbollayer.h:24

DEFAULT_SIMPLEFILL_BORDERSTYLE
#define DEFAULT_SIMPLEFILL_BORDERSTYLE
Definition: qgsfillsymbollayer.h:26

DEFAULT_SIMPLEFILL_BORDERCOLOR
#define DEFAULT_SIMPLEFILL_BORDERCOLOR
Definition: qgsfillsymbollayer.h:25

DEFAULT_SIMPLEFILL_BORDERWIDTH
#define DEFAULT_SIMPLEFILL_BORDERWIDTH
Definition: qgsfillsymbollayer.h:27

qgssymbollayer.h