qgssymbolv2.h

Go to the documentation of this file.

/***************************************************************************
 qgssymbolv2.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 QGSSYMBOLV2_H
#define QGSSYMBOLV2_H

#include "qgis.h"
#include <QList>
#include <QMap>
#include "qgsmapunitscale.h"
#include "qgsgeometry.h"
#include "qgspointv2.h"

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

class QDomDocument;
class QDomElement;
//class

class QgsFeature;
class QgsFields;
class QgsSymbolLayerV2;
class QgsRenderContext;
class QgsVectorLayer;
class QgsPaintEffect;
class QgsMarkerSymbolLayerV2;
class QgsLineSymbolLayerV2;
class QgsFillSymbolLayerV2;
class QgsDataDefined;
class QgsSymbolV2RenderContext;
class QgsFeatureRendererV2;

typedef QList<QgsSymbolLayerV2*> QgsSymbolLayerV2List;

class CORE_EXPORT QgsSymbolV2
{
    friend class QgsFeatureRendererV2;

  public:

    //TODO QGIS 3.0 - move to QgsUnitTypes and rename to SymbolUnit
    enum OutputUnit
    {
      MM = 0,     
      MapUnit,    
      Mixed,      
      Pixel,      
      Percentage,  
    };

    typedef QList<OutputUnit> OutputUnitList;

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

    enum ScaleMethod
    {
      ScaleArea,     
      ScaleDiameter  
    };

    enum RenderHint
    {
      DataDefinedSizeScale = 1,
      DataDefinedRotation = 2
    };

    virtual ~QgsSymbolV2();

    static QgsSymbolV2* defaultSymbol( QGis::GeometryType geomType );

    SymbolType type() const { return mType; }

    // symbol layers handling

    QgsSymbolLayerV2List symbolLayers() { return mLayers; }

    QgsSymbolLayerV2* symbolLayer( int layer );

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

    bool insertSymbolLayer( int index, QgsSymbolLayerV2* layer );

    bool appendSymbolLayer( QgsSymbolLayerV2* layer );

    bool deleteSymbolLayer( int index );

    QgsSymbolLayerV2* takeSymbolLayer( int index );

    bool changeSymbolLayer( int index, QgsSymbolLayerV2 *layer );

    void startRender( QgsRenderContext& context, const QgsFields* fields = nullptr );
    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 QgsSymbolV2* clone() const = 0;

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

    QgsSymbolV2::OutputUnit outputUnit() const;
    void setOutputUnit( QgsSymbolV2::OutputUnit u );

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

    qreal alpha() const { return mAlpha; }
    void setAlpha( qreal alpha ) { mAlpha = alpha; }

    void setRenderHints( int hints ) { mRenderHints = hints; }
    int renderHints() const { return mRenderHints; }

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

    bool clipFeaturesToExtent() const { return mClipFeaturesToExtent; }

    QSet<QString> usedAttributes() const;

    bool hasDataDefinedProperties() const;

    void setLayer( const QgsVectorLayer* layer ) { mLayer = layer; }
    const QgsVectorLayer* layer() const { return mLayer; }

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

    QgsSymbolV2RenderContext* symbolRenderContext();

  protected:
    QgsSymbolV2( SymbolType type, const QgsSymbolLayerV2List& layers ); // can't be instantiated

    static inline void _getPoint( QPointF& pt, QgsRenderContext& context, const QgsPointV2* point )
    {
      if ( context.coordinateTransform() )
      {
        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() );
    }

    static QgsConstWkbPtr _getPoint( QPointF& pt, QgsRenderContext& context, QgsConstWkbPtr wkb );

    static QgsConstWkbPtr _getLineString( QPolygonF& pts, QgsRenderContext& context, QgsConstWkbPtr wkb, bool clipToExtent = true );

    static QgsConstWkbPtr _getPolygon( QPolygonF& pts, QList<QPolygonF>& holes, QgsRenderContext& context, QgsConstWkbPtr wkb, bool clipToExtent = true );

    QgsSymbolLayerV2List cloneLayers() const;

    void renderUsingLayer( QgsSymbolLayerV2* layer, QgsSymbolV2RenderContext& context );

    Q_DECL_DEPRECATED bool isSymbolLayerCompatible( SymbolType layerType );

    SymbolType mType;
    QgsSymbolLayerV2List mLayers;

    qreal mAlpha;

    int mRenderHints;
    bool mClipFeaturesToExtent;

    const QgsVectorLayer* mLayer; //current vectorlayer

  private:
    QgsSymbolV2RenderContext* mSymbolRenderContext;

    Q_DISABLE_COPY( QgsSymbolV2 )

};


class CORE_EXPORT QgsSymbolV2RenderContext
{
  public:
    QgsSymbolV2RenderContext( QgsRenderContext& c, QgsSymbolV2::OutputUnit u, qreal alpha = 1.0, bool selected = false, int renderHints = 0, const QgsFeature* f = nullptr, const QgsFields* fields = nullptr, const QgsMapUnitScale& mapUnitScale = QgsMapUnitScale() );
    ~QgsSymbolV2RenderContext();

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

    void setOriginalValueVariable( const QVariant& value );

    QgsSymbolV2::OutputUnit outputUnit() const { return mOutputUnit; }
    void setOutputUnit( QgsSymbolV2::OutputUnit u ) { mOutputUnit = u; }

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

    qreal alpha() const { return mAlpha; }
    void setAlpha( qreal alpha ) { mAlpha = alpha; }

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

    int renderHints() const { return mRenderHints; }
    void setRenderHints( int hints ) { mRenderHints = hints; }

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

    const QgsFields* fields() const { return mFields; }

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

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

    QgsExpressionContextScope* expressionContextScope();
    void setExpressionContextScope( QgsExpressionContextScope* contextScope );

  private:
    QgsRenderContext& mRenderContext;
    QgsExpressionContextScope* mExpressionContextScope;
    QgsSymbolV2::OutputUnit mOutputUnit;
    QgsMapUnitScale mMapUnitScale;
    qreal mAlpha;
    bool mSelected;
    int mRenderHints;
    const QgsFeature* mFeature; //current feature
    const QgsFields* mFields;


    QgsSymbolV2RenderContext( const QgsSymbolV2RenderContext& rh );
};






class CORE_EXPORT QgsMarkerSymbolV2 : public QgsSymbolV2
{
  public:

    static QgsMarkerSymbolV2* createSimple( const QgsStringMap& properties );

    QgsMarkerSymbolV2( const QgsSymbolLayerV2List& layers = QgsSymbolLayerV2List() );

    void setAngle( double angle );

    double angle() const;

    void setDataDefinedAngle( const QgsDataDefined& dd );

    QgsDataDefined dataDefinedAngle() const;

    void setLineAngle( double lineAngle );

    void setSize( double size );

    double size() const;

    void setSizeUnit( OutputUnit unit );

    OutputUnit sizeUnit() const;

    void setSizeMapUnitScale( const QgsMapUnitScale& scale );

    QgsMapUnitScale sizeMapUnitScale() const;

    void setDataDefinedSize( const QgsDataDefined& dd );

    QgsDataDefined dataDefinedSize() const;

    void setScaleMethod( QgsSymbolV2::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;

    virtual QgsMarkerSymbolV2* clone() const override;

  private:

    void renderPointUsingLayer( QgsMarkerSymbolLayerV2* layer, QPointF point, QgsSymbolV2RenderContext& context );

};



class CORE_EXPORT QgsLineSymbolV2 : public QgsSymbolV2
{
  public:
    static QgsLineSymbolV2* createSimple( const QgsStringMap& properties );

    QgsLineSymbolV2( const QgsSymbolLayerV2List& layers = QgsSymbolLayerV2List() );

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

    void setDataDefinedWidth( const QgsDataDefined& dd );

    QgsDataDefined dataDefinedWidth() const;

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

    virtual QgsLineSymbolV2* clone() const override;

  private:

    void renderPolylineUsingLayer( QgsLineSymbolLayerV2* layer, const QPolygonF& points, QgsSymbolV2RenderContext& context );

};



class CORE_EXPORT QgsFillSymbolV2 : public QgsSymbolV2
{
  public:
    static QgsFillSymbolV2* createSimple( const QgsStringMap& properties );

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

    virtual QgsFillSymbolV2* clone() const override;

  private:

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

#endif


/*

QgsSymbolV2* ps = new QgsPointSymbol();

// ----

sl = QgsSymbolLayerV2Registry::instance()->createSymbolLayer("SimpleLine", { "color", "..." })

// (or)

sl = QgsSymbolLayerV2Registry::defaultSymbolLayer(QgsSymbolV2::Line)

// (or)

QgsSymbolLayerV2* sl = new QgsSimpleLineSymbolLayer(x,y,z);
QgsLineSymbol* s = new LineSymbol( [ sl ] );

// ----

rend = QgsSingleSymbolRenderer( new LineSymbol() );
*/