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.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfeature.h"
#include "qgsfields.h"
#include "qgsrendercontext.h"
#include "qgsrenderer.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( const 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 )
        {
          if ( &rh == this )
            return *this;
 
          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(); }

        const QgsSymbol *symbol() const SIP_SKIP { 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; }

        std::unique_ptr<QgsRuleBasedRenderer::Rule> clone() const;

        Q_DECL_DEPRECATED void toSld( QDomDocument &doc, QDomElement &element, QVariantMap props ) const SIP_DEPRECATED;

        bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const;

        static std::unique_ptr<QgsRuleBasedRenderer::Rule> createFromSld( QDomElement &element, Qgis::GeometryType geomType );
 
        QDomElement save( QDomDocument &doc, QgsSymbolMap &symbolMap ) const;

        bool startRender( QgsRenderContext &context, const QgsFields &fields, QString &filter );

        bool hasActiveChildren() const;

        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 std::unique_ptr<QgsRuleBasedRenderer::Rule> create( QDomElement &ruleElem, QgsSymbolMap &symbolMap, bool reuseId = true, const QgsReadWriteContext &context = QgsReadWriteContext() );

        const QgsRuleBasedRenderer::RuleList &children() const { 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 std::unique_ptr<QgsFeatureRenderer> create( QDomElement &element, const QgsReadWriteContext &context );

    QgsRuleBasedRenderer( QgsRuleBasedRenderer::Rule *root SIP_TRANSFER );
    QgsRuleBasedRenderer( QgsSymbol *defaultSymbol SIP_TRANSFER );
 
    ~QgsRuleBasedRenderer() override;

    QgsSymbol *symbolForFeature( const QgsFeature &feature, QgsRenderContext &context ) const override;
 
    Qgis::FeatureRendererFlags flags() 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;
    bool canSkipRender() 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;
 
    Q_DECL_DEPRECATED void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props = QVariantMap() ) const override SIP_DEPRECATED;
    bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const override;

    static std::unique_ptr<QgsFeatureRenderer> createFromSld( QDomElement &element, Qgis::GeometryType geomType );
 
    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;
    QString legendKeyToExpression( const QString &key, QgsVectorLayer *layer, bool &ok ) const override;
 
    void setLegendSymbolItem( const QString &key, QgsSymbol *symbol SIP_TRANSFER ) override;
    void setLegendSymbolItemLabel( const QString &key, const QString &label ) 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.get(); }
 

    const QgsRuleBasedRenderer::Rule *rootRule() const SIP_SKIP { return mRootRule.get(); }


    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 std::unique_ptr<QgsRuleBasedRenderer> convertFromRenderer( const QgsFeatureRenderer *renderer, QgsVectorLayer *layer = nullptr );

    static void convertToDataDefinedSymbology( QgsSymbol *symbol, const QString &sizeScaleField, const QString &rotationField = QString() );
 
  protected:
    std::unique_ptr<Rule> mRootRule;
 
    // temporary
    RenderQueue mRenderQueue;
    QList<FeatureToRender> mCurrentFeatures;
 
    QString mFilter;
 
  private:
#ifdef SIP_RUN
    QgsRuleBasedRenderer( const QgsRuleBasedRenderer & );
    QgsRuleBasedRenderer &operator=( const QgsRuleBasedRenderer & );
#endif
};
 
#endif // QGSRULEBASEDRENDERER_H