qgssymbollayer.h

Go to the documentation of this file.

/***************************************************************************
 qgssymbollayer.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 QGSSYMBOLLAYER_H
#define QGSSYMBOLLAYER_H
 
#define DEG2RAD(x)    ((x)*M_PI/180)
#define DEFAULT_SCALE_METHOD              Qgis::ScaleMethod::ScaleDiameter
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgsfields.h"
#include "qgspropertycollection.h"
#include "qgssymbolrendercontext.h"
 
#include <QColor>
#include <QDomDocument>
#include <QDomElement>
#include <QImage>
#include <QMap>
#include <QPainterPath>
#include <QPointF>
#include <QSet>
 
class QPainter;
class QSize;
class QPolygonF;
 
class QgsDxfExport;
class QgsExpression;
class QgsRenderContext;
class QgsPaintEffect;
class QgsSymbolLayerReference;
class QgsSldExportContext;
 
#ifndef SIP_RUN
typedef QMap<QString, QString> QgsStringMap;
#endif

class CORE_EXPORT QgsSymbolLayer
{
    //SIP_TYPEHEADER_INCLUDE( "qgslinesymbollayer.h" );
 
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    switch ( sipCpp->type() )
    {
      case Qgis::SymbolType::Marker:
        if ( sipCpp->layerType() == "EllipseMarker" )
          sipType = sipType_QgsEllipseSymbolLayer;
        else if ( sipCpp->layerType() == "FontMarker" )
          sipType = sipType_QgsFontMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "SimpleMarker" )
          sipType = sipType_QgsSimpleMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "FilledMarker" )
          sipType = sipType_QgsFilledMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "SvgMarker" )
          sipType = sipType_QgsSvgMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "RasterMarker" )
          sipType = sipType_QgsRasterMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "AnimatedMarker" )
          sipType = sipType_QgsAnimatedMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "VectorField" )
          sipType = sipType_QgsVectorFieldSymbolLayer;
        else if ( sipCpp->layerType() == "MaskMarker" )
          sipType = sipType_QgsMaskMarkerSymbolLayer;
        else
          sipType = sipType_QgsMarkerSymbolLayer;
        break;
 
      case Qgis::SymbolType::Line:
        if ( sipCpp->layerType() == "MarkerLine" )
          sipType = sipType_QgsMarkerLineSymbolLayer;
        else if ( sipCpp->layerType() == "SimpleLine" )
          sipType = sipType_QgsSimpleLineSymbolLayer;
        else if ( sipCpp->layerType() == "HashLine" )
          sipType = sipType_QgsHashedLineSymbolLayer;
        else if ( sipCpp->layerType() == "ArrowLine" )
          sipType = sipType_QgsArrowSymbolLayer;
        else if ( sipCpp->layerType() == "InterpolatedLine" )
          sipType = sipType_QgsInterpolatedLineSymbolLayer;
        else if ( sipCpp->layerType() == "RasterLine" )
          sipType = sipType_QgsRasterLineSymbolLayer;
        else if ( sipCpp->layerType() == "Lineburst" )
          sipType = sipType_QgsLineburstSymbolLayer;
        else if ( sipCpp->layerType() == "LinearReferencing" )
          sipType = sipType_QgsLinearReferencingSymbolLayer;
        else if ( sipCpp->layerType() == "FilledLine" )
          sipType = sipType_QgsFilledLineSymbolLayer;
        else
          sipType = sipType_QgsLineSymbolLayer;
        break;
 
      case Qgis::SymbolType::Fill:
        if ( sipCpp->layerType() == "SimpleFill" )
          sipType = sipType_QgsSimpleFillSymbolLayer;
        else if ( sipCpp->layerType() == "LinePatternFill" )
          sipType = sipType_QgsLinePatternFillSymbolLayer;
        else if ( sipCpp->layerType() == "PointPatternFill" )
          sipType = sipType_QgsPointPatternFillSymbolLayer;
        else if ( sipCpp->layerType() == "SVGFill" )
          sipType = sipType_QgsSVGFillSymbolLayer;
        else if ( sipCpp->layerType() == "RasterFill" )
          sipType = sipType_QgsRasterFillSymbolLayer;
        else if ( sipCpp->layerType() == "CentroidFill" )
          sipType = sipType_QgsCentroidFillSymbolLayer;
        else if ( sipCpp->layerType() == "GradientFill" )
          sipType = sipType_QgsGradientFillSymbolLayer;
        else if ( sipCpp->layerType() == "ShapeburstFill" )
          sipType = sipType_QgsShapeburstFillSymbolLayer;
        else if ( sipCpp->layerType() == "RandomMarkerFill" )
          sipType = sipType_QgsRandomMarkerFillSymbolLayer;
        else
          sipType = sipType_QgsFillSymbolLayer;
        break;
 
      case Qgis::SymbolType::Hybrid:
        sipType = sipType_QgsGeometryGeneratorSymbolLayer;
        break;
    }
    SIP_END
#endif
  public:
 
    // *INDENT-OFF*

    enum class Property SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbolLayer, Property ) : int
    {
      Size SIP_MONKEYPATCH_COMPAT_NAME( PropertySize ) = 0, 
      Angle SIP_MONKEYPATCH_COMPAT_NAME( PropertyAngle ), 
      Name SIP_MONKEYPATCH_COMPAT_NAME( PropertyName ), 
      FillColor SIP_MONKEYPATCH_COMPAT_NAME( PropertyFillColor ), 
      StrokeColor SIP_MONKEYPATCH_COMPAT_NAME( PropertyStrokeColor ), 
      StrokeWidth SIP_MONKEYPATCH_COMPAT_NAME( PropertyStrokeWidth ), 
      StrokeStyle SIP_MONKEYPATCH_COMPAT_NAME( PropertyStrokeStyle ), 
      Offset SIP_MONKEYPATCH_COMPAT_NAME( PropertyOffset ), 
      Character SIP_MONKEYPATCH_COMPAT_NAME( PropertyCharacter ), 
      Width SIP_MONKEYPATCH_COMPAT_NAME( PropertyWidth ), 
      Height SIP_MONKEYPATCH_COMPAT_NAME( PropertyHeight ), 
      PreserveAspectRatio SIP_MONKEYPATCH_COMPAT_NAME( PropertyPreserveAspectRatio ), 
      FillStyle SIP_MONKEYPATCH_COMPAT_NAME( PropertyFillStyle ), 
      JoinStyle SIP_MONKEYPATCH_COMPAT_NAME( PropertyJoinStyle ), 
      SecondaryColor SIP_MONKEYPATCH_COMPAT_NAME( PropertySecondaryColor ), 
      LineAngle SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineAngle ), 
      LineDistance SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineDistance ), 
      GradientType SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientType ), 
      CoordinateMode SIP_MONKEYPATCH_COMPAT_NAME( PropertyCoordinateMode ), 
      GradientSpread SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientSpread ), 
      GradientReference1X SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference1X ), 
      GradientReference1Y SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference1Y ), 
      GradientReference2X SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference2X ), 
      GradientReference2Y SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference2Y ), 
      GradientReference1IsCentroid SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference1IsCentroid ), 
      GradientReference2IsCentroid SIP_MONKEYPATCH_COMPAT_NAME( PropertyGradientReference2IsCentroid ), 
      BlurRadius SIP_MONKEYPATCH_COMPAT_NAME( PropertyBlurRadius ), 
      ShapeburstUseWholeShape SIP_MONKEYPATCH_COMPAT_NAME( PropertyShapeburstUseWholeShape ), 
      ShapeburstMaxDistance SIP_MONKEYPATCH_COMPAT_NAME( PropertyShapeburstMaxDistance ), 
      ShapeburstIgnoreRings SIP_MONKEYPATCH_COMPAT_NAME( PropertyShapeburstIgnoreRings ), 
      File SIP_MONKEYPATCH_COMPAT_NAME( PropertyFile ), 
      DistanceX SIP_MONKEYPATCH_COMPAT_NAME( PropertyDistanceX ), 
      DistanceY SIP_MONKEYPATCH_COMPAT_NAME( PropertyDistanceY ), 
      DisplacementX SIP_MONKEYPATCH_COMPAT_NAME( PropertyDisplacementX ), 
      DisplacementY SIP_MONKEYPATCH_COMPAT_NAME( PropertyDisplacementY ), 
      Opacity SIP_MONKEYPATCH_COMPAT_NAME( PropertyOpacity ), 
      CustomDash SIP_MONKEYPATCH_COMPAT_NAME( PropertyCustomDash ), 
      CapStyle SIP_MONKEYPATCH_COMPAT_NAME( PropertyCapStyle ), 
      Placement SIP_MONKEYPATCH_COMPAT_NAME( PropertyPlacement ), 
      Interval SIP_MONKEYPATCH_COMPAT_NAME( PropertyInterval ), 
      OffsetAlongLine SIP_MONKEYPATCH_COMPAT_NAME( PropertyOffsetAlongLine ), 
      AverageAngleLength SIP_MONKEYPATCH_COMPAT_NAME( PropertyAverageAngleLength ), 
      HorizontalAnchor SIP_MONKEYPATCH_COMPAT_NAME( PropertyHorizontalAnchor ), 
      VerticalAnchor SIP_MONKEYPATCH_COMPAT_NAME( PropertyVerticalAnchor ), 
      LayerEnabled SIP_MONKEYPATCH_COMPAT_NAME( PropertyLayerEnabled ), 
      ArrowWidth SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowWidth ), 
      ArrowStartWidth SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowStartWidth ), 
      ArrowHeadLength SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowHeadLength ), 
      ArrowHeadThickness SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowHeadThickness ), 
      ArrowHeadType SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowHeadType ), 
      ArrowType SIP_MONKEYPATCH_COMPAT_NAME( PropertyArrowType ), 
      OffsetX SIP_MONKEYPATCH_COMPAT_NAME( PropertyOffsetX ), 
      OffsetY SIP_MONKEYPATCH_COMPAT_NAME( PropertyOffsetY ), 
      PointCount SIP_MONKEYPATCH_COMPAT_NAME( PropertyPointCount ), 
      RandomSeed SIP_MONKEYPATCH_COMPAT_NAME( PropertyRandomSeed ), 
      ClipPoints SIP_MONKEYPATCH_COMPAT_NAME( PropertyClipPoints ), 
      DensityArea SIP_MONKEYPATCH_COMPAT_NAME( PropertyDensityArea ), 
      FontFamily SIP_MONKEYPATCH_COMPAT_NAME( PropertyFontFamily ), 
      FontStyle SIP_MONKEYPATCH_COMPAT_NAME( PropertyFontStyle ), 
      DashPatternOffset SIP_MONKEYPATCH_COMPAT_NAME( PropertyDashPatternOffset ), 
      TrimStart SIP_MONKEYPATCH_COMPAT_NAME( PropertyTrimStart ), 
      TrimEnd SIP_MONKEYPATCH_COMPAT_NAME( PropertyTrimEnd ), 
      LineStartWidthValue SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineStartWidthValue ), 
      LineEndWidthValue SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineEndWidthValue ), 
      LineStartColorValue SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineStartColorValue ), 
      LineEndColorValue SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineEndColorValue ), 
      MarkerClipping SIP_MONKEYPATCH_COMPAT_NAME( PropertyMarkerClipping ), 
      RandomOffsetX SIP_MONKEYPATCH_COMPAT_NAME( PropertyRandomOffsetX ), 
      RandomOffsetY SIP_MONKEYPATCH_COMPAT_NAME( PropertyRandomOffsetY ), 
      LineClipping SIP_MONKEYPATCH_COMPAT_NAME( PropertyLineClipping ), 
      SkipMultiples, 
      ShowMarker, 
      BlankSegments, 
    };
    // *INDENT-ON*

    static const QgsPropertiesDefinition &propertyDefinitions();
 
    virtual ~QgsSymbolLayer();
 
    QgsSymbolLayer &operator=( const QgsSymbolLayer &other ) = delete;

    virtual Qgis::SymbolLayerFlags flags() const;

    bool enabled() const { return mEnabled; }

    void setEnabled( bool enabled ) { mEnabled = enabled; }

    Qgis::SymbolLayerUserFlags userFlags() const;

    void setUserFlags( Qgis::SymbolLayerUserFlags flags );

    virtual QColor color() const;

    virtual void setColor( const QColor &color );

    virtual void setStrokeColor( const QColor &color );

    virtual QColor strokeColor() const;

    virtual void setFillColor( const QColor &color );

    virtual QColor fillColor() const;

    virtual QString layerType() const = 0;

    virtual void startRender( QgsSymbolRenderContext &context ) = 0;

    virtual void stopRender( QgsSymbolRenderContext &context ) = 0;

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

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

    virtual QgsSymbolLayer *clone() const = 0 SIP_FACTORY;

    Q_DECL_DEPRECATED virtual void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const SIP_DEPRECATED;

    virtual bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const;
 
    virtual QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const { Q_UNUSED( mmScaleFactor ) Q_UNUSED( mapUnitScaleFactor ); return QString(); }

    virtual QVariantMap properties() const = 0;
 
    virtual void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) = 0;

    virtual QgsSymbol *subSymbol();

    virtual bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER );
 
    Qgis::SymbolType type() const { return mType; }

    virtual bool isCompatibleWithSymbol( QgsSymbol *symbol ) const;

    virtual bool rendersIdenticallyTo( const QgsSymbolLayer *other ) const;

    virtual bool canCauseArtifactsBetweenAdjacentTiles() const;

    void setLocked( bool locked ) { mLocked = locked; }

    bool isLocked() const { return mLocked; }

    virtual double estimateMaxBleed( const QgsRenderContext &context ) const { Q_UNUSED( context ) return 0; }

    virtual void setOutputUnit( Qgis::RenderUnit unit ) { Q_UNUSED( unit ) }

    virtual Qgis::RenderUnit outputUnit() const { return Qgis::RenderUnit::Unknown; }

    virtual bool usesMapUnits() const;
 
    virtual void setMapUnitScale( const QgsMapUnitScale &scale ) { Q_UNUSED( scale ) }
    virtual QgsMapUnitScale mapUnitScale() const { return QgsMapUnitScale(); }

    void setRenderingPass( int renderingPass );

    int renderingPass() const;

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

    virtual void setDataDefinedProperty( Property key, const QgsProperty &property );

    virtual bool writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift = QPointF( 0.0, 0.0 ) ) const;

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

    virtual double dxfSize( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const;

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

    virtual QColor dxfColor( QgsSymbolRenderContext &context ) const;

    virtual double dxfAngle( QgsSymbolRenderContext &context ) const;

    virtual QVector<qreal> dxfCustomDashPattern( Qgis::RenderUnit &unit ) const;

    virtual Qt::PenStyle dxfPenStyle() const;

    virtual QColor dxfBrushColor( QgsSymbolRenderContext &context ) const;

    virtual Qt::BrushStyle dxfBrushStyle() const;

    QgsPaintEffect *paintEffect() const;

    void setPaintEffect( QgsPaintEffect *effect SIP_TRANSFER );

    virtual void prepareExpressions( const QgsSymbolRenderContext &context );

    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }

    const QgsPropertyCollection &dataDefinedProperties() const SIP_SKIP { return mDataDefinedProperties; }

    void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }

    virtual bool hasDataDefinedProperties() const;

    virtual QList<QgsSymbolLayerReference> masks() const;

    virtual void prepareMasks( const QgsSymbolRenderContext &context );

    void setId( const QString &id );

    QString id() const;

    bool installMasks( QgsRenderContext &context, bool recursive, const QRectF &rect = QRectF() );
 
  protected:
    QgsSymbolLayer( const QgsSymbolLayer &other ) SIP_SKIP;

    QgsSymbolLayer( Qgis::SymbolType type, bool locked = false );
 
    Qgis::SymbolType mType;

    bool mEnabled = true;

    Qgis::SymbolLayerUserFlags mUserFlags;
 
    bool mLocked = false;
    QColor mColor;
    int mRenderingPass = 0;
    QString mId;
    QgsPropertyCollection mDataDefinedProperties;
 
    std::unique_ptr< QgsPaintEffect > mPaintEffect;
    QgsFields mFields;
 
    // clip path to be used during rendering
    QPainterPath mClipPath;
 
    // Configuration of selected symbology implementation
    static const bool SELECTION_IS_OPAQUE = true;
    static const bool SELECT_FILL_BORDER = false;
    static const bool SELECT_FILL_STYLE = false;

    void restoreOldDataDefinedProperties( const QVariantMap &stringMap );

    void copyDataDefinedProperties( QgsSymbolLayer *destLayer ) const;

    void copyPaintEffect( QgsSymbolLayer *destLayer ) const;

    void removeMasks( QgsRenderContext &context, bool recursive );

    bool shouldRenderUsingSelectionColor( const QgsSymbolRenderContext &context ) const;
 
  private:
    static void initPropertyDefinitions();

    static QgsPropertiesDefinition sPropertyDefinitions;
 
#ifdef SIP_RUN
    QgsSymbolLayer( const QgsSymbolLayer &other );
#endif
 
};


class CORE_EXPORT QgsMarkerSymbolLayer : public QgsSymbolLayer
{
  public:
 
    QgsMarkerSymbolLayer &operator=( const QgsMarkerSymbolLayer &other ) = delete;
 
    void startRender( QgsSymbolRenderContext &context ) override;
 
    void stopRender( QgsSymbolRenderContext &context ) override;

    virtual void renderPoint( QPointF point, QgsSymbolRenderContext &context ) = 0;
 
    void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;

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

    double angle() const { return mAngle; }

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

    virtual void setSize( double size ) { mSize = size; }

    double size() const { return mSize; }

    void setSizeUnit( Qgis::RenderUnit unit ) { mSizeUnit = unit; }

    Qgis::RenderUnit sizeUnit() const { return mSizeUnit; }

    void setSizeMapUnitScale( const QgsMapUnitScale &scale ) { mSizeMapUnitScale = scale; }

    const QgsMapUnitScale &sizeMapUnitScale() const { return mSizeMapUnitScale; }

    void setScaleMethod( Qgis::ScaleMethod scaleMethod ) { mScaleMethod = scaleMethod; }

    Qgis::ScaleMethod scaleMethod() const { return mScaleMethod; }

    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 setHorizontalAnchorPoint( Qgis::HorizontalAnchorPoint h ) { mHorizontalAnchorPoint = h; }

    Qgis::HorizontalAnchorPoint horizontalAnchorPoint() const { return mHorizontalAnchorPoint; }

    void setVerticalAnchorPoint( Qgis::VerticalAnchorPoint v ) { mVerticalAnchorPoint = v; }

    Qgis::VerticalAnchorPoint verticalAnchorPoint() const { return mVerticalAnchorPoint; }
 
    using QgsSymbolLayer::toSld;
    bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const override;

    Q_DECL_DEPRECATED virtual void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const SIP_DEPRECATED;

    virtual bool writeSldMarker( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const;
 
    void setOutputUnit( Qgis::RenderUnit unit ) override;
    Qgis::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    double dxfSize( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
    double dxfAngle( QgsSymbolRenderContext &context ) const override;

    virtual QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) = 0;
 
  protected:
 
    QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other ) SIP_SKIP;

    QgsMarkerSymbolLayer( bool locked = false );

    void markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const;

    void markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const SIP_PYNAME( markerOffsetWithWidthAndHeight );

    void markerOffset( QgsSymbolRenderContext &context, double width, double height,
                       Qgis::RenderUnit widthUnit, Qgis::RenderUnit heightUnit,
                       double &offsetX, double &offsetY,
                       const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const SIP_PYNAME( markerOffset2 );

    static QPointF _rotatedOffset( QPointF offset, double angle );

    double mAngle = 0;
    double mLineAngle = 0;
    double mSize = 2.0;
    Qgis::RenderUnit mSizeUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mSizeMapUnitScale;
    QPointF mOffset;
    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
    Qgis::ScaleMethod mScaleMethod = Qgis::ScaleMethod::ScaleDiameter;
    Qgis::HorizontalAnchorPoint mHorizontalAnchorPoint = Qgis::HorizontalAnchorPoint::Center;
    Qgis::VerticalAnchorPoint mVerticalAnchorPoint = Qgis::VerticalAnchorPoint::Center;
 
  private:
    static Qgis::HorizontalAnchorPoint decodeHorizontalAnchorPoint( const QString &str );
    static Qgis::VerticalAnchorPoint decodeVerticalAnchorPoint( const QString &str );
 
#ifdef SIP_RUN
    QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other );
#endif
};

class CORE_EXPORT QgsLineSymbolLayer : public QgsSymbolLayer
{
  public:

    enum RenderRingFilter
    {
      AllRings, 
      ExteriorRingOnly, 
      InteriorRingsOnly, 
    };
 
    QgsLineSymbolLayer( const QgsLineSymbolLayer &other ) = delete;
    QgsLineSymbolLayer &operator=( const QgsLineSymbolLayer &other ) = delete;
 
    void setOutputUnit( Qgis::RenderUnit unit ) override;
    Qgis::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;
    double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;

    virtual void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) = 0;

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

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

    virtual double width() const { return mWidth; }

    virtual double width( const QgsRenderContext &context ) const;

    double offset() const { return mOffset; }

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

    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; }
 
    // TODO QGIS 4.0 - setWidthUnit(), widthUnit(), setWidthUnitScale(), widthUnitScale()
    // only apply to simple line symbol layers and do not belong here.

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

    Qgis::RenderUnit widthUnit() const { return mWidthUnit; }
 
    void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
    const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }

    RenderRingFilter ringFilter() const;

    void setRingFilter( QgsLineSymbolLayer::RenderRingFilter filter );
 
  protected:
    QgsLineSymbolLayer( bool locked = false );
 
    double mWidth = 0;
    Qgis::RenderUnit mWidthUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mWidthMapUnitScale;
    double mOffset = 0;
    Qgis::RenderUnit mOffsetUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
    RenderRingFilter mRingFilter = AllRings;
 
  private:
#ifdef SIP_RUN
    QgsLineSymbolLayer( const QgsLineSymbolLayer &other );
#endif
};

class CORE_EXPORT QgsFillSymbolLayer : public QgsSymbolLayer
{
  public:
 
    QgsFillSymbolLayer( const QgsFillSymbolLayer &other ) = delete;
    QgsFillSymbolLayer &operator=( const QgsFillSymbolLayer &other ) = delete;

    virtual void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) = 0;
 
    void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;

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

    double angle() const { return mAngle; }

    virtual QImage toTiledPatternImage( ) const;
 
  protected:
    QgsFillSymbolLayer( bool locked = false );
    void _renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context );
 
    double mAngle = 0.0;
 
  private:
#ifdef SIP_RUN
    QgsFillSymbolLayer( const QgsFillSymbolLayer &other );
#endif
};
 
class QgsSymbolLayerWidget;  // why does SIP fail, when this isn't here
 
#endif