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, 
      ExtraItems,    
    };
    // *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;

    QString selectiveMaskingSourceSetId() const;

    void setSelectiveMaskingSourceSetId( const QString &id );

    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;
 
    QString mSelectiveMaskingSourceSetId;
 
    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 copyCommonProperties( QgsSymbolLayer *destLayer ) const;

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