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 QGSRENDERER_H
#define QGSRENDERER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
#include "qgsrectangle.h"
#include "qgsfields.h"
#include "qgsfeaturerequest.h"
#include "qgsconfig.h"
#include "qgspropertycollection.h"
 
#include <QList>
#include <QString>
#include <QVariant>
#include <QPair>
#include <QPixmap>
#include <QDomDocument>
#include <QDomElement>
 
class QgsFeature;
class QgsVectorLayer;
class QgsPaintEffect;
class QgsReadWriteContext;
class QgsStyleEntityVisitorInterface;
class QgsRenderContext;
class QgsLayerTreeModelLegendNode;
class QgsLayerTreeLayer;
class QgsSldExportContext;
 
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 )
    {}
    QgsSymbolLevelItem( QgsSymbol *symbol, int layer ) {…}
 
    QgsSymbol *symbol() const;
 
    int layer() const;
 
    // TODO QGIS 4.0 -> make private
  protected:
    QgsSymbol *mSymbol = nullptr;
    int mLayer;
};
class CORE_EXPORT QgsSymbolLevelItem {…};
 
// 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
 
    const QString type = sipCpp->type();
 
    if ( type == QLatin1String( "singleSymbol" ) )
      sipType = sipType_QgsSingleSymbolRenderer;
    else if ( type == QLatin1String( "categorizedSymbol" ) )
      sipType = sipType_QgsCategorizedSymbolRenderer;
    else if ( type == QLatin1String( "graduatedSymbol" ) )
      sipType = sipType_QgsGraduatedSymbolRenderer;
    else if ( type == QLatin1String( "RuleRenderer" ) )
      sipType = sipType_QgsRuleBasedRenderer;
    else if ( type == QLatin1String( "heatmapRenderer" ) )
      sipType = sipType_QgsHeatmapRenderer;
    else if ( type == QLatin1String( "invertedPolygonRenderer" ) )
      sipType = sipType_QgsInvertedPolygonRenderer;
    else if ( type == QLatin1String( "pointCluster" ) )
      sipType = sipType_QgsPointClusterRenderer;
    else if ( type == QLatin1String( "pointDisplacement" ) )
      sipType = sipType_QgsPointDisplacementRenderer;
    else if ( type == QLatin1String( "25dRenderer" ) )
      sipType = sipType_Qgs25DRenderer;
    else if ( type == QLatin1String( "nullSymbol" ) )
      sipType = sipType_QgsNullSymbolRenderer;
    else if ( type == QLatin1String( "embeddedSymbol" ) )
      sipType = sipType_QgsEmbeddedSymbolRenderer;
    else
      sipType = 0;
    SIP_END
#endif
 
  public:
 
    enum class Property : int
    {
      HeatmapRadius, 
      HeatmapMaximum, 
    };
    enum class Property : int {…};
 
    static const QgsPropertiesDefinition &propertyDefinitions();
 
    // renderer takes ownership of its symbols!
 
    static QgsFeatureRenderer *defaultRenderer( Qgis::GeometryType geomType ) SIP_FACTORY;
 
    QString type() const { return mType; }
 
    virtual QgsSymbol *symbolForFeature( const QgsFeature &feature, QgsRenderContext &context ) const = 0;
 
    virtual QgsSymbol *originalSymbolForFeature( const QgsFeature &feature, QgsRenderContext &context ) const;
 
    virtual QSet< QString > legendKeysForFeature( const QgsFeature &feature, QgsRenderContext &context ) const;
 
    virtual void startRender( QgsRenderContext &context, const QgsFields &fields );
 
    virtual void stopRender( QgsRenderContext &context );
 
    virtual bool canSkipRender();
 
    virtual QString filter( const QgsFields &fields = QgsFields() ) { Q_UNUSED( fields ) return QString(); }
 
    virtual QSet<QString> usedAttributes( const QgsRenderContext &context ) const = 0;
 
    virtual bool usesEmbeddedSymbols() const;
 
    virtual bool filterNeedsGeometry() const;
 
    virtual ~QgsFeatureRenderer();
 
    virtual QgsFeatureRenderer *clone() const = 0 SIP_FACTORY;
 
    virtual bool renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer = -1, bool selected = false, bool drawVertexMarker = false ) SIP_THROW( QgsCsException );
 
    virtual QString dump() const;
 
    enum Capability SIP_ENUM_BASETYPE( IntFlag )
    {
      SymbolLevels          = 1,      
      MoreSymbolsPerFeature = 1 << 2, 
      Filter                = 1 << 3, 
      ScaleDependent        = 1 << 4  
    };
    enum Capability SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_DECLARE_FLAGS( Capabilities, Capability )
 
    
    virtual QgsFeatureRenderer::Capabilities capabilities() { return QgsFeatureRenderer::Capabilities(); }
 
    virtual Qgis::FeatureRendererFlags flags() const;
 
    virtual QgsSymbolList symbols( QgsRenderContext &context ) const;
 
    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 QVariantMap &props = QVariantMap() ) const;
 
    static QgsFeatureRenderer *loadSld( const QDomNode &node, Qgis::GeometryType geomType, QString &errorMessage ) SIP_FACTORY;
 
    Q_DECL_DEPRECATED virtual void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props = QVariantMap() ) const SIP_DEPRECATED;
 
    virtual bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const;
 
    QSet< QString > legendKeys() const;
 
    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 QString legendKeyToExpression( const QString &key, QgsVectorLayer *layer, bool &ok SIP_OUT ) const;
 
    virtual QgsLegendSymbolList legendSymbolItems() const;
 
    virtual QList<QgsLayerTreeModelLegendNode *> createLegendNodes( QgsLayerTreeLayer *nodeLayer ) const SIP_FACTORY;
 
    virtual QString legendClassificationAttribute() const { return QString(); }
 
    void setVertexMarkerAppearance( Qgis::VertexMarkerType type, double size );
 
    virtual bool willRenderFeature( const QgsFeature &feature, QgsRenderContext &context ) const;
 
    virtual QgsSymbolList symbolsForFeature( const QgsFeature &feature, QgsRenderContext &context ) const;
 
    virtual QgsSymbolList originalSymbolsForFeature( const QgsFeature &feature, QgsRenderContext &context ) const;
 
    virtual void modifyRequestExtent( QgsRectangle &extent, QgsRenderContext &context );
 
    QgsPaintEffect *paintEffect() const;
 
    void setPaintEffect( QgsPaintEffect *effect SIP_TRANSFER );
 
    bool forceRasterRender() const { return mForceRaster; }
 
    void setForceRasterRender( bool forceRaster ) { mForceRaster = forceRaster; }
 
    void setDataDefinedProperty( Property key, const QgsProperty &property );
 
    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }
 
    const QgsPropertyCollection &dataDefinedProperties() const SIP_SKIP { return mDataDefinedProperties; }
 
    void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }
 
    double referenceScale() const { return mReferenceScale; }
 
    void setReferenceScale( double scale ) { mReferenceScale = scale; }
 
    QgsFeatureRequest::OrderBy orderBy() const;
 
    void setOrderBy( const QgsFeatureRequest::OrderBy &orderBy );
 
    bool orderByEnabled() const;
 
    void setOrderByEnabled( bool enabled );
 
    virtual void setEmbeddedRenderer( QgsFeatureRenderer *subRenderer SIP_TRANSFER );
 
    virtual const QgsFeatureRenderer *embeddedRenderer() const;
 
    virtual bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
    void copyRendererData( QgsFeatureRenderer *destRenderer ) const;
 
    double maximumExtentBuffer( QgsRenderContext &context ) const;
 
  protected:
    QgsFeatureRenderer( const QString &type );
 
    void renderFeatureWithSymbol( const QgsFeature &feature, QgsSymbol *symbol, QgsRenderContext &context, int layer, bool selected, bool drawVertexMarker ) SIP_THROW( QgsCsException );
 
    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 saveRendererData( QDomDocument &doc, QDomElement &element, const QgsReadWriteContext &context );
 
    QString mType;
 
    bool mUsingSymbolLevels = false;
 
    Qgis::VertexMarkerType mCurrentVertexMarkerType = Qgis::VertexMarkerType::Cross;
 
    double mCurrentVertexMarkerSize = 2;
 
    std::unique_ptr<QgsPaintEffect> mPaintEffect;
 
    bool mForceRaster = false;
 
    double mReferenceScale = -1.0;
 
    static void convertSymbolSizeScale( QgsSymbol *symbol, Qgis::ScaleMethod method, const QString &field );
 
    static void convertSymbolRotation( QgsSymbol *symbol, const QString &field );
 
    QgsFeatureRequest::OrderBy mOrderBy;
 
    bool mOrderByEnabled = false;
 
  private:
#ifdef SIP_RUN
    QgsFeatureRenderer( const QgsFeatureRenderer & );
    QgsFeatureRenderer &operator=( const QgsFeatureRenderer & );
#endif
 
    static void initPropertyDefinitions();
    static QgsPropertiesDefinition sPropertyDefinitions;
 
#ifdef QGISDEBUG
    QThread *mThread = nullptr;
#endif
 
    QgsPropertyCollection mDataDefinedProperties;
 
    Q_DISABLE_COPY( QgsFeatureRenderer )
};
class CORE_EXPORT 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 // QGSRENDERER_H