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 "qgis_core.h"
#include <QAbstractItemModel>
#include <QFont>
#include <QIcon>
#include <QTimer>
#include <memory>

#include "qgsgeometry.h"
#include "qgslayertreemodellegendnode.h"

class QgsLayerTreeNode;
class QgsLayerTreeGroup;
class QgsLayerTreeLayer;
class QgsMapHitTest;
class QgsMapSettings;
class QgsExpression;
class QgsRenderContext;
class QgsLayerTree;

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

      // behavioral flags
      AllowNodeReorder           = 0x1000,  
      AllowNodeRename            = 0x2000,  
      AllowNodeChangeVisibility  = 0x4000,  
      AllowLegendChangeState     = 0x8000,  
      ActionHierarchical         = 0x10000, 
    };
    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; }

    void setLegendFilterByMap( const QgsMapSettings *settings );

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

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

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

    static int scaleIconSize( int standardSize );

  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 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:
    QgsLayerTree *mRootNode = nullptr;
    Flags mFlags;
    QPersistentModelIndex mCurrentIndex;
    int mAutoCollapseLegendNodesCount;

#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;

    QMap<QgsLayerTreeLayer *, LayerLegendData> mLegend;

    QFont mFontLayer;
    QFont mFontGroup;

    double mLegendFilterByScale;

    std::unique_ptr<QgsMapSettings> mLegendFilterMapSettings;
    std::unique_ptr<QgsMapHitTest> mLegendFilterHitTest;

    bool mLegendFilterUsesExtent;

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

  private:

    QgsRenderContext *createTemporaryRenderContext() const;
};

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 = QStringLiteral( "embedded-widget-" ) + QUuid::createUuid().toString();
    }

    QVariant data( int role ) const override
    {
      if ( role == RuleKeyRole )
        return mRuleKey;
      return QVariant();
    }

  private:
    QString mRuleKey;
};
#endif


#endif // QGSLAYERTREEMODEL_H