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 "qgsconfig.h"
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfeaturerequest.h"
#include "qgsfields.h"
#include "qgspropertycollection.h"
#include "qgsrectangle.h"
 
#include <QDomDocument>
#include <QDomElement>
#include <QList>
#include <QPair>
#include <QPixmap>
#include <QString>
#include <QVariant>
 
using namespace Qt::StringLiterals;
 
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 )
    {}

    QgsSymbol *symbol() const;

    int layer() const;
 
    // TODO QGIS 5.0 -> make private
  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
 
    const QString type = sipCpp->type();
 
    if ( type == "singleSymbol"_L1 )
      sipType = sipType_QgsSingleSymbolRenderer;
    else if ( type == "categorizedSymbol"_L1 )
      sipType = sipType_QgsCategorizedSymbolRenderer;
    else if ( type == "graduatedSymbol"_L1 )
      sipType = sipType_QgsGraduatedSymbolRenderer;
    else if ( type == "RuleRenderer"_L1 )
      sipType = sipType_QgsRuleBasedRenderer;
    else if ( type == "heatmapRenderer"_L1 )
      sipType = sipType_QgsHeatmapRenderer;
    else if ( type == "mergedFeatureRenderer"_L1 )
      sipType = sipType_QgsMergedFeatureRenderer;
    else if ( type == "invertedPolygonRenderer"_L1 )
      sipType = sipType_QgsInvertedPolygonRenderer;
    else if ( type == "pointCluster"_L1 )
      sipType = sipType_QgsPointClusterRenderer;
    else if ( type == "pointDisplacement"_L1 )
      sipType = sipType_QgsPointDisplacementRenderer;
    else if ( type == "25dRenderer"_L1 )
      sipType = sipType_Qgs25DRenderer;
    else if ( type == "nullSymbol"_L1 )
      sipType = sipType_QgsNullSymbolRenderer;
    else if ( type == "embeddedSymbol"_L1 )
      sipType = sipType_QgsEmbeddedSymbolRenderer;
    else
      sipType = 0;
  SIP_END
#endif
 
  public:

    enum class Property : int
    {
      HeatmapRadius,  
      HeatmapMaximum, 
    };

    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         
    };
 
    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 )
};
 
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