qgsrulebasedrenderer.h

Go to the documentation of this file.

/***************************************************************************
    qgsrulebasedrenderer.h - Rule-based renderer (symbology)
    ---------------------
    begin                : May 2010
    copyright            : (C) 2010 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 QGSRULEBASEDRENDERER_H
#define QGSRULEBASEDRENDERER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfields.h"
#include "qgsfeature.h"
#include "qgis.h"
 
#include "qgsrenderer.h"
#include "qgsrendercontext.h"
 
class QgsExpression;
 
class QgsCategorizedSymbolRenderer;
class QgsGraduatedSymbolRenderer;
 
class CORE_EXPORT QgsRuleBasedRenderer : public QgsFeatureRenderer
{
  public:
    // TODO: use QVarLengthArray instead of QList
 
    enum FeatureFlags
    {
      FeatIsSelected = 1,
      FeatDrawMarkers = 2
    };
 
    struct FeatureToRender
    {
      FeatureToRender( const QgsFeature &_f, int _flags )
        : feat( _f )
        , flags( _flags )
      {}
      QgsFeature feat;
      int flags; // selected and/or draw markers
    };
 
    struct RenderJob
    {
        RenderJob( QgsRuleBasedRenderer::FeatureToRender &_ftr, QgsSymbol *_s )
          : ftr( _ftr )
          , symbol( _s )
        {}
 
        QgsRuleBasedRenderer::FeatureToRender &ftr;
 
        QgsSymbol *symbol = nullptr;
 
      private:
#ifdef SIP_RUN
        RenderJob &operator=( const RenderJob & );
#endif
    };
 
    struct RenderLevel
    {
      explicit RenderLevel( int z )
        : zIndex( z )
      {}
 
      ~RenderLevel() { qDeleteAll( jobs ); }
      int zIndex;
 
      QList<QgsRuleBasedRenderer::RenderJob *> jobs;
 
      QgsRuleBasedRenderer::RenderLevel &operator=( const QgsRuleBasedRenderer::RenderLevel &rh )
      {
        zIndex = rh.zIndex;
        qDeleteAll( jobs );
        jobs.clear();
        for ( auto it = rh.jobs.constBegin(); it != rh.jobs.constEnd(); ++it )
        {
          jobs << new RenderJob( *( *it ) );
        }
        return *this;
      }
 
      RenderLevel( const QgsRuleBasedRenderer::RenderLevel &other )
        : zIndex( other.zIndex ), jobs()
      {
        for ( auto it = other.jobs.constBegin(); it != other.jobs.constEnd(); ++it )
        {
          jobs << new RenderJob( * ( *it ) );
        }
      }
 
    };
 
    typedef QList<QgsRuleBasedRenderer::RenderLevel> RenderQueue;
 
    class Rule;
    typedef QList<QgsRuleBasedRenderer::Rule *> RuleList;
 
    class CORE_EXPORT Rule
    {
      public:
        enum RenderResult
        {
          Filtered = 0, 
          Inactive,     
          Rendered      
        };
 
        Rule( QgsSymbol *symbol SIP_TRANSFER, int maximumScale = 0, int minimumScale = 0, const QString &filterExp = QString(),
              const QString &label = QString(), const QString &description = QString(), bool elseRule = false );
        ~Rule();
 
        Rule( const Rule &rh ) = delete;
        Rule &operator=( const Rule &rh ) = delete;
 
        QString dump( int indent = 0 ) const;
 
        QSet<QString> usedAttributes( const QgsRenderContext &context ) const;
 
        bool needsGeometry() const;
 
        QgsSymbolList symbols( const QgsRenderContext &context = QgsRenderContext() ) const;
 
        QgsLegendSymbolList legendSymbolItems( int currentLevel = -1 ) const;
 
        bool isFilterOK( const QgsFeature &f, QgsRenderContext *context = nullptr ) const;
 
        bool isScaleOK( double scale ) const;
 
        QgsSymbol *symbol() { return mSymbol.get(); }
        QString label() const { return mLabel; }
        bool dependsOnScale() const { return mMaximumScale != 0 || mMinimumScale != 0; }
 
        double maximumScale() const { return mMaximumScale; }
 
        double minimumScale() const { return mMinimumScale; }
 
        QgsExpression *filter() const { return mFilter.get(); }
 
        QString filterExpression() const { return mFilterExp; }
 
        QString description() const { return mDescription; }
 
        bool active() const { return mIsActive; }
 
        QString ruleKey() const { return mRuleKey; }
 
        void setRuleKey( const QString &key ) { mRuleKey = key; }
 
        void setSymbol( QgsSymbol *sym SIP_TRANSFER );
        void setLabel( const QString &label ) { mLabel = label; }
 
        void setMinimumScale( double scale ) { mMinimumScale = scale; }
 
        void setMaximumScale( double scale ) { mMaximumScale = scale; }
 
        void setFilterExpression( const QString &filterExp );
 
        void setDescription( const QString &description ) { mDescription = description; }
 
        void setActive( bool state ) { mIsActive = state; }
 
        QgsRuleBasedRenderer::Rule *clone() const SIP_FACTORY;
 
        void toSld( QDomDocument &doc, QDomElement &element, QVariantMap props ) const;
 
        static QgsRuleBasedRenderer::Rule *createFromSld( QDomElement &element, QgsWkbTypes::GeometryType geomType ) SIP_FACTORY;
 
        QDomElement save( QDomDocument &doc, QgsSymbolMap &symbolMap ) const;
 
        bool startRender( QgsRenderContext &context, const QgsFields &fields, QString &filter );
 
        QSet<int> collectZLevels();
 
        void setNormZLevels( const QMap<int, int> &zLevelsToNormLevels ) SIP_SKIP;
 
        QgsRuleBasedRenderer::Rule::RenderResult renderFeature( QgsRuleBasedRenderer::FeatureToRender &featToRender, QgsRenderContext &context, QgsRuleBasedRenderer::RenderQueue &renderQueue );
 
        bool willRenderFeature( const QgsFeature &feature, QgsRenderContext *context = nullptr );
 
        QgsSymbolList symbolsForFeature( const QgsFeature &feature, QgsRenderContext *context = nullptr );
 
        QSet< QString > legendKeysForFeature( const QgsFeature &feature, QgsRenderContext *context = nullptr );
 
        QgsRuleBasedRenderer::RuleList rulesForFeature( const QgsFeature &feature, QgsRenderContext *context = nullptr, bool onlyActive = true );
 
        void stopRender( QgsRenderContext &context );
 
        static QgsRuleBasedRenderer::Rule *create( QDomElement &ruleElem, QgsSymbolMap &symbolMap ) SIP_FACTORY;
 
        const QgsRuleBasedRenderer::RuleList &children() { return mChildren; }
 
        QgsRuleBasedRenderer::RuleList descendants() const;
 
        QgsRuleBasedRenderer::Rule *parent() { return mParent; }
 
        void appendChild( QgsRuleBasedRenderer::Rule *rule SIP_TRANSFER );
 
        void insertChild( int i, QgsRuleBasedRenderer::Rule *rule SIP_TRANSFER );
 
        void removeChild( QgsRuleBasedRenderer::Rule *rule );
 
        void removeChildAt( int i );
 
        QgsRuleBasedRenderer::Rule *takeChild( QgsRuleBasedRenderer::Rule *rule ) SIP_TRANSFERBACK;
 
        QgsRuleBasedRenderer::Rule *takeChildAt( int i ) SIP_TRANSFERBACK;
 
        QgsRuleBasedRenderer::Rule *findRuleByKey( const QString &key );
 
        void setIsElse( bool iselse );
 
        bool isElse() const { return mElseRule; }
 
        bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
      protected:
        void initFilter();
 
      private:
#ifdef SIP_RUN
        Rule( const QgsRuleBasedRenderer::Rule &rh );
#endif
 
        Rule *mParent = nullptr; // parent rule (nullptr only for root rule)
        std::unique_ptr< QgsSymbol > mSymbol;
        double mMaximumScale = 0;
        double mMinimumScale = 0;
        QString mFilterExp, mLabel, mDescription;
        bool mElseRule = false;
        RuleList mChildren;
        RuleList mElseRules;
        bool mIsActive = true; // whether it is enabled or not
 
        QString mRuleKey; // string used for unique identification of rule within renderer
 
        // temporary
        std::unique_ptr< QgsExpression > mFilter;
        // temporary while rendering
        QSet<int> mSymbolNormZLevels;
        RuleList mActiveChildren;
 
        void updateElseRules();
    };
 
 
    static QgsFeatureRenderer *create( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
 
    QgsRuleBasedRenderer( QgsRuleBasedRenderer::Rule *root SIP_TRANSFER );
    QgsRuleBasedRenderer( QgsSymbol *defaultSymbol SIP_TRANSFER );
 
    ~QgsRuleBasedRenderer() override;
 
    QgsSymbol *symbolForFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
 
    bool renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer = -1, bool selected = false, bool drawVertexMarker = false ) override SIP_THROW( QgsCsException );
 
    void startRender( QgsRenderContext &context, const QgsFields &fields ) override;
 
    void stopRender( QgsRenderContext &context ) override;
 
    QString filter( const QgsFields &fields = QgsFields() ) override;
 
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
 
    bool filterNeedsGeometry() const override;
 
    QgsRuleBasedRenderer *clone() const override SIP_FACTORY;
 
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props = QVariantMap() ) const override;
 
    static QgsFeatureRenderer *createFromSld( QDomElement &element, QgsWkbTypes::GeometryType geomType ) SIP_FACTORY;
 
    QgsSymbolList symbols( QgsRenderContext &context ) const override;
 
    QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) override;
    bool legendSymbolItemsCheckable() const override;
    bool legendSymbolItemChecked( const QString &key ) override;
    void checkLegendSymbolItem( const QString &key, bool state = true ) override;
 
    void setLegendSymbolItem( const QString &key, QgsSymbol *symbol SIP_TRANSFER ) override;
    QgsLegendSymbolList legendSymbolItems() const override;
    QString dump() const override;
    bool willRenderFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
    QgsSymbolList symbolsForFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
    QgsSymbolList originalSymbolsForFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
    QSet<QString> legendKeysForFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
    QgsFeatureRenderer::Capabilities capabilities() override { return MoreSymbolsPerFeature | Filter | ScaleDependent; }
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
 
 
    QgsRuleBasedRenderer::Rule *rootRule() { return mRootRule; }
 
 
    static void refineRuleCategories( QgsRuleBasedRenderer::Rule *initialRule, QgsCategorizedSymbolRenderer *r );
    static void refineRuleRanges( QgsRuleBasedRenderer::Rule *initialRule, QgsGraduatedSymbolRenderer *r );
    static void refineRuleScales( QgsRuleBasedRenderer::Rule *initialRule, QList<int> scales );
 
    static QgsRuleBasedRenderer *convertFromRenderer( const QgsFeatureRenderer *renderer, QgsVectorLayer *layer = nullptr ) SIP_FACTORY;
 
    static void convertToDataDefinedSymbology( QgsSymbol *symbol, const QString &sizeScaleField, const QString &rotationField = QString() );
 
  protected:
    Rule *mRootRule = nullptr;
 
    // temporary
    RenderQueue mRenderQueue;
    QList<FeatureToRender> mCurrentFeatures;
 
    QString mFilter;
 
  private:
#ifdef SIP_RUN
    QgsRuleBasedRenderer( const QgsRuleBasedRenderer & );
    QgsRuleBasedRenderer &operator=( const QgsRuleBasedRenderer & );
#endif
};
 
#endif // QGSRULEBASEDRENDERER_H