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 QGSRULEBASEDRENDERERV2_H
#define QGSRULEBASEDRENDERERV2_H

#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfields.h"
#include "qgsfeature.h"
#include "qgis.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
    };

    // feature for rendering: QgsFeature and some flags
    struct FeatureToRender
    {
      FeatureToRender( QgsFeature &_f, int _flags )
        : feat( _f )
        , flags( _flags )
      {}
      QgsFeature feat;
      int flags; // selected and/or draw markers
    };

    // rendering job: a feature to be rendered with a particular symbol
    // (both f, symbol are _not_ owned by this class)
    struct RenderJob
    {
      RenderJob( QgsRuleBasedRenderer::FeatureToRender &_ftr, QgsSymbol *_s )
        : ftr( _ftr )
        , symbol( _s )
      {}
      QgsRuleBasedRenderer::FeatureToRender &ftr;
      QgsSymbol *symbol = nullptr;
    };

    // render level: a list of jobs to be drawn at particular level
    // (jobs are owned by this class)
    struct RenderLevel
    {
      explicit RenderLevel( int z ): zIndex( z ) {}
      ~RenderLevel() { Q_FOREACH ( RenderJob *j, jobs ) delete j; }
      int zIndex;
      QList<QgsRuleBasedRenderer::RenderJob *> jobs;

      QgsRuleBasedRenderer::RenderLevel &operator=( const QgsRuleBasedRenderer::RenderLevel &rh )
      {
        zIndex = rh.zIndex;
        qDeleteAll( jobs );
        jobs.clear();
        Q_FOREACH ( RenderJob *job, rh.jobs )
        {
          jobs << new RenderJob( *job );
        }
        return *this;
      }

      RenderLevel( const QgsRuleBasedRenderer::RenderLevel &other )
        : zIndex( other.zIndex )
      {
        Q_FOREACH ( RenderJob *job, other.jobs )
        {
          jobs << new RenderJob( *job );
        }
      }

    };

    // rendering queue: a list of rendering levels
    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( QgsFeature &f, QgsRenderContext *context = nullptr ) const;

        bool isScaleOK( double scale ) const;

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

        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, QgsStringMap 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( QgsFeature &feat, QgsRenderContext *context = nullptr );

        QgsSymbolList symbolsForFeature( QgsFeature &feat, QgsRenderContext *context = nullptr );

        QSet< QString > legendKeysForFeature( QgsFeature &feat, QgsRenderContext *context = nullptr );

        QgsRuleBasedRenderer::RuleList rulesForFeature( QgsFeature &feat, QgsRenderContext *context = nullptr );

        void stopRender( QgsRenderContext &context );

        static QgsRuleBasedRenderer::Rule *create( QDomElement &ruleElem, QgsSymbolMap &symbolMap ) SIP_FACTORY;

        QgsRuleBasedRenderer::RuleList &children() { return mChildren; }

        QgsRuleBasedRenderer::RuleList descendants() const { RuleList l; Q_FOREACH ( QgsRuleBasedRenderer::Rule *c, mChildren ) { l += c; l += c->descendants(); } return l; }

        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() { return mElseRule; }

      protected:
        void initFilter();

        Rule *mParent; // parent rule (NULL only for root rule)
        QgsSymbol *mSymbol = nullptr;
        double mMaximumScale = 0;
        double mMinimumScale = 0;
        QString mFilterExp, mLabel, mDescription;
        bool mElseRule;
        RuleList mChildren;
        RuleList mElseRules;
        bool mIsActive; // whether it is enabled or not

        QString mRuleKey; // string used for unique identification of rule within renderer

        // temporary
        QgsExpression *mFilter = nullptr;
        // temporary while rendering
        QSet<int> mSymbolNormZLevels;
        RuleList mActiveChildren;

      private:
#ifdef SIP_RUN
        Rule( const QgsRuleBasedRenderer::Rule &rh );
#endif

        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( QgsFeature &feature, QgsRenderContext &context ) override;

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

    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 QgsStringMap &props = QgsStringMap() ) const override;

    static QgsFeatureRenderer *createFromSld( QDomElement &element, QgsWkbTypes::GeometryType geomType ) SIP_FACTORY;

    QgsSymbolList symbols( QgsRenderContext &context ) 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( QgsFeature &feat, QgsRenderContext &context ) override;
    QgsSymbolList symbolsForFeature( QgsFeature &feat, QgsRenderContext &context ) override;
    QgsSymbolList originalSymbolsForFeature( QgsFeature &feat, QgsRenderContext &context ) override;
    QSet<QString> legendKeysForFeature( QgsFeature &feature, QgsRenderContext &context ) override;
    QgsFeatureRenderer::Capabilities capabilities() override { return MoreSymbolsPerFeature | Filter | ScaleDependent; }


    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 ) 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 // QGSRULEBASEDRENDERERV2_H