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 <QAbstractItemModel>
#include <QFont>
#include <QIcon>
#include <QTimer>

#include "qgsgeometry.h"

class QgsLayerTreeNode;
class QgsLayerTreeGroup;
class QgsLayerTreeLayer;
class QgsLayerTreeModelLegendNode;
class QgsMapHitTest;
class QgsMapLayer;
class QgsMapSettings;
class QgsExpression;

class CORE_EXPORT QgsLayerTreeModel : public QAbstractItemModel
{
    Q_OBJECT
  public:
    explicit QgsLayerTreeModel( QgsLayerTreeGroup* rootNode, QObject *parent = nullptr );
    ~QgsLayerTreeModel();

    // 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
    {
      // display flags
      ShowLegend                 = 0x0001,  
      ShowSymbology              = 0x0001,  
      ShowRasterPreviewIcon      = 0x0002,  
      ShowLegendAsTree           = 0x0004,  
      DeferredLegendInvalidation = 0x0008,  
      UseEmbeddedWidgets         = 0x0010,  

      // behavioral flags
      AllowNodeReorder           = 0x1000,  
      AllowNodeRename            = 0x2000,  
      AllowNodeChangeVisibility  = 0x4000,  
      AllowLegendChangeState     = 0x8000,  
      AllowSymbologyChangeState  = 0x8000,  
    };
    Q_DECLARE_FLAGS( Flags, Flag )

    
    void setFlags( const 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;

    QgsLayerTreeGroup* rootGroup() const;
    void setRootGroup( QgsLayerTreeGroup* 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 scaleDenominator );
    double legendFilterByScale() const { return mLegendFilterByScale; }

    void setLegendFilterByMap( const QgsMapSettings* settings );

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

    Q_DECL_DEPRECATED const QgsMapSettings* legendFilterByMap() const { return mLegendFilterMapSettings.data(); }

    const QgsMapSettings* legendFilterMapSettings() const { return mLegendFilterMapSettings.data(); }

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

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

    Q_DECL_DEPRECATED bool isIndexSymbologyNode( const QModelIndex& index ) const;
    Q_DECL_DEPRECATED QgsLayerTreeLayer* layerNodeForSymbologyNode( const QModelIndex& index ) const;
    Q_DECL_DEPRECATED void refreshLayerSymbology( QgsLayerTreeLayer* nodeLayer ) { refreshLayerLegend( nodeLayer ); }
    Q_DECL_DEPRECATED void setAutoCollapseSymbologyNodes( int nodeCount ) { setAutoCollapseLegendNodes( nodeCount ); }
    Q_DECL_DEPRECATED int autoCollapseSymbologyNodes() const { return autoCollapseLegendNodes(); }

  signals:

  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 layerNeedsUpdate();

    void legendNodeDataChanged();

    void invalidateLegendMapBasedData();

  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() );

    static const 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:
    QgsLayerTreeGroup* mRootNode;
    Flags mFlags;
    QPersistentModelIndex mCurrentIndex;
    int mAutoCollapseLegendNodesCount;

    struct LayerLegendTree
    {
      QMap<QgsLayerTreeModelLegendNode*, QgsLayerTreeModelLegendNode*> parents;
      QMap<QgsLayerTreeModelLegendNode*, QList<QgsLayerTreeModelLegendNode*> > children;
    };

    struct LayerLegendData
    {
      LayerLegendData()
          : embeddedNodeInParent( nullptr )
          , tree( nullptr )
      {
      }

      QList<QgsLayerTreeModelLegendNode*> activeNodes;
      QgsLayerTreeModelLegendNode* embeddedNodeInParent;
      QList<QgsLayerTreeModelLegendNode*> originalNodes;
      LayerLegendTree* tree;
    };

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

    QMap<QString, QString> mLayerStyleOverrides;

    QMap<QgsLayerTreeLayer*, LayerLegendData> mLegend;

    QFont mFontLayer;
    QFont mFontGroup;

    double mLegendFilterByScale;

    QScopedPointer<QgsMapSettings> mLegendFilterMapSettings;
    QScopedPointer<QgsMapHitTest> mLegendFilterHitTest;

    bool mLegendFilterUsesExtent;

    double mLegendMapViewMupp;
    int mLegendMapViewDpi;
    double mLegendMapViewScale;
    QTimer mDeferLegendInvalidationTimer;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLayerTreeModel::Flags )

#endif // QGSLAYERTREEMODEL_H