api/3.28/qgslinesymbollayer_8h_source.html

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

 qgslinesymbollayer.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 QGSLINESYMBOLLAYER_H

#define QGSLINESYMBOLLAYER_H


#include "qgis_core.h"

#include "qgis.h"

#include "qgssymbollayer.h"


#include <QPen>

#include <QVector>


class QgsExpression;

class QgsMarkerSymbol;

class QgsLineSymbol;

class QgsPathResolver;

class QgsColorRamp;


#define DEFAULT_SIMPLELINE_COLOR     QColor(35,35,35)

#define DEFAULT_SIMPLELINE_WIDTH     DEFAULT_LINE_WIDTH

#define DEFAULT_SIMPLELINE_PENSTYLE  Qt::SolidLine

#define DEFAULT_SIMPLELINE_JOINSTYLE Qt::BevelJoin

#define DEFAULT_SIMPLELINE_CAPSTYLE  Qt::SquareCap


class CORE_EXPORT QgsSimpleLineSymbolLayer : public QgsLineSymbolLayer

{

  public:


    QgsSimpleLineSymbolLayer( const QColor &color = DEFAULT_SIMPLELINE_COLOR,

                              double width = DEFAULT_SIMPLELINE_WIDTH,

                              Qt::PenStyle penStyle = DEFAULT_SIMPLELINE_PENSTYLE );


    ~QgsSimpleLineSymbolLayer() override;


    // static stuff


    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 renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;

    //overridden so that clip path can be set when using draw inside polygon option

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

    QVariantMap properties() const override;

    QgsSimpleLineSymbolLayer *clone() const override SIP_FACTORY;

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

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

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

    QgsUnitTypes::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;

    QVector<qreal> dxfCustomDashPattern( QgsUnitTypes::RenderUnit &unit ) const override;

    Qt::PenStyle dxfPenStyle() const override;

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

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

    QColor dxfColor( QgsSymbolRenderContext &context ) const override;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


    Qt::PenStyle penStyle() const { return mPenStyle; }


    void setPenStyle( Qt::PenStyle style ) { mPenStyle = style; }


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


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


    Qt::PenCapStyle penCapStyle() const { return mPenCapStyle; }


    void setPenCapStyle( Qt::PenCapStyle style ) { mPenCapStyle = style; }


    bool useCustomDashPattern() const { return mUseCustomDashPattern; }


    void setUseCustomDashPattern( bool b ) { mUseCustomDashPattern = b; }


    void setCustomDashPatternUnit( QgsUnitTypes::RenderUnit unit ) { mCustomDashPatternUnit = unit; }


    QgsUnitTypes::RenderUnit customDashPatternUnit() const { return mCustomDashPatternUnit; }


    const QgsMapUnitScale &customDashPatternMapUnitScale() const { return mCustomDashPatternMapUnitScale; }


    void setCustomDashPatternMapUnitScale( const QgsMapUnitScale &scale ) { mCustomDashPatternMapUnitScale = scale; }


    QVector<qreal> customDashVector() const { return mCustomDashVector; }


    void setCustomDashVector( const QVector<qreal> &vector ) { mCustomDashVector = vector; }


    double dashPatternOffset() const { return mDashPatternOffset; }


    void setDashPatternOffset( double offset ) { mDashPatternOffset = offset; }


    void setDashPatternOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mDashPatternOffsetUnit = unit; }


    QgsUnitTypes::RenderUnit dashPatternOffsetUnit() const { return mDashPatternOffsetUnit; }


    const QgsMapUnitScale &dashPatternOffsetMapUnitScale() const { return mDashPatternOffsetMapUnitScale; }


    void setDashPatternOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mDashPatternOffsetMapUnitScale = scale; }


    double trimDistanceStart() const { return mTrimDistanceStart; }


    void setTrimDistanceStart( double distance ) { mTrimDistanceStart = distance; }


    void setTrimDistanceStartUnit( QgsUnitTypes::RenderUnit unit ) { mTrimDistanceStartUnit = unit; }


    QgsUnitTypes::RenderUnit trimDistanceStartUnit() const { return mTrimDistanceStartUnit; }


    const QgsMapUnitScale &trimDistanceStartMapUnitScale() const { return mTrimDistanceStartMapUnitScale; }


    void setTrimDistanceStartMapUnitScale( const QgsMapUnitScale &scale ) { mTrimDistanceStartMapUnitScale = scale; }


    double trimDistanceEnd() const { return mTrimDistanceEnd; }


    void setTrimDistanceEnd( double distance ) { mTrimDistanceEnd = distance; }


    void setTrimDistanceEndUnit( QgsUnitTypes::RenderUnit unit ) { mTrimDistanceEndUnit = unit; }


    QgsUnitTypes::RenderUnit trimDistanceEndUnit() const { return mTrimDistanceEndUnit; }


    const QgsMapUnitScale &trimDistanceEndMapUnitScale() const { return mTrimDistanceEndMapUnitScale; }


    void setTrimDistanceEndMapUnitScale( const QgsMapUnitScale &scale ) { mTrimDistanceEndMapUnitScale = scale; }


    bool drawInsidePolygon() const { return mDrawInsidePolygon; }


    void setDrawInsidePolygon( bool drawInsidePolygon ) { mDrawInsidePolygon = drawInsidePolygon; }


    bool alignDashPattern() const;


    void setAlignDashPattern( bool enabled );


    bool tweakDashPatternOnCorners() const;


    void setTweakDashPatternOnCorners( bool enabled );


  private:


    Qt::PenStyle mPenStyle = Qt::SolidLine;

    Qt::PenJoinStyle mPenJoinStyle = DEFAULT_SIMPLELINE_JOINSTYLE;

    Qt::PenCapStyle mPenCapStyle = DEFAULT_SIMPLELINE_CAPSTYLE;

    QPen mPen;

    QPen mSelPen;


    bool mUseCustomDashPattern = false;

    QgsUnitTypes::RenderUnit mCustomDashPatternUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mCustomDashPatternMapUnitScale;


    double mDashPatternOffset = 0;

    QgsUnitTypes::RenderUnit mDashPatternOffsetUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mDashPatternOffsetMapUnitScale;


    double mTrimDistanceStart = 0;

    QgsUnitTypes::RenderUnit mTrimDistanceStartUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mTrimDistanceStartMapUnitScale;


    double mTrimDistanceEnd = 0;

    QgsUnitTypes::RenderUnit mTrimDistanceEndUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mTrimDistanceEndMapUnitScale;


    QVector<qreal> mCustomDashVector;


    bool mAlignDashPattern = false;

    bool mPatternCartographicTweakOnSharpCorners = false;


    bool mDrawInsidePolygon = false;


    //helper functions for data defined symbology

    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QPen &pen, QPen &selPen, double &offset );

    void drawPathWithDashPatternTweaks( QPainter *painter, const QPolygonF &points, QPen pen ) const;

};


#define DEFAULT_MARKERLINE_ROTATE     true

#define DEFAULT_MARKERLINE_INTERVAL   3


class CORE_EXPORT QgsTemplatedLineSymbolLayerBase : public QgsLineSymbolLayer

{

  public:


    QgsTemplatedLineSymbolLayerBase( bool rotateSymbol = true,

                                     double interval = 3 );


    ~QgsTemplatedLineSymbolLayerBase() override;


    bool rotateSymbols() const { return mRotateSymbols; }


    void setRotateSymbols( bool rotate ) { mRotateSymbols = rotate; }


    double interval() const { return mInterval; }


    void setInterval( double interval ) { mInterval = interval; }


    void setIntervalUnit( QgsUnitTypes::RenderUnit unit ) { mIntervalUnit = unit; }


    QgsUnitTypes::RenderUnit intervalUnit() const { return mIntervalUnit; }


    void setIntervalMapUnitScale( const QgsMapUnitScale &scale ) { mIntervalMapUnitScale = scale; }


    const QgsMapUnitScale &intervalMapUnitScale() const { return mIntervalMapUnitScale; }


    Q_DECL_DEPRECATED Qgis::MarkerLinePlacement placement() const SIP_DEPRECATED;


    Q_DECL_DEPRECATED void setPlacement( Qgis::MarkerLinePlacement placement ) SIP_DEPRECATED;


    Qgis::MarkerLinePlacements placements() const { return mPlacements; }


    void setPlacements( Qgis::MarkerLinePlacements placements ) { mPlacements = placements; }


    bool placeOnEveryPart() const { return mPlaceOnEveryPart; }


    void setPlaceOnEveryPart( bool respect ) { mPlaceOnEveryPart = respect; }


    double offsetAlongLine() const { return mOffsetAlongLine; }


    void setOffsetAlongLine( double offsetAlongLine ) { mOffsetAlongLine = offsetAlongLine; }


    QgsUnitTypes::RenderUnit offsetAlongLineUnit() const { return mOffsetAlongLineUnit; }


    void setOffsetAlongLineUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetAlongLineUnit = unit; }


    const QgsMapUnitScale &offsetAlongLineMapUnitScale() const { return mOffsetAlongLineMapUnitScale; }


    void setOffsetAlongLineMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetAlongLineMapUnitScale = scale; }


    double averageAngleLength() const { return mAverageAngleLength; }


    void setAverageAngleLength( double length ) { mAverageAngleLength = length; }


    void setAverageAngleUnit( QgsUnitTypes::RenderUnit unit ) { mAverageAngleLengthUnit = unit; }


    QgsUnitTypes::RenderUnit averageAngleUnit() const { return mAverageAngleLengthUnit; }


    void setAverageAngleMapUnitScale( const QgsMapUnitScale &scale ) { mAverageAngleLengthMapUnitScale = scale; }


    const QgsMapUnitScale &averageAngleMapUnitScale() const { return mAverageAngleLengthMapUnitScale; }


    void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;

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

    QgsUnitTypes::RenderUnit outputUnit() const FINAL;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

    void setMapUnitScale( const QgsMapUnitScale &scale ) FINAL;

    QgsMapUnitScale mapUnitScale() const FINAL;

    QVariantMap properties() const override;

    bool canCauseArtifactsBetweenAdjacentTiles() const override;


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

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


  protected:


    virtual void setSymbolLineAngle( double angle ) = 0;


    virtual double symbolAngle() const = 0;


    virtual void setSymbolAngle( double angle ) = 0;


    virtual void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false ) = 0;


    void copyTemplateSymbolProperties( QgsTemplatedLineSymbolLayerBase *destLayer ) const;


    static void setCommonProperties( QgsTemplatedLineSymbolLayerBase *destLayer, const QVariantMap &properties );


  private:


    void renderPolylineInterval( const QPolygonF &points, QgsSymbolRenderContext &context, double averageAngleOver );

    void renderPolylineVertex( const QPolygonF &points, QgsSymbolRenderContext &context, Qgis::MarkerLinePlacement placement = Qgis::MarkerLinePlacement::Vertex );

    void renderPolylineCentral( const QPolygonF &points, QgsSymbolRenderContext &context, double averageAngleOver );

    double markerAngle( const QPolygonF &points, bool isRing, int vertex );


    void renderOffsetVertexAlongLine( const QPolygonF &points, int vertex, double distance, QgsSymbolRenderContext &context,

                                      Qgis::MarkerLinePlacement placement );


    static void collectOffsetPoints( const QVector< QPointF> &points,

                                     QVector< QPointF> &dest, double intervalPainterUnits, double initialOffset, double initialLag = 0,

                                     int numberPointsRequired = -1 );


    bool mRotateSymbols = true;

    double mInterval = 3;

    QgsUnitTypes::RenderUnit mIntervalUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mIntervalMapUnitScale;

    Qgis::MarkerLinePlacements mPlacements = Qgis::MarkerLinePlacement::Interval;

    double mOffsetAlongLine = 0; //distance to offset along line before marker is drawn

    QgsUnitTypes::RenderUnit mOffsetAlongLineUnit = QgsUnitTypes::RenderMillimeters; //unit for offset along line

    QgsMapUnitScale mOffsetAlongLineMapUnitScale;

    double mAverageAngleLength = 4;

    QgsUnitTypes::RenderUnit mAverageAngleLengthUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mAverageAngleLengthMapUnitScale;

    bool mPlaceOnEveryPart = true;


    bool mRenderingFeature = false;

    bool mHasRenderedFirstPart = false;

    QPointF mFinalVertex;

    bool mCurrentFeatureIsSelected = false;

    double mFeatureSymbolOpacity = 1;


    friend class TestQgsMarkerLineSymbol;


};


class CORE_EXPORT QgsMarkerLineSymbolLayer : public QgsTemplatedLineSymbolLayerBase

{

  public:


    QgsMarkerLineSymbolLayer( bool rotateMarker = DEFAULT_MARKERLINE_ROTATE,

                              double interval = DEFAULT_MARKERLINE_INTERVAL );


    ~QgsMarkerLineSymbolLayer() 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;

    QgsMarkerLineSymbolLayer *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 setWidth( double width ) override;

    double width() const override;

    double width( const QgsRenderContext &context ) const override;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

    bool usesMapUnits() const override;

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

    bool hasDataDefinedProperties() const override;

    void setDataDefinedProperty( QgsSymbolLayer::Property key, const QgsProperty &property ) override;


    Q_DECL_DEPRECATED bool rotateMarker() const SIP_DEPRECATED { return rotateSymbols(); }


    Q_DECL_DEPRECATED void setRotateMarker( bool rotate ) SIP_DEPRECATED { setRotateSymbols( rotate ); }


    void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;


  protected:


    std::unique_ptr< QgsMarkerSymbol > mMarker;


    void setSymbolLineAngle( double angle ) override;

    double symbolAngle() const override;

    void setSymbolAngle( double angle ) override;

    void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false ) override;


  private:


#ifdef SIP_RUN

    QgsMarkerLineSymbolLayer( const QgsMarkerLineSymbolLayer &other );

#endif


};


class CORE_EXPORT QgsHashedLineSymbolLayer : public QgsTemplatedLineSymbolLayerBase

{

  public:


    QgsHashedLineSymbolLayer( bool rotateSymbol = true,

                              double interval = 3 );


    ~QgsHashedLineSymbolLayer() override;


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


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsHashedLineSymbolLayer *clone() const override SIP_FACTORY;

    void setColor( const QColor &color ) override;

    QColor color() const override;

    QgsSymbol *subSymbol() override;

    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;

    void setWidth( double width ) override;

    double width() const override;

    double width( const QgsRenderContext &context ) const override;

    double estimateMaxBleed( const QgsRenderContext &context ) const override;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

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

    bool hasDataDefinedProperties() const override;

    void setDataDefinedProperty( QgsSymbolLayer::Property key, const QgsProperty &property ) override;

    bool usesMapUnits() const override;


    double hashAngle() const;


    void setHashAngle( double angle );


    double hashLength() const { return mHashLength; }


    void setHashLength( double length ) { mHashLength = length; }


    void setHashLengthUnit( QgsUnitTypes::RenderUnit unit ) { mHashLengthUnit = unit; }


    QgsUnitTypes::RenderUnit hashLengthUnit() const { return mHashLengthUnit; }


    void setHashLengthMapUnitScale( const QgsMapUnitScale &scale ) { mHashLengthMapUnitScale = scale; }


    const QgsMapUnitScale &hashLengthMapUnitScale() const { return mHashLengthMapUnitScale; }


    void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;


  protected:


    void setSymbolLineAngle( double angle ) override;

    double symbolAngle() const override;

    void setSymbolAngle( double angle ) override;

    void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false ) override;


  private:

#ifdef SIP_RUN

    QgsHashedLineSymbolLayer( const QgsHashedLineSymbolLayer &other );

#endif


    std::unique_ptr< QgsLineSymbol > mHashSymbol;


    double mSymbolLineAngle = 0;

    double mSymbolAngle = 0;


    double mHashAngle = 0;

    double mHashLength = 3;

    QgsUnitTypes::RenderUnit mHashLengthUnit = QgsUnitTypes::RenderMillimeters;

    QgsMapUnitScale mHashLengthMapUnitScale;


};


class CORE_EXPORT QgsAbstractBrushedLineSymbolLayer : public QgsLineSymbolLayer

{

  public:


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


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


    Qt::PenCapStyle penCapStyle() const { return mPenCapStyle; }


    void setPenCapStyle( Qt::PenCapStyle style ) { mPenCapStyle = style; }


  protected:


    void renderPolylineUsingBrush( const QPolygonF &points, QgsSymbolRenderContext &context, const QBrush &brush,

                                   double patternThickness, double patternLength );


    Qt::PenJoinStyle mPenJoinStyle = Qt::PenJoinStyle::RoundJoin;

    Qt::PenCapStyle mPenCapStyle = Qt::PenCapStyle::RoundCap;


  private:

    void renderLine( const QPolygonF &points, QgsSymbolRenderContext &context, const double lineThickness, const double patternLength, const QBrush &sourceBrush );

};


class CORE_EXPORT QgsRasterLineSymbolLayer : public QgsAbstractBrushedLineSymbolLayer

{

  public:


    QgsRasterLineSymbolLayer( const QString &path = QString() );

    virtual ~QgsRasterLineSymbolLayer();


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


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


    QString path() const { return mPath; }


    void setPath( const QString &path );


    double opacity() const { return mOpacity; }


    void setOpacity( double opacity ) { mOpacity = opacity; }


    QString layerType() const override;

    void startRender( QgsSymbolRenderContext &context ) override;

    void stopRender( QgsSymbolRenderContext &context ) override;

    void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsRasterLineSymbolLayer *clone() const override SIP_FACTORY;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

    QgsUnitTypes::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;

    QColor color() const override;


  protected:

    QString mPath;

    double mOpacity = 1.0;

    QImage mLineImage;


};


class CORE_EXPORT QgsLineburstSymbolLayer : public QgsAbstractBrushedLineSymbolLayer

{

  public:


    QgsLineburstSymbolLayer( const QColor &color = DEFAULT_SIMPLELINE_COLOR,

                             const QColor &color2 = Qt::white );

    ~QgsLineburstSymbolLayer() 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 renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;

    QVariantMap properties() const override;

    QgsLineburstSymbolLayer *clone() const override SIP_FACTORY;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;

    QgsUnitTypes::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;

    QColor color() const override;


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


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


    QgsColorRamp *colorRamp();


    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );


    QColor color2() const { return mColor2; }


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


  protected:

    Qgis::GradientColorSource mGradientColorType = Qgis::GradientColorSource::SimpleTwoColor;

    QColor mColor2;

    std::unique_ptr< QgsColorRamp > mGradientRamp;


};


#endif


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

Qgis::MarkerLinePlacement
MarkerLinePlacement
Defines how/where the symbols should be placed on a line.
Definition: qgis.h:1581

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

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

QgsAbstractBrushedLineSymbolLayer
Base class for line symbol layer types which draws line sections using a QBrush.
Definition: qgslinesymbollayer.h:1145

QgsAbstractBrushedLineSymbolLayer::setPenJoinStyle
void setPenJoinStyle(Qt::PenJoinStyle style)
Sets the pen join style used to render the line (e.g.
Definition: qgslinesymbollayer.h:1160

QgsAbstractBrushedLineSymbolLayer::penCapStyle
Qt::PenCapStyle penCapStyle() const
Returns the pen cap style used to render the line (e.g.
Definition: qgslinesymbollayer.h:1167

QgsAbstractBrushedLineSymbolLayer::penJoinStyle
Qt::PenJoinStyle penJoinStyle() const
Returns the pen join style used to render the line (e.g.
Definition: qgslinesymbollayer.h:1153

QgsAbstractBrushedLineSymbolLayer::setPenCapStyle
void setPenCapStyle(Qt::PenCapStyle style)
Sets the pen cap style used to render the line (e.g.
Definition: qgslinesymbollayer.h:1174

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

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

QgsExpression
Class for parsing and evaluation of expressions (formerly called "search strings").
Definition: qgsexpression.h:103

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

QgsHashedLineSymbolLayer
Line symbol layer type which draws repeating line sections along a line feature.
Definition: qgslinesymbollayer.h:1010

QgsHashedLineSymbolLayer::setHashLength
void setHashLength(double length)
Sets the length of hash symbols.
Definition: qgslinesymbollayer.h:1077

QgsHashedLineSymbolLayer::hashLengthMapUnitScale
const QgsMapUnitScale & hashLengthMapUnitScale() const
Returns the map unit scale for the hash length.
Definition: qgslinesymbollayer.h:1107

QgsHashedLineSymbolLayer::hashLengthUnit
QgsUnitTypes::RenderUnit hashLengthUnit() const
Returns the units for the length of hash symbols.
Definition: qgslinesymbollayer.h:1091

QgsHashedLineSymbolLayer::setHashLengthUnit
void setHashLengthUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the length of hash symbols.
Definition: qgslinesymbollayer.h:1084

QgsHashedLineSymbolLayer::setHashLengthMapUnitScale
void setHashLengthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the hash length.
Definition: qgslinesymbollayer.h:1099

QgsHashedLineSymbolLayer::~QgsHashedLineSymbolLayer
~QgsHashedLineSymbolLayer() override

QgsLineSymbolLayer
Definition: qgssymbollayer.h:1025

QgsLineSymbolLayer::renderPolygonStroke
virtual void renderPolygonStroke(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Renders the line symbol layer along the outline of polygon, using the given render context.
Definition: qgssymbollayer.cpp:762

QgsLineSymbolLayer::renderPolyline
virtual void renderPolyline(const QPolygonF &points, QgsSymbolRenderContext &context)=0
Renders the line symbol layer along the line joining points, using the given render context.

QgsLineSymbolLayer::outputUnit
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
Definition: qgssymbollayer.cpp:727

QgsLineSymbolLayer::offset
double offset() const
Returns the line's offset.
Definition: qgssymbollayer.h:1112

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

QgsLineburstSymbolLayer
Line symbol layer type which draws a gradient pattern perpendicularly along a line.
Definition: qgslinesymbollayer.h:1284

QgsLineburstSymbolLayer::mGradientRamp
std::unique_ptr< QgsColorRamp > mGradientRamp
Definition: qgslinesymbollayer.h:1363

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

QgsLineburstSymbolLayer::~QgsLineburstSymbolLayer
~QgsLineburstSymbolLayer() override

QgsLineburstSymbolLayer::setGradientColorType
void setGradientColorType(Qgis::GradientColorSource gradientColorType)
Sets the gradient color mode, which controls how gradient color stops are created.
Definition: qgslinesymbollayer.h:1327

QgsLineburstSymbolLayer::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: qgslinesymbollayer.h:1358

QgsLineburstSymbolLayer::mColor2
QColor mColor2
Definition: qgslinesymbollayer.h:1362

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

QgsMarkerLineSymbolLayer
Line symbol layer type which draws repeating marker symbols along a line feature.
Definition: qgslinesymbollayer.h:916

QgsMarkerLineSymbolLayer::mMarker
std::unique_ptr< QgsMarkerSymbol > mMarker
Definition: qgslinesymbollayer.h:984

QgsMarkerLineSymbolLayer::~QgsMarkerLineSymbolLayer
~QgsMarkerLineSymbolLayer() override

QgsMarkerLineSymbolLayer::setRotateMarker
Q_DECL_DEPRECATED void setRotateMarker(bool rotate)
Shall the marker be rotated.
Definition: qgslinesymbollayer.h:978

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

QgsProperty
A store for object properties.
Definition: qgsproperty.h:230

QgsRasterLineSymbolLayer
Line symbol layer type which draws line sections using a raster image file.
Definition: qgslinesymbollayer.h:1202

QgsRasterLineSymbolLayer::opacity
double opacity() const
Returns the line opacity.
Definition: qgslinesymbollayer.h:1241

QgsRasterLineSymbolLayer::setOpacity
void setOpacity(double opacity)
Set the line opacity.
Definition: qgslinesymbollayer.h:1248

QgsRasterLineSymbolLayer::~QgsRasterLineSymbolLayer
virtual ~QgsRasterLineSymbolLayer()

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

QgsSimpleLineSymbolLayer
A simple line symbol layer, which renders lines using a line in a variety of styles (e....
Definition: qgslinesymbollayer.h:44

QgsSimpleLineSymbolLayer::dashPatternOffsetUnit
QgsUnitTypes::RenderUnit dashPatternOffsetUnit() const
Returns the units for the dash pattern offset.
Definition: qgslinesymbollayer.h:253

QgsSimpleLineSymbolLayer::setDrawInsidePolygon
void setDrawInsidePolygon(bool drawInsidePolygon)
Sets whether the line should only be drawn inside polygons, and any portion of the line which falls o...
Definition: qgslinesymbollayer.h:453

QgsSimpleLineSymbolLayer::customDashPatternMapUnitScale
const QgsMapUnitScale & customDashPatternMapUnitScale() const
Returns the map unit scale for lengths used in the custom dash pattern.
Definition: qgslinesymbollayer.h:169

QgsSimpleLineSymbolLayer::setPenCapStyle
void setPenCapStyle(Qt::PenCapStyle style)
Sets the pen cap style used to render the line (e.g.
Definition: qgslinesymbollayer.h:135

QgsSimpleLineSymbolLayer::trimDistanceEndMapUnitScale
const QgsMapUnitScale & trimDistanceEndMapUnitScale() const
Returns the map unit scale for the trim distance for the end of the line.
Definition: qgslinesymbollayer.h:419

QgsSimpleLineSymbolLayer::customDashVector
QVector< qreal > customDashVector() const
Returns the custom dash vector, which is the pattern of alternating drawn/skipped lengths used while ...
Definition: qgslinesymbollayer.h:189

QgsSimpleLineSymbolLayer::penJoinStyle
Qt::PenJoinStyle penJoinStyle() const
Returns the pen join style used to render the line (e.g.
Definition: qgslinesymbollayer.h:114

QgsSimpleLineSymbolLayer::setDashPatternOffsetUnit
void setDashPatternOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the dash pattern offset.
Definition: qgslinesymbollayer.h:242

QgsSimpleLineSymbolLayer::trimDistanceStartUnit
QgsUnitTypes::RenderUnit trimDistanceStartUnit() const
Returns the unit for the trim distance for the start of the line.
Definition: qgslinesymbollayer.h:329

QgsSimpleLineSymbolLayer::trimDistanceStartMapUnitScale
const QgsMapUnitScale & trimDistanceStartMapUnitScale() const
Returns the map unit scale for the trim distance for the start of the line.
Definition: qgslinesymbollayer.h:341

QgsSimpleLineSymbolLayer::setCustomDashPatternMapUnitScale
void setCustomDashPatternMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for lengths used in the custom dash pattern.
Definition: qgslinesymbollayer.h:175

QgsSimpleLineSymbolLayer::customDashPatternUnit
QgsUnitTypes::RenderUnit customDashPatternUnit() const
Returns the units for lengths used in the custom dash pattern.
Definition: qgslinesymbollayer.h:163

QgsSimpleLineSymbolLayer::setTrimDistanceEndMapUnitScale
void setTrimDistanceEndMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the trim distance for the end of the line.
Definition: qgslinesymbollayer.h:431

QgsSimpleLineSymbolLayer::setTrimDistanceEnd
void setTrimDistanceEnd(double distance)
Sets the trim distance for the end of the line, which dictates a length from the end of the line at w...
Definition: qgslinesymbollayer.h:383

QgsSimpleLineSymbolLayer::setCustomDashPatternUnit
void setCustomDashPatternUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for lengths used in the custom dash pattern.
Definition: qgslinesymbollayer.h:157

QgsSimpleLineSymbolLayer::trimDistanceStart
double trimDistanceStart() const
Returns the trim distance for the start of the line, which dictates a length from the start of the li...
Definition: qgslinesymbollayer.h:290

QgsSimpleLineSymbolLayer::~QgsSimpleLineSymbolLayer
~QgsSimpleLineSymbolLayer() override

QgsSimpleLineSymbolLayer::setUseCustomDashPattern
void setUseCustomDashPattern(bool b)
Sets whether the line uses a custom dash pattern.
Definition: qgslinesymbollayer.h:151

QgsSimpleLineSymbolLayer::trimDistanceEnd
double trimDistanceEnd() const
Returns the trim distance for the end of the line, which dictates a length from the end of the line a...
Definition: qgslinesymbollayer.h:368

QgsSimpleLineSymbolLayer::dashPatternOffsetMapUnitScale
const QgsMapUnitScale & dashPatternOffsetMapUnitScale() const
Returns the map unit scale for the dash pattern offset value.
Definition: qgslinesymbollayer.h:264

QgsSimpleLineSymbolLayer::setCustomDashVector
void setCustomDashVector(const QVector< qreal > &vector)
Sets the custom dash vector, which is the pattern of alternating drawn/skipped lengths used while ren...
Definition: qgslinesymbollayer.h:203

QgsSimpleLineSymbolLayer::useCustomDashPattern
bool useCustomDashPattern() const
Returns true if the line uses a custom dash pattern.
Definition: qgslinesymbollayer.h:143

QgsSimpleLineSymbolLayer::trimDistanceEndUnit
QgsUnitTypes::RenderUnit trimDistanceEndUnit() const
Returns the unit for the trim distance for the end of the line.
Definition: qgslinesymbollayer.h:407

QgsSimpleLineSymbolLayer::setDashPatternOffset
void setDashPatternOffset(double offset)
Sets the dash pattern offset, which dictates how far along the dash pattern the pattern should start ...
Definition: qgslinesymbollayer.h:231

QgsSimpleLineSymbolLayer::setDashPatternOffsetMapUnitScale
void setDashPatternOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the dash pattern offset.
Definition: qgslinesymbollayer.h:275

QgsSimpleLineSymbolLayer::setPenStyle
void setPenStyle(Qt::PenStyle style)
Sets the pen style used to render the line (e.g.
Definition: qgslinesymbollayer.h:107

QgsSimpleLineSymbolLayer::setPenJoinStyle
void setPenJoinStyle(Qt::PenJoinStyle style)
Sets the pen join style used to render the line (e.g.
Definition: qgslinesymbollayer.h:121

QgsSimpleLineSymbolLayer::dashPatternOffset
double dashPatternOffset() const
Returns the dash pattern offset, which dictates how far along the dash pattern the pattern should sta...
Definition: qgslinesymbollayer.h:217

QgsSimpleLineSymbolLayer::setTrimDistanceStartUnit
void setTrimDistanceStartUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the trim distance for the start of the line.
Definition: qgslinesymbollayer.h:317

QgsSimpleLineSymbolLayer::setTrimDistanceStartMapUnitScale
void setTrimDistanceStartMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the trim distance for the start of the line.
Definition: qgslinesymbollayer.h:353

QgsSimpleLineSymbolLayer::setTrimDistanceEndUnit
void setTrimDistanceEndUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the trim distance for the end of the line.
Definition: qgslinesymbollayer.h:395

QgsSimpleLineSymbolLayer::penCapStyle
Qt::PenCapStyle penCapStyle() const
Returns the pen cap style used to render the line (e.g.
Definition: qgslinesymbollayer.h:128

QgsSimpleLineSymbolLayer::drawInsidePolygon
bool drawInsidePolygon() const
Returns true if the line should only be drawn inside polygons, and any portion of the line which fall...
Definition: qgslinesymbollayer.h:442

QgsSimpleLineSymbolLayer::setTrimDistanceStart
void setTrimDistanceStart(double distance)
Sets the trim distance for the start of the line, which dictates a length from the start of the line ...
Definition: qgslinesymbollayer.h:305

QgsSymbolLayer
Definition: qgssymbollayer.h:55

QgsSymbolLayer::Property
Property
Data definable properties.
Definition: qgssymbollayer.h:143

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

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::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.

QgsSymbolRenderContext
Definition: qgssymbolrendercontext.h:36

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

QgsTemplatedLineSymbolLayerBase
Base class for templated line symbols, e.g.
Definition: qgslinesymbollayer.h:553

QgsTemplatedLineSymbolLayerBase::rotateSymbols
bool rotateSymbols() const
Returns true if the repeating symbols be rotated to match their line segment orientation.
Definition: qgslinesymbollayer.h:572

QgsTemplatedLineSymbolLayerBase::placeOnEveryPart
bool placeOnEveryPart() const
Returns true if the placement applies for every part of multi-part feature geometries.
Definition: qgslinesymbollayer.h:668

QgsTemplatedLineSymbolLayerBase::averageAngleLength
double averageAngleLength() const
Returns the length of line over which the line's direction is averaged when calculating individual sy...
Definition: qgslinesymbollayer.h:749

QgsTemplatedLineSymbolLayerBase::setRotateSymbols
void setRotateSymbols(bool rotate)
Sets whether the repeating symbols should be rotated to match their line segment orientation.
Definition: qgslinesymbollayer.h:578

QgsTemplatedLineSymbolLayerBase::averageAngleMapUnitScale
const QgsMapUnitScale & averageAngleMapUnitScale() const
Returns the map unit scale for the length over which the line's direction is averaged when calculatin...
Definition: qgslinesymbollayer.h:801

QgsTemplatedLineSymbolLayerBase::interval
double interval() const
Returns the interval between individual symbols.
Definition: qgslinesymbollayer.h:585

QgsTemplatedLineSymbolLayerBase::setAverageAngleMapUnitScale
void setAverageAngleMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the length over which the line's direction is averaged when calculating i...
Definition: qgslinesymbollayer.h:791

QgsTemplatedLineSymbolLayerBase::intervalMapUnitScale
const QgsMapUnitScale & intervalMapUnitScale() const
Returns the map unit scale for the interval between symbols.
Definition: qgslinesymbollayer.h:624

QgsTemplatedLineSymbolLayerBase::offsetAlongLine
double offsetAlongLine() const
Returns the offset along the line for the symbol placement.
Definition: qgslinesymbollayer.h:696

QgsTemplatedLineSymbolLayerBase::~QgsTemplatedLineSymbolLayerBase
~QgsTemplatedLineSymbolLayerBase() override

QgsTemplatedLineSymbolLayerBase::setOffsetAlongLine
void setOffsetAlongLine(double offsetAlongLine)
Sets the the offset along the line for the symbol placement.
Definition: qgslinesymbollayer.h:709

QgsTemplatedLineSymbolLayerBase::setOffsetAlongLineUnit
void setOffsetAlongLineUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit used for calculating the offset along line for symbols.
Definition: qgslinesymbollayer.h:725

QgsTemplatedLineSymbolLayerBase::setInterval
void setInterval(double interval)
Sets the interval between individual symbols.
Definition: qgslinesymbollayer.h:593

QgsTemplatedLineSymbolLayerBase::averageAngleUnit
QgsUnitTypes::RenderUnit averageAngleUnit() const
Returns the unit for the length over which the line's direction is averaged when calculating individu...
Definition: qgslinesymbollayer.h:781

QgsTemplatedLineSymbolLayerBase::setPlaceOnEveryPart
void setPlaceOnEveryPart(bool respect)
Sets whether the placement applies for every part of multi-part feature geometries.
Definition: qgslinesymbollayer.h:684

QgsTemplatedLineSymbolLayerBase::offsetAlongLineUnit
QgsUnitTypes::RenderUnit offsetAlongLineUnit() const
Returns the unit used for calculating the offset along line for symbols.
Definition: qgslinesymbollayer.h:717

QgsTemplatedLineSymbolLayerBase::setPlacements
void setPlacements(Qgis::MarkerLinePlacements placements)
Sets the placement of the symbols.
Definition: qgslinesymbollayer.h:652

QgsTemplatedLineSymbolLayerBase::intervalUnit
QgsUnitTypes::RenderUnit intervalUnit() const
Returns the units for the interval between symbols.
Definition: qgslinesymbollayer.h:608

QgsTemplatedLineSymbolLayerBase::setAverageAngleUnit
void setAverageAngleUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the length over which the line's direction is averaged when calculating individual ...
Definition: qgslinesymbollayer.h:771

QgsTemplatedLineSymbolLayerBase::setIntervalUnit
void setIntervalUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the interval between symbols.
Definition: qgslinesymbollayer.h:601

QgsTemplatedLineSymbolLayerBase::offsetAlongLineMapUnitScale
const QgsMapUnitScale & offsetAlongLineMapUnitScale() const
Returns the map unit scale used for calculating the offset in map units along line for symbols.
Definition: qgslinesymbollayer.h:731

QgsTemplatedLineSymbolLayerBase::setIntervalMapUnitScale
void setIntervalMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the interval between symbols.
Definition: qgslinesymbollayer.h:616

QgsTemplatedLineSymbolLayerBase::setOffsetAlongLineMapUnitScale
void setOffsetAlongLineMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale used for calculating the offset in map units along line for symbols.
Definition: qgslinesymbollayer.h:737

QgsTemplatedLineSymbolLayerBase::setAverageAngleLength
void setAverageAngleLength(double length)
Sets the length of line over which the line's direction is averaged when calculating individual symbo...
Definition: qgslinesymbollayer.h:761

QgsUnitTypes
Helper functions for various unit types.
Definition: qgsunittypes.h:39

QgsUnitTypes::RenderUnit
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168

QgsUnitTypes::RenderMillimeters
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169

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

qgis.h

SIP_DEPRECATED
#define SIP_DEPRECATED
Definition: qgis_sip.h:106

FINAL
#define FINAL
Definition: qgis_sip.h:237

SIP_TRANSFER
#define SIP_TRANSFER
Definition: qgis_sip.h:36

SIP_FACTORY
#define SIP_FACTORY
Definition: qgis_sip.h:76

DEFAULT_MARKERLINE_INTERVAL
#define DEFAULT_MARKERLINE_INTERVAL
Definition: qgslinesymbollayer.h:541

DEFAULT_SIMPLELINE_WIDTH
#define DEFAULT_SIMPLELINE_WIDTH
Definition: qgslinesymbollayer.h:33

DEFAULT_MARKERLINE_ROTATE
#define DEFAULT_MARKERLINE_ROTATE
Definition: qgslinesymbollayer.h:540

DEFAULT_SIMPLELINE_PENSTYLE
#define DEFAULT_SIMPLELINE_PENSTYLE
Definition: qgslinesymbollayer.h:34

DEFAULT_SIMPLELINE_JOINSTYLE
#define DEFAULT_SIMPLELINE_JOINSTYLE
Definition: qgslinesymbollayer.h:35

DEFAULT_SIMPLELINE_COLOR
#define DEFAULT_SIMPLELINE_COLOR
Definition: qgslinesymbollayer.h:32

DEFAULT_SIMPLELINE_CAPSTYLE
#define DEFAULT_SIMPLELINE_CAPSTYLE
Definition: qgslinesymbollayer.h:36

qgssymbollayer.h