qgsrulebasedlabeling.h

Go to the documentation of this file.

/***************************************************************************
    qgsrulebasedlabeling.h
    ---------------------
    begin                : September 2015
    copyright            : (C) 2015 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 QGSRULEBASEDLABELING_H
#define QGSRULEBASEDLABELING_H

#include <QStringList>
#include <QMap>

#include "qgsvectorlayerlabeling.h"
#include "qgsvectorlayerlabelprovider.h"

class QDomDocument;
class QDomElement;

class QgsExpression;
class QgsFeature;
class QgsPalLayerSettings;
class QgsRenderContext;
class QgsGeometry;
class QgsRuleBasedLabelProvider;

class CORE_EXPORT QgsRuleBasedLabeling : public QgsAbstractVectorLayerLabeling
{
  public:
    class Rule;
    typedef QList<Rule*> RuleList;
    typedef QMap<Rule*, QgsVectorLayerLabelProvider*> RuleToProviderMap;

    class CORE_EXPORT Rule
    {
      public:
        Rule( QgsPalLayerSettings* settings, int scaleMinDenom = 0, int scaleMaxDenom = 0, const QString& filterExp = QString(), const QString& description = QString(), bool elseRule = false );
        ~Rule();

        enum RegisterResult
        {
          Filtered = 0, 
          Inactive,     
          Registered    
        };

        QgsPalLayerSettings* settings() const { return mSettings; }

        bool dependsOnScale() const { return mScaleMinDenom != 0 || mScaleMaxDenom != 0; }

        int scaleMinDenom() const { return mScaleMinDenom; }

        int scaleMaxDenom() const { return mScaleMaxDenom; }
        QString filterExpression() const { return mFilterExp; }
        QString description() const { return mDescription; }
        bool active() const { return mIsActive; }
        bool isElse() const { return mElseRule; }

        QString ruleKey() const { return mRuleKey; }

        void setSettings( QgsPalLayerSettings* settings );

        void setScaleMinDenom( int scaleMinDenom ) { mScaleMinDenom = scaleMinDenom; }
        void setScaleMaxDenom( int scaleMaxDenom ) { mScaleMaxDenom = scaleMaxDenom; }
        void setFilterExpression( const QString& filterExp ) { mFilterExp = filterExp; initFilter(); }
        void setDescription( const QString& description ) { mDescription = description; }
        void setActive( bool state ) { mIsActive = state; }
        void setIsElse( bool iselse ) { mElseRule = iselse; }

        void setRuleKey( const QString& key ) { mRuleKey = key; }

        // parent / child operations

        const RuleList& children() const { return mChildren; }
        RuleList& children() { return mChildren; }

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

        const Rule* parent() const { return mParent; }
        Rule* parent() { return mParent; }

        void appendChild( Rule* rule );

        void insertChild( int i, Rule* rule );

        void removeChildAt( int i );

        const Rule* findRuleByKey( const QString& key ) const;

        Rule* clone() const;

        // load / save

        static Rule* create( const QDomElement& ruleElem );

        QDomElement save( QDomDocument& doc ) const;

        // evaluation

        void createSubProviders( QgsVectorLayer* layer, RuleToProviderMap& subProviders, QgsRuleBasedLabelProvider *provider );

        void subProviderIds( QStringList& list ) const;

        void prepare( const QgsRenderContext& context, QStringList& attributeNames, RuleToProviderMap& subProviders );

        RegisterResult registerFeature( QgsFeature& feature, QgsRenderContext& context, RuleToProviderMap& subProviders, QgsGeometry* obstacleGeometry = nullptr );

      protected:
        bool isFilterOK( QgsFeature& f, QgsRenderContext& context ) const;
        bool isScaleOK( double scale ) const;

        void initFilter();

        void updateElseRules();

      protected:
        Rule* mParent; // parent rule (NULL only for root rule)
        QgsPalLayerSettings* mSettings;
        int mScaleMinDenom, mScaleMaxDenom;
        QString mFilterExp, 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 labeling

        // temporary
        QgsExpression* mFilter;

      private:

        Rule( const Rule& rh );
        Rule& operator=( const Rule& rh );
    };


    explicit QgsRuleBasedLabeling( QgsRuleBasedLabeling::Rule* root );
    QgsRuleBasedLabeling( const QgsRuleBasedLabeling& other );
    ~QgsRuleBasedLabeling();

    Rule* rootRule() { return mRootRule; }
    const Rule* rootRule() const { return mRootRule; }

    static QgsRuleBasedLabeling* create( const QDomElement& element );

    // implementation of parent interface

    virtual QString type() const override;
    virtual QDomElement save( QDomDocument& doc ) const override;
    virtual QgsVectorLayerLabelProvider *provider( QgsVectorLayer* layer ) const override;
    virtual QStringList subProviders() const override;
    virtual QgsPalLayerSettings settings( QgsVectorLayer* layer, const QString& providerId = QString() ) const override;

  protected:
    Rule* mRootRule;
};


class CORE_EXPORT QgsRuleBasedLabelProvider : public QgsVectorLayerLabelProvider
{
  public:
    QgsRuleBasedLabelProvider( const QgsRuleBasedLabeling& rules, QgsVectorLayer* layer, bool withFeatureLoop = true );
    ~QgsRuleBasedLabelProvider();

    // reimplemented

    virtual bool prepare( const QgsRenderContext& context, QStringList& attributeNames ) override;

    virtual void registerFeature( QgsFeature& feature, QgsRenderContext& context, QgsGeometry* obstacleGeometry = nullptr ) override;

    virtual QgsVectorLayerLabelProvider *createProvider( QgsVectorLayer *layer, const QString& providerId, bool withFeatureLoop, const QgsPalLayerSettings *settings );

    virtual QList<QgsAbstractLabelProvider*> subProviders() override;

  protected:
    QgsRuleBasedLabeling mRules;
    QgsRuleBasedLabeling::RuleToProviderMap mSubProviders;
};


#endif // QGSRULEBASEDLABELING_H