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_core.h"
#include "qgis.h"
#include "qgsfields.h"
#include "qgspropertycollection.h"
#include "qgssymbolrendercontext.h"
 
#include <QColor>
#include <QMap>
#include <QPointF>
#include <QSet>
#include <QDomDocument>
#include <QDomElement>
#include <QPainterPath>
#include <QImage>
 
class QPainter;
class QSize;
class QPolygonF;
 
class QgsDxfExport;
class QgsExpression;
class QgsRenderContext;
class QgsPaintEffect;
class QgsSymbolLayerReference;
 
#ifndef SIP_RUN
typedef QMap<QString, QString> QgsStringMap;
#endif
 
class CORE_EXPORT QgsSymbolLayer
{
#ifdef SIP_RUN
#include <qgslinesymbollayer.h>
#endif
 
 
#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
          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, 
    };
    // *INDENT-ON*
 
    static const QgsPropertiesDefinition &propertyDefinitions();
 
    virtual ~QgsSymbolLayer();
 
    QgsSymbolLayer( const QgsSymbolLayer &other ) = delete;
    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;
 
    virtual void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
    { Q_UNUSED( props ) element.appendChild( doc.createComment( QStringLiteral( "SymbolLayerV2 %1 not implemented yet" ).arg( layerType() ) ) ); }
 
    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 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 { return mDataDefinedProperties; } SIP_SKIP
 
    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( 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:
 
    enum HorizontalAnchorPoint
    {
      Left, 
      HCenter, 
      Right, 
    };
 
    enum VerticalAnchorPoint
    {
      Top, 
      VCenter, 
      Bottom, 
    };
 
    QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other ) = delete;
    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( HorizontalAnchorPoint h ) { mHorizontalAnchorPoint = h; }
 
    HorizontalAnchorPoint horizontalAnchorPoint() const { return mHorizontalAnchorPoint; }
 
    void setVerticalAnchorPoint( VerticalAnchorPoint v ) { mVerticalAnchorPoint = v; }
 
    VerticalAnchorPoint verticalAnchorPoint() const { return mVerticalAnchorPoint; }
 
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
 
    virtual void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
    { Q_UNUSED( props ) element.appendChild( doc.createComment( QStringLiteral( "QgsMarkerSymbolLayer %1 not implemented yet" ).arg( layerType() ) ) ); }
 
    void setOutputUnit( Qgis::RenderUnit unit ) override;
    Qgis::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    virtual double dxfSize( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
    virtual double dxfAngle( QgsSymbolRenderContext &context ) const override;
 
    virtual QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) = 0;
 
  protected:
 
    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;
    HorizontalAnchorPoint mHorizontalAnchorPoint = HCenter;
    VerticalAnchorPoint mVerticalAnchorPoint = VCenter;
 
  private:
    static QgsMarkerSymbolLayer::HorizontalAnchorPoint decodeHorizontalAnchorPoint( const QString &str );
    static QgsMarkerSymbolLayer::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