qgsrulebased3drenderer.h

Go to the documentation of this file.

/***************************************************************************
  qgsrulebased3drenderer.h
  --------------------------------------
  Date                 : January 2019
  Copyright            : (C) 2019 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 QGSRULEBASED3DRENDERER_H
#define QGSRULEBASED3DRENDERER_H
 
#include "qgis_3d.h"
 
#include "qgs3drendererregistry.h"
#include "qgsabstractvectorlayer3drenderer.h"
#include "qgsabstract3dsymbol.h"
#include "qgsmaplayerref.h"
#include <QUuid>
 
class Qgs3DRenderContext;
class QgsFeature3DHandler;
 
 
class _3D_EXPORT QgsRuleBased3DRendererMetadata : public Qgs3DRendererAbstractMetadata
{
  public:
    QgsRuleBased3DRendererMetadata();
 
    QgsAbstract3DRenderer *createRenderer( QDomElement &elem, const QgsReadWriteContext &context ) override SIP_FACTORY;
};
 
 
class _3D_EXPORT QgsRuleBased3DRenderer : public QgsAbstractVectorLayer3DRenderer
{
  public:
 
    class Rule;
    typedef QList<QgsRuleBased3DRenderer::Rule *> RuleList;
    typedef QHash<const QgsRuleBased3DRenderer::Rule *, QgsFeature3DHandler *> RuleToHandlerMap;
 
    class _3D_EXPORT Rule
    {
      public:
        Rule( QgsAbstract3DSymbol *symbol SIP_TRANSFER, 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    
        };
 
        QgsAbstract3DSymbol *symbol() const { return mSymbol.get(); }
 
        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 setSymbol( QgsAbstract3DSymbol *symbol SIP_TRANSFER );
 
        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; }
 
        // TODO: needed?
        void setRuleKey( const QString &key ) { mRuleKey = key; }
 
        // parent / child operations
 
        const QgsRuleBased3DRenderer::RuleList &children() const { return mChildren; }
 
        QgsRuleBased3DRenderer::RuleList &children() SIP_SKIP { return mChildren; }
 
        QgsRuleBased3DRenderer::RuleList descendants() const;
 
        const QgsRuleBased3DRenderer::Rule *parent() const SIP_SKIP { return mParent; }
 
        QgsRuleBased3DRenderer::Rule *parent() { return mParent; }
 
        void appendChild( QgsRuleBased3DRenderer::Rule *rule SIP_TRANSFER );
 
        void insertChild( int i, QgsRuleBased3DRenderer::Rule *rule SIP_TRANSFER );
 
        void removeChildAt( int i );
 
        const QgsRuleBased3DRenderer::Rule *findRuleByKey( const QString &key ) const;
 
        QgsRuleBased3DRenderer::Rule *findRuleByKey( const QString &key ) SIP_SKIP;
 
        QgsRuleBased3DRenderer::Rule *clone() const SIP_FACTORY;
 
        // load / save
 
        static QgsRuleBased3DRenderer::Rule *create( const QDomElement &ruleElem, const QgsReadWriteContext &context ) SIP_FACTORY;
 
        QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const;
 
        // evaluation
 
        void createHandlers( QgsVectorLayer *layer, RuleToHandlerMap &handlers ) const SIP_SKIP;
 
        void prepare( const Qgs3DRenderContext &context, QSet<QString> &attributeNames, RuleToHandlerMap &handlers ) const SIP_SKIP;
 
        RegisterResult registerFeature( QgsFeature &feature, Qgs3DRenderContext &context, RuleToHandlerMap &handlers ) const SIP_SKIP;
 
      private:
#ifdef SIP_RUN
        Rule( const QgsRuleBased3DRenderer::Rule &rh );
#endif
 
        bool isFilterOK( QgsFeature &f, Qgs3DRenderContext &context ) const;
 
        void initFilter();
 
        void updateElseRules();
 
      private:
        Rule *mParent = nullptr; // parent rule (nullptr only for root rule)
        std::unique_ptr<QgsAbstract3DSymbol> mSymbol;
        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;
    };
 
 
    QgsRuleBased3DRenderer( QgsRuleBased3DRenderer::Rule *root SIP_TRANSFER );
    ~QgsRuleBased3DRenderer() override;
 
    QgsRuleBased3DRenderer::Rule *rootRule() { return mRootRule; }
    const Rule *rootRule() const SIP_SKIP { return mRootRule; }
 
    QString type() const override { return "rulebased"; }
    QgsRuleBased3DRenderer *clone() const override SIP_FACTORY;
    Qt3DCore::QEntity *createEntity( Qgs3DMapSettings *map ) const override SIP_SKIP;
 
    void writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const override;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context ) override;
 
  private:
    Rule *mRootRule = nullptr;
 
};
 
#endif // QGSRULEBASED3DRENDERER_H