QGIS/python/core/symbology-ng/qgssymbollayer.sip

class QgsSymbolLayer
{
%TypeHeaderCode
#include <qgssymbollayer.h>
#include <qgslinesymbollayer.h>
%End

%ConvertToSubClassCode
  switch (sipCpp->type())
  {
    case QgsSymbol::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() == "VectorField" )
        sipType = sipType_QgsVectorFieldSymbolLayer;
      else
        sipType = sipType_QgsMarkerSymbolLayer;
      break;

    case QgsSymbol::Line:
      if ( sipCpp->layerType() == "MarkerLine" )
        sipType = sipType_QgsMarkerLineSymbolLayer;
      else if ( sipCpp->layerType() == "SimpleLine" )
        sipType = sipType_QgsSimpleLineSymbolLayer;
      else if ( sipCpp->layerType() == "ArrowLine" )
        sipType = sipType_QgsArrowSymbolLayer;
      else
        sipType = sipType_QgsLineSymbolLayer;
      break;

    case QgsSymbol::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
        sipType = sipType_QgsFillSymbolLayer;
      break;

    case QgsSymbol::Hybrid:
      sipType = sipType_QgsGeometryGeneratorSymbolLayer;
      break;
  }
%End

  public:

    /**
     * Data definable properties.
     * @note added in QGIS 3.0
     */
    enum Property
    {
      PropertySize, //!< Symbol size
      PropertyAngle, //!< Symbol angle
      PropertyName, //!< Name, eg shape name for simple markers
      PropertyFillColor, //!< Fill color
      PropertyOutlineColor, //!< Outline color
      PropertyOutlineWidth, //!< Outline width
      PropertyOutlineStyle, //!< Outline style (eg solid, dashed)
      PropertyOffset, //!< Symbol offset
      PropertyCharacter, //!< Character, eg for font marker symbol layers
      PropertyWidth, //!< Symbol width
      PropertyHeight, //!< Symbol height
      PropertyFillStyle, //!< Fill style (eg solid, dots)
      PropertyJoinStyle, //!< Line join style
      PropertySecondaryColor, //!< Secondary color (eg for gradient fills)
      PropertyLineAngle, //!< Line angle
      PropertyLineDistance, //!< Distance between lines
      PropertyGradientType, //!< Gradient fill type
      PropertyCoordinateMode, //!< Gradient coordinate mode
      PropertyGradientSpread, //!< Gradient spread mode
      PropertyGradientReference1X, //!< Gradient reference point 1 x
      PropertyGradientReference1Y, //!< Gradient reference point 1 y
      PropertyGradientReference2X, //!< Gradient reference point 2 x
      PropertyGradientReference2Y, //!< Gradient reference point 2 y
      PropertyGradientReference1IsCentroid, //!< Gradient reference point 1 is centroid
      PropertyGradientReference2IsCentroid, //!< Gradient reference point 2 is centroid
      PropertyBlurRadius, //!< Shapeburst blur radius
      PropertyShapeburstUseWholeShape, //!< Shapeburst use whole shape
      PropertyShapeburstMaxDistance, //!< Shapeburst fill from edge distance
      PropertyShapeburstIgnoreRings, //!< Shapeburst ignore rings
      PropertyFile, //!< Filename, eg for svg files
      PropertyDistanceX, //!< Horizontal distance between points
      PropertyDistanceY, //!< Vertical distance between points
      PropertyDisplacementX, //!< Horizontal displacement
      PropertyDisplacementY, //!< Vertical displacement
      PropertyAlpha, //!< Alpha (opacity)
      PropertyCustomDash, //!< Custom dash pattern
      PropertyCapStyle, //!< Line cap style
      PropertyPlacement, //!< Line marker placement
      PropertyInterval, //!< Line marker interval
      PropertyOffsetAlongLine, //!< Offset along line
      PropertyHorizontalAnchor, //!< Horizontal anchor point
      PropertyVerticalAnchor, //!< Vertical anchor point
      PropertyLayerEnabled, //!< Whether symbol layer is enabled
      PropertyArrowWidth, //!< Arrow tail width
      PropertyArrowStartWidth, //!< Arrow tail start width
      PropertyArrowHeadLength, //!< Arrow head length
      PropertyArrowHeadThickness, //!< Arrow head thickness
      PropertyArrowHeadType, //!< Arrow head type
      PropertyArrowType, //!< Arrow type
    };

    static const QgsPropertiesDefinition PROPERTY_DEFINITIONS;

    virtual ~QgsSymbolLayer();

    /**
     * Returns true if symbol layer is enabled and will be drawn.
     * @note added in QGIS 3.0
     * @see setEnabled()
     */
    bool enabled() const;

    /**
     * Sets whether symbol layer is enabled and should be drawn. Disabled
     * layers are not drawn, but remain part of the symbol and can be re-enabled
     * when desired.
     * @note added in QGIS 3.0
     * @see enabled()
     */
    void setEnabled( bool enabled );

    /**
     * The fill color.
     */
    virtual QColor color() const;
    /**
     * The fill color.
     */
    virtual void setColor( const QColor& color );

    /** Set outline color. Supported by marker and fill layers.
     * @note added in 2.1 */
    virtual void setOutlineColor( const QColor& color );

    /** Get outline color. Supported by marker and fill layers.
     * @note added in 2.1 */
    virtual QColor outlineColor() const;

    /** Set fill color. Supported by marker and fill layers.
     * @note added in 2.1 */
    virtual void setFillColor( const QColor& color );

    /** Get fill color. Supported by marker and fill layers.
     * @note added in 2.1 */
    virtual QColor fillColor() const;

    /**
     * Returns a string that represents this layer type. Used for serialization.
     * Should match with the string used to register this symbol layer in the registry.
     */
    virtual QString layerType() const = 0;

    virtual void startRender( QgsSymbolRenderContext& context ) = 0;
    virtual void stopRender( QgsSymbolRenderContext& context ) = 0;

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

    virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap& props ) const;

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

    /**
     * Should be reimplemented by subclasses to return a string map that
     * contains the configuration information for the symbol layer. This
     * is used to serialize a symbol layer perstistently.
     */
    virtual QgsStringMap properties() const = 0;

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

    virtual QgsSymbol* subSymbol();
    //! set layer's subsymbol. takes ownership of the passed symbol
    virtual bool setSubSymbol( QgsSymbol* symbol /Transfer/ );

    QgsSymbol::SymbolType type() const;

    //! Returns if the layer can be used below the specified symbol
    virtual bool isCompatibleWithSymbol( QgsSymbol* symbol ) const;

    void setLocked( bool locked );
    bool isLocked() const;

    /** Returns the estimated maximum distance which the layer style will bleed outside
      the drawn shape. For example, polygons drawn with an outline will draw half the width
      of the outline outside of the polygon. This amount is estimated, since it may
      be affected by data defined symbology rules.*/
    virtual double estimateMaxBleed( const QgsRenderContext& context ) const;

    /** Sets the units to use for sizes and widths within the symbol layer. Individual
     * symbol layer subclasses will interpret this in different ways, e.g., a marker symbol
     * layer may use it to specify the units for the marker size, while a line symbol
     * layer may use it to specify the units for the line width.
     * @param unit output units
     * @see outputUnit()
     */
    virtual void setOutputUnit( QgsUnitTypes::RenderUnit unit );

    /** Returns the units to use for sizes and widths within the symbol layer. Individual
     * symbol layer subclasses will interpret this in different ways, e.g., a marker symbol
     * layer may use it to specify the units for the marker size, while a line symbol
     * layer may use it to specify the units for the line width.
     * @returns output unit, or QgsUnitTypes::RenderUnknownUnit if the symbol layer contains mixed units
     * @see setOutputUnit()
     */
    virtual QgsUnitTypes::RenderUnit outputUnit() const;

    virtual void setMapUnitScale( const QgsMapUnitScale& scale );
    virtual QgsMapUnitScale mapUnitScale() const;

    // used only with rending with symbol levels is turned on (0 = first pass, 1 = second, ...)
    void setRenderingPass( int renderingPass );
    int renderingPass() const;

    /** Returns the set of attributes referenced by the layer. This includes attributes
     * required by any data defined properties associated with the layer.
     */
    virtual QSet<QString> usedAttributes( const QgsRenderContext& context ) const;

    /** Sets a data defined property for the layer.
     * @param property unique property key. Any existing data defined with the same key will be deleted and overridden.
     * @param dataDefined data defined object to associate with property key. Ownership is transferred to the layer.
     * @note added in QGIS 2.9
     * @see getDataDefinedProperty
     * @see removeDataDefinedProperty
     */
    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 dxfOffset( const QgsDxfExport& e, QgsSymbolRenderContext& context ) const;

    virtual QColor dxfColor( QgsSymbolRenderContext& context ) const;
    virtual double dxfAngle( QgsSymbolRenderContext& context ) const;

    virtual QVector<qreal> dxfCustomDashPattern( QgsUnitTypes::RenderUnit& unit ) const;
    virtual Qt::PenStyle dxfPenStyle() const;
    virtual QColor dxfBrushColor( QgsSymbolRenderContext& context ) const;
    virtual Qt::BrushStyle dxfBrushStyle() const;

    /** Returns the current paint effect for the layer.
     * @returns paint effect
     * @note added in QGIS 2.9
     * @see setPaintEffect
     */
    QgsPaintEffect* paintEffect() const;

    /** Sets the current paint effect for the layer.
     * @param effect paint effect. Ownership is transferred to the layer.
     * @note added in QGIS 2.9
     * @see paintEffect
     */
    void setPaintEffect( QgsPaintEffect* effect /Transfer/);

    /** Prepares all data defined property expressions for evaluation. This should
     * be called prior to evaluating data defined properties.
     * @param context symbol render context
     * @note added in QGIS 2.12
     */
    virtual void prepareExpressions( const QgsSymbolRenderContext& context );


    /** Returns a reference to the symbol layer's property collection, used for data defined overrides.
     * @note added in QGIS 3.0
     * @see setProperties()
     */
    QgsPropertyCollection& dataDefinedProperties();

    /** Returns a reference to the symbol layer's property collection, used for data defined overrides.
     * @note added in QGIS 3.0
     * @see setProperties()
     */
    //const QgsPropertyCollection& dataDefinedProperties() const { return mProperties; }

    /** Sets the symbol layer's property collection, used for data defined overrides.
     * @param collection property collection. Existing properties will be replaced.
     * @note added in QGIS 3.0
     * @see properties()
     */
    void setDataDefinedProperties( const QgsPropertyCollection& collection );

  protected:
    QgsSymbolLayer( QgsSymbol::SymbolType type, bool locked = false );

    /** Restores all data defined properties from string map.
     * @param stringMap source string map
     * @note added in QGIS 2.9
     * @see saveDataDefinedProperties
     */
    void restoreOldDataDefinedProperties( const QgsStringMap& stringMap );

    /** Copies all data defined properties of this layer to another symbol layer.
     * @param destLayer destination layer
     */
    void copyDataDefinedProperties( QgsSymbolLayer* destLayer ) const;

    /** Copies paint effect of this layer to another symbol layer
     * @param destLayer destination layer
     * @note added in QGIS 2.9
     */
    void copyPaintEffect( QgsSymbolLayer* destLayer ) const;

};

//////////////////////

/** \ingroup core
 * \class QgsMarkerSymbolLayer
 * \brief Abstract base class for marker symbol layers.
 */
class QgsMarkerSymbolLayer : QgsSymbolLayer
{
%TypeHeaderCode
#include <qgssymbollayer.h>
%End
  public:

    //! Symbol horizontal anchor points
    enum HorizontalAnchorPoint
    {
      Left, /*!< Align to left side of symbol */
      HCenter, /*!< Align to horizontal center of symbol */
      Right, /*!< Align to right side of symbol */
    };

    //! Symbol vertical anchor points
    enum VerticalAnchorPoint
    {
      Top, /*!< Align to top of symbol */
      VCenter, /*!< Align to vertical center of symbol */
      Bottom, /*!< Align to bottom of symbol */
    };

    void startRender( QgsSymbolRenderContext& context );

    /** Renders a marker at the specified point. Derived classes must implement this to
     * handle drawing the point.
     * @param point position at which to render point, in painter units
     * @param context symbol render context
     */
    virtual void renderPoint( QPointF point, QgsSymbolRenderContext& context ) = 0;

    void drawPreviewIcon( QgsSymbolRenderContext& context, QSize size );

    /** Sets the rotation angle for the marker.
     * @param angle angle in degrees clockwise from north.
     * @see angle()
     * @see setLineAngle()
     */
    void setAngle( double angle );

    /** Returns the rotation angle for the marker, in degrees clockwise from north.
     * @see setAngle()
     */
    double angle() const;

    /** Sets the line angle modification for the symbol's angle. This angle is added to
     * the marker's rotation and data defined rotation before rendering the symbol, and
     * is usually used for orienting symbols to match a line's angle.
     * @param lineAngle Angle in degrees clockwise from north, valid values are between 0 and 360
     * @note added in QGIS 2.9
     * @see setAngle()
     * @see angle()
     */
    void setLineAngle( double lineAngle );

    /** Sets the symbol size.
     * @param size symbol size. Units are specified by sizeUnit().
     * @see size()
     * @see setSizeUnit()
     * @see setSizeMapUnitScale()
     */
    void setSize( double size );

    /** Returns the symbol size. Units are specified by sizeUnit().
     * @see setSize()
     * @see sizeUnit()
     * @see sizeUnitMapScale()
     */
    double size() const;

    /** Sets the units for the symbol's size.
     * @param unit size units
     * @see sizeUnit()
     * @see setSize()
     * @see setSizeMapUnitScale()
     */
    void setSizeUnit( QgsUnitTypes::RenderUnit unit );

    /** Returns the units for the symbol's size.
     * @see setSizeUnit()
     * @see size()
     * @see sizeMapUnitScale()
     */
    QgsUnitTypes::RenderUnit sizeUnit() const;

    /** Sets the map unit scale for the symbol's size.
     * @param scale size map unit scale
     * @see sizeMapUnitScale()
     * @see setSize()
     * @see setSizeUnit()
     */
    void setSizeMapUnitScale( const QgsMapUnitScale& scale);

    /** Returns the map unit scale for the symbol's size.
     * @see setSizeMapUnitScale()
     * @see size()
     * @see sizeUnit()
     */
    const QgsMapUnitScale& sizeMapUnitScale() const;

    /** Sets the method to use for scaling the marker's size.
     * @param scaleMethod scale method
     * @see scaleMethod()
     */
    void setScaleMethod( QgsSymbol::ScaleMethod scaleMethod );

    /** Returns the method to use for scaling the marker's size.
     * @see setScaleMethod()
     */
    QgsSymbol::ScaleMethod scaleMethod() const;

    /** Sets the marker's offset, which is the horizontal and vertical displacement which the rendered marker
     * should have from the original feature's geometry.
     * @param offset marker offset. Units are specified by offsetUnit()
     * @see offset()
     * @see setOffsetUnit()
     * @see setOffsetMapUnitScale()
     */
    void setOffset( QPointF offset );

    /** Returns the marker's offset, which is the horizontal and vertical displacement which the rendered marker
     * will have from the original feature's geometry. Units are specified by offsetUnit().
     * @see setOffset()
     * @see offsetUnit()
     * @see offsetMapUnitScale()
     */
    QPointF offset();

    /** Sets the units for the symbol's offset.
     * @param unit offset units
     * @see offsetUnit()
     * @see setOffset()
     * @see setOffsetMapUnitScale()
     */
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit );

    /** Returns the units for the symbol's offset.
     * @see setOffsetUnit()
     * @see offset()
     * @see offsetMapUnitScale()
     */
    QgsUnitTypes::RenderUnit offsetUnit() const;

   /** Sets the map unit scale for the symbol's offset.
     * @param scale offset map unit scale
     * @see offsetMapUnitScale()
     * @see setOffset()
     * @see setOffsetUnit()
     */
    void setOffsetMapUnitScale( const QgsMapUnitScale& scale);

    /** Returns the map unit scale for the symbol's offset.
     * @see setOffsetMapUnitScale()
     * @see offset()
     * @see offsetUnit()
     */
    const QgsMapUnitScale& offsetMapUnitScale() const;

    /** Sets the horizontal anchor point for positioning the symbol.
     * @param h anchor point. Symbol will be drawn so that the horizontal anchor point is aligned with
     * the marker's desired location.
     * @see horizontalAnchorPoint()
     * @see setVerticalAnchorPoint()
     */
    void setHorizontalAnchorPoint( HorizontalAnchorPoint h );

    /** Returns the horizontal anchor point for positioning the symbol. The symbol will be drawn so that
     * the horizontal anchor point is aligned with the marker's desired location.
     * @see setHorizontalAnchorPoint()
     * @see verticalAnchorPoint()
     */
    HorizontalAnchorPoint horizontalAnchorPoint() const;

    /** Sets the vertical anchor point for positioning the symbol.
     * @param v anchor point. Symbol will be drawn so that the vertical anchor point is aligned with
     * the marker's desired location.
     * @see verticalAnchorPoint()
     * @see setHorizontalAnchorPoint()
     */
    void setVerticalAnchorPoint( VerticalAnchorPoint v );

    /** Returns the vertical anchor point for positioning the symbol. The symbol will be drawn so that
     * the vertical anchor point is aligned with the marker's desired location.
     * @see setVerticalAnchorPoint()
     * @see horizontalAnchorPoint()
     */
    VerticalAnchorPoint verticalAnchorPoint() const;

    virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap& props ) const;

    /** Writes the symbol layer definition as a SLD XML element.
     * @param doc XML document
     * @param element parent XML element
     * @param props symbol layer definition (see properties())
     */
    virtual void writeSldMarker( QDomDocument &doc, QDomElement &element, const QgsStringMap& props ) const;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit );
    QgsUnitTypes::RenderUnit outputUnit() const;

    void setMapUnitScale( const QgsMapUnitScale& scale );
    QgsMapUnitScale mapUnitScale() const;

    /** Returns the approximate bounding box of the marker symbol layer, taking into account
     * any data defined overrides and offsets which are set for the marker layer.
     * @returns approximate symbol bounds, in painter units
     * @note added in QGIS 2.14
     */
    virtual QRectF bounds( QPointF point, QgsSymbolRenderContext& context ) = 0;

  protected:

    /** Constructor for QgsMarkerSymbolLayer.
     * @param locked set to true to lock symbol color
     */
    QgsMarkerSymbolLayer( bool locked = false );

    /** Calculates the required marker offset, including both the symbol offset
     * and any displacement required to align with the marker's anchor point.
     * @param context symbol render context
     * @param offsetX will be set to required horizontal offset (in painter units)
     * @param offsetY will be set to required vertical offset (in painter units)
     */
    void markerOffset( QgsSymbolRenderContext& context, double& offsetX, double& offsetY ) const;

    /** Calculates the required marker offset, including both the symbol offset
     * and any displacement required to align with the marker's anchor point.
     * @param context symbol render context
     * @param width marker width
     * @param height marker height
     * @param offsetX will be set to required horizontal offset (in painter units)
     * @param offsetY will be set to required vertical offset (in painter units)
     * @note available in python as markerOffsetWithWidthAndHeight
     */
    void markerOffset( QgsSymbolRenderContext& context, double width, double height, double& offsetX, double& offsetY ) const /PyName=markerOffsetWithWidthAndHeight/;

    //! @note available in python bindings as markerOffset2
    void markerOffset( QgsSymbolRenderContext& context, double width, double height,
                       QgsUnitTypes::RenderUnit widthUnit, QgsUnitTypes::RenderUnit heightUnit,
                       double& offsetX, double& offsetY,
                       const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const /PyName=markerOffset2/;

   /** Adjusts a marker offset to account for rotation.
     * @param offset offset prior to rotation
     * @param angle rotation angle in degrees clockwise from north
     * @return adjusted offset
     */
    static QPointF _rotatedOffset( QPointF offset, double angle );
};

class QgsLineSymbolLayer : QgsSymbolLayer
{
%TypeHeaderCode
#include <qgssymbollayer.h>
%End

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

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

    virtual void setWidth( double width );
    virtual double width() const;

    double offset() const;
    void setOffset( double offset );

    /** Sets the units for the line's width.
     * @param unit width units
     * @see widthUnit()
    */
    void setWidthUnit( QgsUnitTypes::RenderUnit unit );

    /** Returns the units for the line's width.
     * @see setWidthUnit()
    */
    QgsUnitTypes::RenderUnit widthUnit() const;

    void setWidthMapUnitScale( const QgsMapUnitScale& scale);
    const QgsMapUnitScale& widthMapUnitScale() const;

    /** Sets the units for the line's offset.
     * @param unit offset units
     * @see offsetUnit()
    */
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit );

    /** Returns the units for the line's offset.
     * @see setOffsetUnit()
    */
    QgsUnitTypes::RenderUnit offsetUnit() const;

    void setOffsetMapUnitScale( const QgsMapUnitScale& scale );
    const QgsMapUnitScale& offsetMapUnitScale() const;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit );
    QgsUnitTypes::RenderUnit outputUnit() const;

    void setMapUnitScale( const QgsMapUnitScale& scale );
    QgsMapUnitScale mapUnitScale() const;

    void drawPreviewIcon( QgsSymbolRenderContext& context, QSize size );

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

  protected:
    QgsLineSymbolLayer( bool locked = false );
};

class QgsFillSymbolLayer : QgsSymbolLayer
{
%TypeHeaderCode
#include <qgssymbollayer.h>
%End

  public:
    virtual void renderPolygon( const QPolygonF& points, QList<QPolygonF>* rings, QgsSymbolRenderContext& context ) = 0;

    void drawPreviewIcon( QgsSymbolRenderContext& context, QSize size );

    void setAngle( double angle );
    double angle() const;

  protected:
    QgsFillSymbolLayer( bool locked = false );
    /** Default method to render polygon*/
    void _renderPolygon( QPainter* p, const QPolygonF& points, const QList<QPolygonF>* rings, QgsSymbolRenderContext& context );
};