qgsrenderer.h

Go to the documentation of this file.

/***************************************************************************
    qgsrenderer.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 QGSRENDERERV2_H
#define QGSRENDERERV2_H

#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
#include "qgsrectangle.h"
#include "qgsrendercontext.h"
#include "qgssymbol.h"
#include "qgsfields.h"
#include "qgsfeaturerequest.h"

#include <QList>
#include <QString>
#include <QVariant>
#include <QPair>
#include <QPixmap>
#include <QDomDocument>
#include <QDomElement>

class QgsFeature;
class QgsVectorLayer;
class QgsPaintEffect;
class QgsReadWriteContext;

typedef QMap<QString, QString> QgsStringMap SIP_SKIP;

typedef QList<QgsSymbol *> QgsSymbolList;
typedef QMap<QString, QgsSymbol * > QgsSymbolMap SIP_SKIP;

#include "qgslegendsymbolitem.h"


#define RENDERER_TAG_NAME   "renderer-v2"

// symbol levels

class CORE_EXPORT QgsSymbolLevelItem
{
  public:
    QgsSymbolLevelItem( QgsSymbol *symbol, int layer )
      : mSymbol( symbol )
      , mLayer( layer )
    {}
    QgsSymbol *symbol() { return mSymbol; }
    int layer() { return mLayer; }
  protected:
    QgsSymbol *mSymbol = nullptr;
    int mLayer;
};

// every level has list of items: symbol + symbol layer num
typedef QList< QgsSymbolLevelItem > QgsSymbolLevel;

// this is a list of levels
#ifndef SIP_RUN
typedef QList< QgsSymbolLevel > QgsSymbolLevelOrder;
#else
typedef QList< QList< QgsSymbolLevelItem > > QgsSymbolLevelOrder;
#endif


// renderers

class CORE_EXPORT QgsFeatureRenderer
{

#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == "singleSymbol" )
      sipType = sipType_QgsSingleSymbolRenderer;
    else if ( sipCpp->type() == "categorizedSymbol" )
      sipType = sipType_QgsCategorizedSymbolRenderer;
    else if ( sipCpp->type() == "graduatedSymbol" )
      sipType = sipType_QgsGraduatedSymbolRenderer;
    else if ( sipCpp->type() == "RuleRenderer" )
      sipType = sipType_QgsRuleBasedRenderer;
    else if ( sipCpp->type() == "heatmapRenderer" )
      sipType = sipType_QgsHeatmapRenderer;
    else if ( sipCpp->type() == "invertedPolygonRenderer" )
      sipType = sipType_QgsInvertedPolygonRenderer;
    else if ( sipCpp->type() == "pointCluster" )
      sipType = sipType_QgsPointClusterRenderer;
    else if ( sipCpp->type() == "pointDisplacement" )
      sipType = sipType_QgsPointDisplacementRenderer;
    else if ( sipCpp->type() == "25dRenderer" )
      sipType = sipType_Qgs25DRenderer;
    else if ( sipCpp->type() == "nullSymbol" )
      sipType = sipType_QgsNullSymbolRenderer;
    else
      sipType = 0;
    SIP_END
#endif

  public:
    // renderer takes ownership of its symbols!

    static QgsFeatureRenderer *defaultRenderer( QgsWkbTypes::GeometryType geomType ) SIP_FACTORY;

    QString type() const { return mType; }

    virtual QgsSymbol *symbolForFeature( QgsFeature &feature, QgsRenderContext &context ) = 0;

    virtual QgsSymbol *originalSymbolForFeature( QgsFeature &feature, QgsRenderContext &context );

    virtual QSet< QString > legendKeysForFeature( QgsFeature &feature, QgsRenderContext &context );

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

    virtual void stopRender( QgsRenderContext &context );

    virtual QString filter( const QgsFields &fields = QgsFields() ) { Q_UNUSED( fields ); return QString(); }

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

    virtual bool filterNeedsGeometry() const;

    virtual ~QgsFeatureRenderer();

    virtual QgsFeatureRenderer *clone() const = 0 SIP_FACTORY;

    virtual bool renderFeature( QgsFeature &feature, QgsRenderContext &context, int layer = -1, bool selected = false, bool drawVertexMarker = false );

    virtual QString dump() const;

    enum Capability
    {
      SymbolLevels          = 1,      
      MoreSymbolsPerFeature = 1 << 2, 
      Filter                = 1 << 3, 
      ScaleDependent        = 1 << 4  
    };

    Q_DECLARE_FLAGS( Capabilities, Capability )

    
    virtual QgsFeatureRenderer::Capabilities capabilities() { return nullptr; }

    virtual QgsSymbolList symbols( QgsRenderContext &context ) { Q_UNUSED( context ); return QgsSymbolList(); }

    bool usingSymbolLevels() const { return mUsingSymbolLevels; }
    void setUsingSymbolLevels( bool usingSymbolLevels ) { mUsingSymbolLevels = usingSymbolLevels; }

    static QgsFeatureRenderer *load( QDomElement &symbologyElem, const QgsReadWriteContext &context ) SIP_FACTORY;

    virtual QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context );

    virtual QDomElement writeSld( QDomDocument &doc, const QString &styleName, const QgsStringMap &props = QgsStringMap() ) const;

    static QgsFeatureRenderer *loadSld( const QDomNode &node, QgsWkbTypes::GeometryType geomType, QString &errorMessage ) SIP_FACTORY;

    virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap &props = QgsStringMap() ) const
    {
      element.appendChild( doc.createComment( QStringLiteral( "FeatureRendererV2 %1 not implemented yet" ).arg( type() ) ) );
      ( void ) props; // warning avoidance
    }

    virtual bool legendSymbolItemsCheckable() const;

    virtual bool legendSymbolItemChecked( const QString &key );

    virtual void checkLegendSymbolItem( const QString &key, bool state = true );

    virtual void setLegendSymbolItem( const QString &key, QgsSymbol *symbol SIP_TRANSFER );

    virtual QgsLegendSymbolList legendSymbolItems() const;

    virtual QString legendClassificationAttribute() const { return QString(); }

    void setVertexMarkerAppearance( int type, int size );

    virtual bool willRenderFeature( QgsFeature &feat, QgsRenderContext &context );

    virtual QgsSymbolList symbolsForFeature( QgsFeature &feat, QgsRenderContext &context );

    virtual QgsSymbolList originalSymbolsForFeature( QgsFeature &feat, QgsRenderContext &context );

    virtual void modifyRequestExtent( QgsRectangle &extent, QgsRenderContext &context ) { Q_UNUSED( extent ); Q_UNUSED( context ); }

    QgsPaintEffect *paintEffect() const;

    void setPaintEffect( QgsPaintEffect *effect );

    bool forceRasterRender() const { return mForceRaster; }

    void setForceRasterRender( bool forceRaster ) { mForceRaster = forceRaster; }

    QgsFeatureRequest::OrderBy orderBy() const;

    void setOrderBy( const QgsFeatureRequest::OrderBy &orderBy );

    bool orderByEnabled() const;

    void setOrderByEnabled( bool enabled );

    virtual void setEmbeddedRenderer( QgsFeatureRenderer *subRenderer SIP_TRANSFER ) { delete subRenderer; }

    virtual const QgsFeatureRenderer *embeddedRenderer() const { return nullptr; }

  protected:
    QgsFeatureRenderer( const QString &type );

    void renderFeatureWithSymbol( QgsFeature &feature,
                                  QgsSymbol *symbol,
                                  QgsRenderContext &context,
                                  int layer,
                                  bool selected,
                                  bool drawVertexMarker );

    void renderVertexMarker( QPointF pt, QgsRenderContext &context );
    void renderVertexMarkerPolyline( QPolygonF &pts, QgsRenderContext &context );
    void renderVertexMarkerPolygon( QPolygonF &pts, QList<QPolygonF> *rings, QgsRenderContext &context );

    static QPointF _getPoint( QgsRenderContext &context, const QgsPoint &point );

    void copyRendererData( QgsFeatureRenderer *destRenderer ) const;

    QString mType;

    bool mUsingSymbolLevels;

    int mCurrentVertexMarkerType;
    int mCurrentVertexMarkerSize;

    QgsPaintEffect *mPaintEffect = nullptr;

    bool mForceRaster;

    static void convertSymbolSizeScale( QgsSymbol *symbol, QgsSymbol::ScaleMethod method, const QString &field );

    static void convertSymbolRotation( QgsSymbol *symbol, const QString &field );

    QgsFeatureRequest::OrderBy mOrderBy;

    bool mOrderByEnabled;

  private:
#ifdef SIP_RUN
    QgsFeatureRenderer( const QgsFeatureRenderer & );
    QgsFeatureRenderer &operator=( const QgsFeatureRenderer & );
#endif

#ifdef QGISDEBUG
    QThread *mThread = nullptr;
#endif

    Q_DISABLE_COPY( QgsFeatureRenderer )
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsFeatureRenderer::Capabilities )

// for some reason SIP compilation fails if these lines are not included:
class QgsRendererWidget;
class QgsPaintEffectWidget;

#endif // QGSRENDERERV2_H