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              QgsSymbol::ScaleDiameter

#include "qgis_core.h"
#include "qgis.h"
#include <QColor>
#include <QMap>
#include <QPointF>
#include <QSet>
#include <QDomDocument>
#include <QDomElement>

#include "qgssymbol.h"
#include "qgssymbollayerutils.h" // QgsStringMap
#include "qgsfields.h"
#include "qgspropertycollection.h"

class QPainter;
class QSize;
class QPolygonF;

class QgsDxfExport;
class QgsExpression;
class QgsRenderContext;
class QgsPaintEffect;

class CORE_EXPORT QgsSymbolLayer
{
#ifdef SIP_RUN
#include <qgslinesymbollayer.h>
#endif


#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    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;
    }
    SIP_END
#endif
  public:

    enum Property
    {
      PropertySize = 0, 
      PropertyAngle, 
      PropertyName, 
      PropertyFillColor, 
      PropertyStrokeColor, 
      PropertyStrokeWidth, 
      PropertyStrokeStyle, 
      PropertyOffset, 
      PropertyCharacter, 
      PropertyWidth, 
      PropertyHeight, 
      PropertyPreserveAspectRatio, 
      PropertyFillStyle, 
      PropertyJoinStyle, 
      PropertySecondaryColor, 
      PropertyLineAngle, 
      PropertyLineDistance, 
      PropertyGradientType, 
      PropertyCoordinateMode, 
      PropertyGradientSpread, 
      PropertyGradientReference1X, 
      PropertyGradientReference1Y, 
      PropertyGradientReference2X, 
      PropertyGradientReference2Y, 
      PropertyGradientReference1IsCentroid, 
      PropertyGradientReference2IsCentroid, 
      PropertyBlurRadius, 
      PropertyShapeburstUseWholeShape, 
      PropertyShapeburstMaxDistance, 
      PropertyShapeburstIgnoreRings, 
      PropertyFile, 
      PropertyDistanceX, 
      PropertyDistanceY, 
      PropertyDisplacementX, 
      PropertyDisplacementY, 
      PropertyOpacity, 
      PropertyCustomDash, 
      PropertyCapStyle, 
      PropertyPlacement, 
      PropertyInterval, 
      PropertyOffsetAlongLine, 
      PropertyHorizontalAnchor, 
      PropertyVerticalAnchor, 
      PropertyLayerEnabled, 
      PropertyArrowWidth, 
      PropertyArrowStartWidth, 
      PropertyArrowHeadLength, 
      PropertyArrowHeadThickness, 
      PropertyArrowHeadType, 
      PropertyArrowType, 
    };

    static const QgsPropertiesDefinition &propertyDefinitions();

    virtual ~QgsSymbolLayer();

    bool enabled() const { return mEnabled; }

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

    virtual QColor color() const { return mColor; }

    virtual void setColor( const QColor &color ) { mColor = color; }

    virtual void setStrokeColor( const QColor &color ) { Q_UNUSED( color ); }

    virtual QColor strokeColor() const { return QColor(); }

    virtual void setFillColor( const QColor &color ) { Q_UNUSED( color ); }

    virtual QColor fillColor() const { return QColor(); }

    virtual QString layerType() const = 0;

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

    virtual QgsSymbolLayer *clone() const = 0 SIP_FACTORY;

    virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap &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 QgsStringMap properties() const = 0;

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

    virtual QgsSymbol *subSymbol() { return nullptr; }

    virtual bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) { delete symbol; return false; }

    QgsSymbol::SymbolType type() const { return mType; }

    virtual bool isCompatibleWithSymbol( QgsSymbol *symbol ) 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( QgsUnitTypes::RenderUnit unit ) { Q_UNUSED( unit ); }

    virtual QgsUnitTypes::RenderUnit outputUnit() const { return QgsUnitTypes::RenderUnknownUnit; }

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

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

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

    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; }

  protected:

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

    QgsSymbol::SymbolType mType;

    bool mEnabled;

    bool mLocked;
    QColor mColor;
    int mRenderingPass;

    QgsPropertyCollection mDataDefinedProperties;

    QgsPaintEffect *mPaintEffect = nullptr;
    QgsFields mFields;

    // 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 QgsStringMap &stringMap );

    void copyDataDefinedProperties( QgsSymbolLayer *destLayer ) const;

    void copyPaintEffect( QgsSymbolLayer *destLayer ) const;

  private:
    static void initPropertyDefinitions();

    static QgsPropertiesDefinition sPropertyDefinitions;

};


class CORE_EXPORT QgsMarkerSymbolLayer : public QgsSymbolLayer
{
  public:

    enum HorizontalAnchorPoint
    {
      Left, 
      HCenter, 
      Right, 
    };

    enum VerticalAnchorPoint
    {
      Top, 
      VCenter, 
      Bottom, 
    };

    void startRender( 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; }

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

    double size() const { return mSize; }

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

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

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

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

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

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

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

    QPointF offset() const { return mOffset; }

    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }

    QgsUnitTypes::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 QgsStringMap &props ) const override;

    virtual void writeSldMarker( QDomDocument &doc, QDomElement &element, const QgsStringMap &props ) const
    { Q_UNUSED( props ); element.appendChild( doc.createComment( QStringLiteral( "QgsMarkerSymbolLayer %1 not implemented yet" ).arg( layerType() ) ) ); }

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() 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,
                       QgsUnitTypes::RenderUnit widthUnit, QgsUnitTypes::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;
    QgsUnitTypes::RenderUnit mSizeUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mSizeMapUnitScale;
    QPointF mOffset;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
    QgsSymbol::ScaleMethod mScaleMethod = QgsSymbol::ScaleDiameter;
    HorizontalAnchorPoint mHorizontalAnchorPoint = HCenter;
    VerticalAnchorPoint mVerticalAnchorPoint = VCenter;

  private:
    static QgsMarkerSymbolLayer::HorizontalAnchorPoint decodeHorizontalAnchorPoint( const QString &str );
    static QgsMarkerSymbolLayer::VerticalAnchorPoint decodeVerticalAnchorPoint( const QString &str );
};

class CORE_EXPORT QgsLineSymbolLayer : public QgsSymbolLayer
{
  public:
    virtual void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) = 0;

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

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

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

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

    QgsUnitTypes::RenderUnit widthUnit() const { return mWidthUnit; }

    void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
    const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }

    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }

    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }

    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }

    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::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;

  protected:
    QgsLineSymbolLayer( bool locked = false );

    double mWidth = 0;
    QgsUnitTypes::RenderUnit mWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mWidthMapUnitScale;
    double mOffset = 0;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
};

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

    void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;

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

  protected:
    QgsFillSymbolLayer( bool locked = false );
    void _renderPolygon( QPainter *p, const QPolygonF &points, const QList<QPolygonF> *rings, QgsSymbolRenderContext &context );

    double mAngle = 0.0;
};

class QgsSymbolLayerWidget;  // why does SIP fail, when this isn't here

#endif