qgslayertreemodel.h

Go to the documentation of this file.

/***************************************************************************
  qgslayertreemodel.h
  --------------------------------------
  Date                 : May 2014
  Copyright            : (C) 2014 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 QGSLAYERTREEMODEL_H
#define QGSLAYERTREEMODEL_H
 
#include <memory>
 
#include "qgis_core.h"
#include "qgsgeometry.h"
#include "qgslayertreemodellegendnode.h"
 
#include <QAbstractItemModel>
#include <QFont>
#include <QIcon>
#include <QString>
#include <QTimer>
#include <QUuid>
 
using namespace Qt::StringLiterals;
 
class QgsLayerTreeNode;
class QgsLayerTreeGroup;
class QgsLayerTreeLayer;
class QgsMapHitTest;
class QgsMapHitTestTask;
class QgsMapSettings;
class QgsExpression;
class QgsRenderContext;
class QgsLayerTree;
class QgsLayerTreeFilterSettings;

class CORE_EXPORT QgsLayerTreeModel : public QAbstractItemModel
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->inherits( "QgsLayerTreeModel" ) )
      sipType = sipType_QgsLayerTreeModel;
    else
      sipType = 0;
    SIP_END
#endif
 
    Q_OBJECT
  public:

    explicit QgsLayerTreeModel( QgsLayerTree *rootNode, QObject *parent SIP_TRANSFERTHIS = nullptr );
 
    ~QgsLayerTreeModel() override;
 
    // Implementation of virtual functions from QAbstractItemModel
 
    int rowCount( const QModelIndex &parent = QModelIndex() ) const override;
    int columnCount( const QModelIndex &parent = QModelIndex() ) const override;
    QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const override;
    QModelIndex parent( const QModelIndex &child ) const override;
    QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const override;
    Qt::ItemFlags flags( const QModelIndex &index ) const override;
    bool setData( const QModelIndex &index, const QVariant &value, int role = Qt::EditRole ) override;
    Qt::DropActions supportedDropActions() const override;
    QStringList mimeTypes() const override;
    QMimeData *mimeData( const QModelIndexList &indexes ) const override;
    bool dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent ) override;
    bool removeRows( int row, int count, const QModelIndex &parent = QModelIndex() ) override;
 
    // New stuff
 
    enum Flag SIP_ENUM_BASETYPE( IntFlag )
    {
      // display flags
      ShowLegend                 = 0x0001,  
      ShowLegendAsTree           = 0x0004,  
      DeferredLegendInvalidation = 0x0008,  
      UseEmbeddedWidgets         = 0x0010,  
      UseTextFormatting          = 0x0020,  
 
      // behavioral flags
      AllowNodeReorder           = 0x1000,  
      AllowNodeRename            = 0x2000,  
      AllowNodeChangeVisibility  = 0x4000,  
      AllowLegendChangeState     = 0x8000,  
      ActionHierarchical         = 0x10000, 
      UseThreadedHitTest         = 0x20000, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    void setFlags( QgsLayerTreeModel::Flags f );
    void setFlag( Flag f, bool on = true );
    Flags flags() const;
    bool testFlag( Flag f ) const;

    QgsLayerTreeNode *index2node( const QModelIndex &index ) const;
    QModelIndex node2index( QgsLayerTreeNode *node ) const;

    QList<QgsLayerTreeNode *> indexes2nodes( const QModelIndexList &list, bool skipInternal = false ) const;

    static QgsLayerTreeModelLegendNode *index2legendNode( const QModelIndex &index );

    QModelIndex legendNode2index( QgsLayerTreeModelLegendNode *legendNode );

    QList<QgsLayerTreeModelLegendNode *> layerLegendNodes( QgsLayerTreeLayer *nodeLayer, bool skipNodeEmbeddedInParent = false );

    QList<QgsLayerTreeModelLegendNode *> layerOriginalLegendNodes( QgsLayerTreeLayer *nodeLayer );

    QgsLayerTreeModelLegendNode *legendNodeEmbeddedInParent( QgsLayerTreeLayer *nodeLayer ) const;

    QgsLayerTreeModelLegendNode *findLegendNode( const QString &layerId, const QString &ruleKey ) const;

    QgsLayerTree *rootGroup() const;

    void setRootGroup( QgsLayerTree *newRootGroup );

    void refreshLayerLegend( QgsLayerTreeLayer *nodeLayer );

    QModelIndex currentIndex() const;
    void setCurrentIndex( const QModelIndex &currentIndex );

    void setLayerTreeNodeFont( int nodeType, const QFont &font );
    QFont layerTreeNodeFont( int nodeType ) const;

    void setAutoCollapseLegendNodes( int nodeCount ) { mAutoCollapseLegendNodesCount = nodeCount; }
    int autoCollapseLegendNodes() const { return mAutoCollapseLegendNodesCount; }

    void setLegendFilterByScale( double scale );

    double legendFilterByScale() const { return mLegendFilterByScale; }

    Q_DECL_DEPRECATED void setLegendFilterByMap( const QgsMapSettings *settings ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED void setLegendFilter( const QgsMapSettings *settings, bool useExtent = true, const QgsGeometry &polygon = QgsGeometry(), bool useExpressions = true ) SIP_DEPRECATED;

    const QgsMapSettings *legendFilterMapSettings() const;

    void setFilterSettings( const QgsLayerTreeFilterSettings *settings = nullptr );

    const QgsLayerTreeFilterSettings *filterSettings() const;

    void setLegendMapViewData( double mapUnitsPerPixel, int dpi, double scale );

    void legendMapViewData( double *mapUnitsPerPixel SIP_OUT, int *dpi SIP_OUT, double *scale  SIP_OUT ) const;

    QMap<QString, QString> layerStyleOverrides() const;

    void setLayerStyleOverrides( const QMap<QString, QString> &overrides );

    void addTargetScreenProperties( const QgsScreenProperties &properties );

    QSet< QgsScreenProperties > targetScreenProperties() const;

    static int scaleIconSize( int standardSize );

    void waitForHitTestBlocking();

    bool hitTestInProgress() const;
 
  signals:

    void messageEmitted( const QString &message, Qgis::MessageLevel level = Qgis::MessageLevel::Info, int duration = 5 );

    void hitTestStarted();

    void hitTestCompleted();
 
  protected slots:
    void nodeWillAddChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo );
    void nodeAddedChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo );
    void nodeWillRemoveChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo );
    void nodeRemovedChildren();
 
    void nodeVisibilityChanged( QgsLayerTreeNode *node );

    void nodeNameChanged( QgsLayerTreeNode *node, const QString &name );
 
    void nodeCustomPropertyChanged( QgsLayerTreeNode *node, const QString &key );
 
    void nodeLayerLoaded();
    void nodeLayerWillBeUnloaded();
    void layerLegendChanged();

    void layerFlagsChanged();
 
    void layerNeedsUpdate();
 
    void legendNodeDataChanged();
 
    void invalidateLegendMapBasedData();
 
  private slots:

    void layerProfileGenerationPropertyChanged();
 
  protected:
    void removeLegendFromLayer( QgsLayerTreeLayer *nodeLayer );
    void addLegendToLayer( QgsLayerTreeLayer *nodeL );
 
    void connectToLayer( QgsLayerTreeLayer *nodeLayer );
    void disconnectFromLayer( QgsLayerTreeLayer *nodeLayer );
 
    void connectToLayers( QgsLayerTreeGroup *parentGroup );
    void disconnectFromLayers( QgsLayerTreeGroup *parentGroup );
    void connectToRootNode();
    void disconnectFromRootNode();

    void recursivelyEmitDataChanged( const QModelIndex &index = QModelIndex() );

    void refreshScaleBasedLayers( const QModelIndex &index = QModelIndex(), double previousScale = 0.0 );
 
    static QIcon iconGroup();

    QList<QgsLayerTreeModelLegendNode *> filterLegendNodes( const QList<QgsLayerTreeModelLegendNode *> &nodes );
 
    QModelIndex indexOfParentLayerTreeNode( QgsLayerTreeNode *parentNode ) const;
 
    int legendRootRowCount( QgsLayerTreeLayer *nL ) const;
    int legendNodeRowCount( QgsLayerTreeModelLegendNode *node ) const;
    QModelIndex legendRootIndex( int row, int column, QgsLayerTreeLayer *nL ) const;
    QModelIndex legendNodeIndex( int row, int column, QgsLayerTreeModelLegendNode *node ) const;
    QModelIndex legendParent( QgsLayerTreeModelLegendNode *legendNode ) const;
    QVariant legendNodeData( QgsLayerTreeModelLegendNode *node, int role ) const;
    Qt::ItemFlags legendNodeFlags( QgsLayerTreeModelLegendNode *node ) const;
    bool legendEmbeddedInParent( QgsLayerTreeLayer *nodeLayer ) const;
    QIcon legendIconEmbeddedInParent( QgsLayerTreeLayer *nodeLayer ) const;
    void legendCleanup();
    void legendInvalidateMapBasedData();
 
  protected:

    QgsRenderContext *createTemporaryRenderContext() const SIP_SKIP;

    QgsLayerTree *mRootNode = nullptr;
    Flags mFlags;
    QPersistentModelIndex mCurrentIndex;
    int mAutoCollapseLegendNodesCount = -1;

#ifndef SIP_RUN
    struct LayerLegendTree
    {
      QMap<QgsLayerTreeModelLegendNode *, QgsLayerTreeModelLegendNode *> parents;
      QMap<QgsLayerTreeModelLegendNode *, QList<QgsLayerTreeModelLegendNode *> > children;
    };
#endif

#ifndef SIP_RUN
    struct LayerLegendData
    {
      LayerLegendData() = default;

      QList<QgsLayerTreeModelLegendNode *> activeNodes;

      QgsLayerTreeModelLegendNode *embeddedNodeInParent = nullptr;

      QList<QgsLayerTreeModelLegendNode *> originalNodes;
      LayerLegendTree *tree = nullptr;
    };
#endif

    LayerLegendTree *tryBuildLegendTree( const QList<QgsLayerTreeModelLegendNode *> &nodes ) SIP_SKIP;

    QMap<QString, QString> mLayerStyleOverrides;

    QHash<QgsLayerTreeLayer *, LayerLegendData> mLegend;

    QSet<QgsLayerTreeLayer *> mInvalidatedNodes;
 
    QFont mFontLayer;
    QFont mFontGroup;

    double mLegendFilterByScale = 0;
 
    QPointer< QgsMapHitTestTask > mHitTestTask;
 
    QMap<QString, QSet<QString>> mHitTestResults;
 
    QMap<QString, QPair<double, double>> mHitTestResultsRendererUpdatedCanvas;
 
    std::unique_ptr< QgsLayerTreeFilterSettings > mFilterSettings;
 
    double mLegendMapViewMupp = 0;
    int mLegendMapViewDpi = 0;
    double mLegendMapViewScale = 0;
    QTimer mDeferLegendInvalidationTimer;
 
    QSet< QgsScreenProperties > mTargetScreenProperties;
 
  private slots:
    void legendNodeSizeChanged();
    void hitTestTaskCompleted();
 
  private:
    void handleHitTestResults();
 
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayerTreeModel::Flags )
 

#ifndef SIP_RUN

class EmbeddedWidgetLegendNode : public QgsLayerTreeModelLegendNode
{
    Q_OBJECT
 
  public:
    EmbeddedWidgetLegendNode( QgsLayerTreeLayer *nodeL )
      : QgsLayerTreeModelLegendNode( nodeL )
    {
      // we need a valid rule key to allow the model to build a tree out of legend nodes
      // if that's possible (if there is a node without a rule key, building of tree is canceled)
      mRuleKey = u"embedded-widget-"_s + QUuid::createUuid().toString();
    }
 
    QVariant data( int role ) const override
    {
      if ( role == static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) )
        return mRuleKey;
      else if ( role == static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::NodeType ) )
        return QgsLayerTreeModelLegendNode::EmbeddedWidget;
      return QVariant();
    }
 
  private:
    QString mRuleKey;
};
#endif

 
#endif // QGSLAYERTREEMODEL_H