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 <QPainterPath>
 
#include "qgssymbol.h"
#include "qgsfields.h"
#include "qgspropertycollection.h"
#include "qgspainteffect.h"
 
class QPainter;
class QSize;
class QPolygonF;
 
class QgsDxfExport;
class QgsExpression;
class QgsRenderContext;
 
#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 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() == "RasterMarker" )
          sipType = sipType_QgsRasterMarkerSymbolLayer;
        else if ( sipCpp->layerType() == "VectorField" )
          sipType = sipType_QgsVectorFieldSymbolLayer;
        else if ( sipCpp->layerType() == "MaskMarker" )
          sipType = sipType_QgsMaskMarkerSymbolLayer;
        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 if ( sipCpp->layerType() == "RandomMarkerFill" )
          sipType = sipType_QgsRandomMarkerFillSymbolLayer;
        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, 
      PropertyAverageAngleLength, 
      PropertyHorizontalAnchor, 
      PropertyVerticalAnchor, 
      PropertyLayerEnabled, 
      PropertyArrowWidth, 
      PropertyArrowStartWidth, 
      PropertyArrowHeadLength, 
      PropertyArrowHeadThickness, 
      PropertyArrowHeadType, 
      PropertyArrowType, 
      PropertyOffsetX, 
      PropertyOffsetY, 
      PropertyPointCount, 
      PropertyRandomSeed, 
      PropertyClipPoints, 
      PropertyDensityArea, 
      PropertyFontFamily, 
      PropertyFontStyle, 
      PropertyDashPatternOffset, 
    };
 
    static const QgsPropertiesDefinition &propertyDefinitions();
 
    virtual ~QgsSymbolLayer();
 
    QgsSymbolLayer( const QgsSymbolLayer &other ) = delete;
 
    QgsSymbolLayer &operator=( const QgsSymbolLayer &other ) = delete;
 
    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 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 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(); }
 
    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 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; }
 
    virtual bool hasDataDefinedProperties() const;
 
    virtual QgsSymbolLayerReferenceList masks() const;
 
  protected:
 
    QgsSymbolLayer( QgsSymbol::SymbolType type, bool locked = false );
 
    QgsSymbol::SymbolType mType;
 
    bool mEnabled = true;
 
    bool mLocked = false;
    QColor mColor;
    int mRenderingPass = 0;
 
    QgsPropertyCollection mDataDefinedProperties;
 
    std::unique_ptr< QgsPaintEffect > mPaintEffect;
    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;
 
#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( 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 );
 
#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( 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;
 
    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( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mWidthUnit = unit; }
 
    QgsUnitTypes::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;
    QgsUnitTypes::RenderUnit mWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mWidthMapUnitScale;
    double mOffset = 0;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    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; }
 
  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