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 "qgis_core.h"
#include <QStringList>
#include <QMap>
#include <QUuid>
 
#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<QgsRuleBasedLabeling::Rule *> RuleList;
    typedef QMap<QgsRuleBasedLabeling::Rule *, QgsVectorLayerLabelProvider *> RuleToProviderMap;
 
    class CORE_EXPORT Rule
    {
      public:
        Rule( QgsPalLayerSettings *settings SIP_TRANSFER, double maximumScale = 0, double minimumScale = 0, const QString &filterExp = QString(), const QString &description = QString(), bool elseRule = false );
        ~Rule();
 
        Rule( const Rule &rh ) = delete;
        Rule &operator=( const Rule &rh ) = delete;
 
        enum RegisterResult
        {
          Filtered = 0, 
          Inactive,     
          Registered    
        };
 
        QgsPalLayerSettings *settings() const { return mSettings.get(); }
 
        bool dependsOnScale() const { return !qgsDoubleNear( mMinimumScale, 0.0 ) || !qgsDoubleNear( mMaximumScale, 0 ); }
 
        double maximumScale() const { return mMaximumScale; }
 
        double minimumScale() const { return mMinimumScale; }
 
        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 SIP_TRANSFER );
 
        void setMinimumScale( double scale ) { mMinimumScale = scale; }
 
        void setMaximumScale( double scale ) { mMaximumScale = scale; }
 
        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 QgsRuleBasedLabeling::RuleList &children() const { return mChildren; }
 
        QgsRuleBasedLabeling::RuleList &children() SIP_SKIP { return mChildren; }
 
        QgsRuleBasedLabeling::RuleList descendants() const;
 
        const QgsRuleBasedLabeling::Rule *parent() const SIP_SKIP { return mParent; }
 
        QgsRuleBasedLabeling::Rule *parent() { return mParent; }
 
        void appendChild( QgsRuleBasedLabeling::Rule *rule SIP_TRANSFER );
 
        void insertChild( int i, QgsRuleBasedLabeling::Rule *rule SIP_TRANSFER );
 
        void removeChildAt( int i );
 
        const QgsRuleBasedLabeling::Rule *findRuleByKey( const QString &key ) const;
 
        QgsRuleBasedLabeling::Rule *findRuleByKey( const QString &key ) SIP_SKIP;
 
        QgsRuleBasedLabeling::Rule *clone() const SIP_FACTORY;
 
        // load / save
 
        static QgsRuleBasedLabeling::Rule *create( const QDomElement &ruleElem, const QgsReadWriteContext &context ) SIP_FACTORY;
 
        QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const;
 
        // evaluation
 
        void createSubProviders( QgsVectorLayer *layer, RuleToProviderMap &subProviders, QgsRuleBasedLabelProvider *provider ) SIP_SKIP;
 
        void subProviderIds( QStringList &list ) const SIP_SKIP;
 
        void prepare( QgsRenderContext &context, QSet<QString> &attributeNames, RuleToProviderMap &subProviders ) SIP_SKIP;
 
        RegisterResult registerFeature( const QgsFeature &feature, QgsRenderContext &context, RuleToProviderMap &subProviders, const QgsGeometry &obstacleGeometry = QgsGeometry(), const QgsSymbol *symbol = nullptr ) SIP_SKIP;
 
        bool requiresAdvancedEffects() const;
 
        bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
      private:
#ifdef SIP_RUN
        Rule( const QgsRuleBasedLabeling::Rule &rh );
#endif
 
        bool isFilterOK( const QgsFeature &f, QgsRenderContext &context ) const;
 
        bool isScaleOK( double scale ) const;
 
        void initFilter();
 
        void updateElseRules();
 
      private:
        Rule *mParent = nullptr; // parent rule (nullptr only for root rule)
        std::unique_ptr<QgsPalLayerSettings> mSettings;
        double mMaximumScale = 0;
        double mMinimumScale = 0;
        QString mFilterExp;
        QString mDescription;
        bool mElseRule = false;
        RuleList mChildren;
        RuleList mElseRules;
        bool mIsActive = true; // whether it is enabled or not
 
        QString mRuleKey = QUuid::createUuid().toString(); // string used for unique identification of rule within labeling
 
        std::unique_ptr<QgsExpression> mFilter;
 
    };
 
 
    explicit QgsRuleBasedLabeling( QgsRuleBasedLabeling::Rule *root SIP_TRANSFER );
    ~QgsRuleBasedLabeling() override;
 
    QgsRuleBasedLabeling::Rule *rootRule();
    const Rule *rootRule() const SIP_SKIP;
 
    static QgsRuleBasedLabeling *create( const QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
 
    // implementation of parent interface
 
    QString type() const override;
    QgsRuleBasedLabeling *clone() const override SIP_FACTORY;
    QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const override;
    QgsVectorLayerLabelProvider *provider( QgsVectorLayer *layer ) const override SIP_SKIP;
    QStringList subProviders() const override;
    QgsPalLayerSettings settings( const QString &providerId = QString() ) const override;
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const override;
 
    void setSettings( QgsPalLayerSettings *settings SIP_TRANSFER, const QString &providerId = QString() ) override;
    bool requiresAdvancedEffects() const override;
    void toSld( QDomNode &parent, const QVariantMap &props ) const override;
 
  protected:
    std::unique_ptr<Rule> mRootRule;
};
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsRuleBasedLabelProvider : public QgsVectorLayerLabelProvider
{
  public:
    QgsRuleBasedLabelProvider( const QgsRuleBasedLabeling &rules, QgsVectorLayer *layer, bool withFeatureLoop = true );
 
    // reimplemented
 
    bool prepare( QgsRenderContext &context, QSet<QString> &attributeNames ) override;
 
    void registerFeature( const QgsFeature &feature, QgsRenderContext &context, const QgsGeometry &obstacleGeometry = QgsGeometry(), const QgsSymbol *symbol = nullptr ) override;
 
    virtual QgsVectorLayerLabelProvider *createProvider( QgsVectorLayer *layer, const QString &providerId, bool withFeatureLoop, const QgsPalLayerSettings *settings );
 
    QList<QgsAbstractLabelProvider *> subProviders() override;
 
  protected:
    std::unique_ptr<QgsRuleBasedLabeling> mRules;
    QgsRuleBasedLabeling::RuleToProviderMap mSubProviders;
};
 
#endif
 
#endif // QGSRULEBASEDLABELING_H