qgssymbol.h

Go to the documentation of this file.

/***************************************************************************
 qgssymbol.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 QGSSYMBOL_H
#define QGSSYMBOL_H

#include "qgis_core.h"
#include "qgis.h"
#include <QList>
#include <QMap>
#include "qgsmapunitscale.h"
#include "qgsfields.h"
#include "qgsrendercontext.h"
#include "qgsproperty.h"

class QColor;
class QImage;
class QPainter;
class QSize;
class QPointF;
class QPolygonF;
class QDomDocument;
class QDomElement;

class QgsFields;
class QgsSymbolLayer;
class QgsRenderContext;
class QgsVectorLayer;
class QgsPaintEffect;
class QgsMarkerSymbolLayer;
class QgsLineSymbolLayer;
class QgsFillSymbolLayer;
class QgsSymbolRenderContext;
class QgsFeature;
class QgsFeatureRenderer;
class QgsCurve;
class QgsPolygon;
class QgsExpressionContext;
class QgsPoint;

typedef QList<QgsSymbolLayer *> QgsSymbolLayerList;

class CORE_EXPORT QgsSymbol
{

#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    switch ( sipCpp->type() )
    {
      case QgsSymbol::Marker: sipType = sipType_QgsMarkerSymbol; break;
      case QgsSymbol::Line: sipType = sipType_QgsLineSymbol; break;
      case QgsSymbol::Fill: sipType = sipType_QgsFillSymbol; break;
      default: sipType = 0; break;
    }
    SIP_END
#endif

    friend class QgsFeatureRenderer;

  public:

    enum SymbolType
    {
      Marker, 
      Line,   
      Fill,   
      Hybrid  
    };

    enum ScaleMethod
    {
      ScaleArea,     
      ScaleDiameter  
    };


    enum RenderHint
    {
      DynamicRotation = 2, 
    };
    Q_DECLARE_FLAGS( RenderHints, RenderHint )

    virtual ~QgsSymbol();

    static QgsSymbol *defaultSymbol( QgsWkbTypes::GeometryType geomType ) SIP_FACTORY;

    SymbolType type() const { return mType; }

    // symbol layers handling

    QgsSymbolLayerList symbolLayers() { return mLayers; }

    QgsSymbolLayer *symbolLayer( int layer );

    int symbolLayerCount() const { return mLayers.count(); }

    bool insertSymbolLayer( int index, QgsSymbolLayer *layer SIP_TRANSFER );

    bool appendSymbolLayer( QgsSymbolLayer *layer SIP_TRANSFER );

    bool deleteSymbolLayer( int index );

    QgsSymbolLayer *takeSymbolLayer( int index ) SIP_TRANSFERBACK;

    bool changeSymbolLayer( int index, QgsSymbolLayer *layer SIP_TRANSFER );

    void startRender( QgsRenderContext &context, const QgsFields &fields = QgsFields() );

    void stopRender( QgsRenderContext &context );

    void setColor( const QColor &color );

    QColor color() const;

    void drawPreviewIcon( QPainter *painter, QSize size, QgsRenderContext *customContext = nullptr );

    void exportImage( const QString &path, const QString &format, QSize size );

    QImage asImage( QSize size, QgsRenderContext *customContext = nullptr );

    QImage bigSymbolPreviewImage( QgsExpressionContext *expressionContext = nullptr );

    QString dump() const;

    virtual QgsSymbol *clone() const = 0 SIP_FACTORY;

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

    QgsUnitTypes::RenderUnit outputUnit() const;

    void setOutputUnit( QgsUnitTypes::RenderUnit unit );

    QgsMapUnitScale mapUnitScale() const;

    void setMapUnitScale( const QgsMapUnitScale &scale );

    qreal opacity() const { return mOpacity; }

    void setOpacity( qreal opacity ) { mOpacity = opacity; }

    void setRenderHints( RenderHints hints ) { mRenderHints = hints; }

    RenderHints renderHints() const { return mRenderHints; }

    void setClipFeaturesToExtent( bool clipFeaturesToExtent ) { mClipFeaturesToExtent = clipFeaturesToExtent; }

    bool clipFeaturesToExtent() const { return mClipFeaturesToExtent; }

    void setForceRHR( bool force ) { mForceRHR = force; }

    bool forceRHR() const { return mForceRHR; }

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const;

    bool hasDataDefinedProperties() const;

    Q_DECL_DEPRECATED void setLayer( const QgsVectorLayer *layer ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED const QgsVectorLayer *layer() const SIP_DEPRECATED;

    void renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer = -1, bool selected = false, bool drawVertexMarker = false, int currentVertexMarkerType = 0, double currentVertexMarkerSize = 0.0 ) SIP_THROW( QgsCsException );

    QgsSymbolRenderContext *symbolRenderContext();

  protected:
    QgsSymbol( SymbolType type, const QgsSymbolLayerList &layers SIP_TRANSFER ); // can't be instantiated

    static inline QPointF _getPoint( QgsRenderContext &context, const QgsPoint &point )
    {
      QPointF pt;
      if ( context.coordinateTransform().isValid() )
      {
        double x = point.x();
        double y = point.y();
        double z = 0.0;
        context.coordinateTransform().transformInPlace( x, y, z );
        pt = QPointF( x, y );

      }
      else
        pt = point.toQPointF();

      context.mapToPixel().transformInPlace( pt.rx(), pt.ry() );
      return pt;
    }

    static QPolygonF _getLineString( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent = true );

    static QPolygonF _getPolygonRing( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing = false, bool correctRingOrientation = false );

    static void _getPolygon( QPolygonF &pts, QList<QPolygonF> &holes, QgsRenderContext &context, const QgsPolygon &polygon, bool clipToExtent = true, bool correctRingOrientation = false );

    QgsSymbolLayerList cloneLayers() const SIP_FACTORY;

    void renderUsingLayer( QgsSymbolLayer *layer, QgsSymbolRenderContext &context );

    void renderVertexMarker( QPointF pt, QgsRenderContext &context, int currentVertexMarkerType, double currentVertexMarkerSize );

    SymbolType mType;
    QgsSymbolLayerList mLayers;

    qreal mOpacity = 1.0;

    RenderHints mRenderHints = nullptr;
    bool mClipFeaturesToExtent = true;
    bool mForceRHR = false;

    Q_DECL_DEPRECATED const QgsVectorLayer *mLayer = nullptr; //current vectorlayer

  private:
#ifdef SIP_RUN
    QgsSymbol( const QgsSymbol & );
#endif

    bool mStarted = false;

    std::unique_ptr< QgsSymbolRenderContext > mSymbolRenderContext;

    Q_DISABLE_COPY( QgsSymbol )

};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsSymbol::RenderHints )


class CORE_EXPORT QgsSymbolRenderContext
{
  public:

    QgsSymbolRenderContext( QgsRenderContext &c, QgsUnitTypes::RenderUnit u, qreal opacity = 1.0, bool selected = false, QgsSymbol::RenderHints renderHints = nullptr, const QgsFeature *f = nullptr, const QgsFields &fields = QgsFields(), const QgsMapUnitScale &mapUnitScale = QgsMapUnitScale() );

    QgsSymbolRenderContext( const QgsSymbolRenderContext &rh ) = delete;

    QgsRenderContext &renderContext() { return mRenderContext; }

    const QgsRenderContext &renderContext() const { return mRenderContext; } SIP_SKIP

    void setOriginalValueVariable( const QVariant &value );

    QgsUnitTypes::RenderUnit outputUnit() const { return mOutputUnit; }

    void setOutputUnit( QgsUnitTypes::RenderUnit u ) { mOutputUnit = u; }

    QgsMapUnitScale mapUnitScale() const { return mMapUnitScale; }
    void setMapUnitScale( const QgsMapUnitScale &scale ) { mMapUnitScale = scale; }

    qreal opacity() const { return mOpacity; }

    void setOpacity( qreal opacity ) { mOpacity = opacity; }

    bool selected() const { return mSelected; }
    void setSelected( bool selected ) { mSelected = selected; }

    QgsSymbol::RenderHints renderHints() const { return mRenderHints; }

    void setRenderHints( QgsSymbol::RenderHints hints ) { mRenderHints = hints; }

    void setFeature( const QgsFeature *f ) { mFeature = f; }
    const QgsFeature *feature() const { return mFeature; }

    void setOriginalGeometryType( QgsWkbTypes::GeometryType type ) { mOriginalGeometryType = type; }

    QgsWkbTypes::GeometryType originalGeometryType() const { return mOriginalGeometryType; }

    QgsFields fields() const { return mFields; }

    int geometryPartCount() const { return mGeometryPartCount; }

    void setGeometryPartCount( int count ) { mGeometryPartCount = count; }

    int geometryPartNum() const { return mGeometryPartNum; }

    void setGeometryPartNum( int num ) { mGeometryPartNum = num; }

    double outputLineWidth( double width ) const;
    double outputPixelSize( double size ) const;

    // workaround for sip 4.7. Don't use assignment - will fail with assertion error
    QgsSymbolRenderContext &operator=( const QgsSymbolRenderContext & );

    QgsExpressionContextScope *expressionContextScope();

    void setExpressionContextScope( QgsExpressionContextScope *contextScope SIP_TRANSFER );

  private:

#ifdef SIP_RUN
    QgsSymbolRenderContext( const QgsSymbolRenderContext &rh ) SIP_FORCE;
#endif

    QgsRenderContext &mRenderContext;
    std::unique_ptr< QgsExpressionContextScope > mExpressionContextScope;
    QgsUnitTypes::RenderUnit mOutputUnit;
    QgsMapUnitScale mMapUnitScale;
    qreal mOpacity = 1.0;
    bool mSelected;
    QgsSymbol::RenderHints mRenderHints;
    const QgsFeature *mFeature; //current feature
    QgsFields mFields;
    int mGeometryPartCount;
    int mGeometryPartNum;
    QgsWkbTypes::GeometryType mOriginalGeometryType = QgsWkbTypes::UnknownGeometry;
};





class CORE_EXPORT QgsMarkerSymbol : public QgsSymbol
{
  public:

    static QgsMarkerSymbol *createSimple( const QgsStringMap &properties ) SIP_FACTORY;

    QgsMarkerSymbol( const QgsSymbolLayerList &layers SIP_TRANSFER = QgsSymbolLayerList() );

    void setAngle( double symbolAngle );

    double angle() const;

    void setDataDefinedAngle( const QgsProperty &property );

    QgsProperty dataDefinedAngle() const;

    void setLineAngle( double lineAngle );

    void setSize( double size );

    double size() const;

    double size( const QgsRenderContext &context ) const;

    void setSizeUnit( QgsUnitTypes::RenderUnit unit );

    QgsUnitTypes::RenderUnit sizeUnit() const;

    void setSizeMapUnitScale( const QgsMapUnitScale &scale );

    QgsMapUnitScale sizeMapUnitScale() const;

    void setDataDefinedSize( const QgsProperty &property );

    QgsProperty dataDefinedSize() const;

    void setScaleMethod( QgsSymbol::ScaleMethod scaleMethod );
    ScaleMethod scaleMethod();

    void renderPoint( QPointF point, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );

    QRectF bounds( QPointF point, QgsRenderContext &context, const QgsFeature &feature = QgsFeature() ) const;

    QgsMarkerSymbol *clone() const override SIP_FACTORY;

  private:

    void renderPointUsingLayer( QgsMarkerSymbolLayer *layer, QPointF point, QgsSymbolRenderContext &context );

};


class CORE_EXPORT QgsLineSymbol : public QgsSymbol
{
  public:

    static QgsLineSymbol *createSimple( const QgsStringMap &properties ) SIP_FACTORY;

    QgsLineSymbol( const QgsSymbolLayerList &layers SIP_TRANSFER = QgsSymbolLayerList() );

    void setWidth( double width );

    double width() const;

    double width( const QgsRenderContext &context ) const;

    void setDataDefinedWidth( const QgsProperty &property );

    QgsProperty dataDefinedWidth() const;

    void renderPolyline( const QPolygonF &points, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );

    QgsLineSymbol *clone() const override SIP_FACTORY;

  private:

    void renderPolylineUsingLayer( QgsLineSymbolLayer *layer, const QPolygonF &points, QgsSymbolRenderContext &context );

};


class CORE_EXPORT QgsFillSymbol : public QgsSymbol
{
  public:

    static QgsFillSymbol *createSimple( const QgsStringMap &properties ) SIP_FACTORY;

    QgsFillSymbol( const QgsSymbolLayerList &layers SIP_TRANSFER = QgsSymbolLayerList() );
    void setAngle( double angle );
    void renderPolygon( const QPolygonF &points, QList<QPolygonF> *rings, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );

    QgsFillSymbol *clone() const override SIP_FACTORY;

  private:

    void renderPolygonUsingLayer( QgsSymbolLayer *layer, const QPolygonF &points, QList<QPolygonF> *rings, QgsSymbolRenderContext &context );
    QRectF polygonBounds( const QPolygonF &points, const QList<QPolygonF> *rings ) const;
    QList<QPolygonF> *translateRings( const QList<QPolygonF> *rings, double dx, double dy ) const;
};

#endif