qgsprocessingtoolboxmodel.h

Go to the documentation of this file.

/***************************************************************************
    qgsprocessingtoolboxmodel.h
    ---------------------------
    begin                : May 2018
    copyright            : (C) 2018 by Nyall Dawson
    email                : nyall dot dawson 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 QGSPROCESSINGTOOLBOXMODEL_H
#define QGSPROCESSINGTOOLBOXMODEL_H
 
#include "qgis.h"
#include "qgis_gui.h"
#include <QAbstractItemModel>
#include <QSortFilterProxyModel>
#include <QPointer>
 
class QgsVectorLayer;
class QgsProcessingRegistry;
class QgsProcessingProvider;
class QgsProcessingAlgorithm;
class QgsProcessingToolboxModelGroupNode;
class QgsProcessingRecentAlgorithmLog;
 
 
class GUI_EXPORT QgsProcessingToolboxModelNode : public QObject
{
    Q_OBJECT
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->inherits( "QgsProcessingToolboxModelNode" ) )
    {
      sipType = sipType_QgsProcessingToolboxModelNode;
      QgsProcessingToolboxModelNode *node = qobject_cast<QgsProcessingToolboxModelNode *>( sipCpp );
      if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeProvider )
        sipType = sipType_QgsProcessingToolboxModelProviderNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeGroup )
        sipType = sipType_QgsProcessingToolboxModelGroupNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeAlgorithm )
        sipType = sipType_QgsProcessingToolboxModelAlgorithmNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeRecent )
        sipType = sipType_QgsProcessingToolboxModelRecentNode;
    }
    else
      sipType = 0;
    SIP_END
#endif
 
  public:
 
    enum NodeType
    {
      NodeProvider = 0, 
      NodeGroup, 
      NodeAlgorithm, 
      NodeRecent, 
    };
 
    ~QgsProcessingToolboxModelNode() override;
 
    virtual NodeType nodeType() const = 0;
 
    QgsProcessingToolboxModelNode *parent() { return mParent; }
 
    QList<QgsProcessingToolboxModelNode *> children() { return mChildren; }
 
    QList<QgsProcessingToolboxModelNode *> children() const { return mChildren; } SIP_SKIP
 
    QgsProcessingToolboxModelNode *takeChild( QgsProcessingToolboxModelNode *node );
 
    QgsProcessingToolboxModelGroupNode *getChildGroupNode( const QString &id );
 
    void addChildNode( QgsProcessingToolboxModelNode *node SIP_TRANSFER );
 
    void deleteChildren();
 
  private:
 
    NodeType mNodeType = NodeProvider;
    QgsProcessingToolboxModelNode *mParent = nullptr;
    QList<QgsProcessingToolboxModelNode *> mChildren;
 
};
 
class GUI_EXPORT QgsProcessingToolboxModelRecentNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
 
    QgsProcessingToolboxModelRecentNode() = default;
 
    NodeType nodeType() const override { return NodeRecent; }
 
};
 
class GUI_EXPORT QgsProcessingToolboxModelProviderNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
 
    QgsProcessingToolboxModelProviderNode( QgsProcessingProvider *provider );
 
    NodeType nodeType() const override { return NodeProvider; }
 
    QgsProcessingProvider *provider();
 
    QString providerId() const { return mProviderId; }
 
  private:
 
    // NOTE: we store both the provider ID and a pointer to the provider here intentionally.
    // We store the provider pointer to avoid having to lookup the provider from the registry
    // every time the node is used (which kills performance in the filter proxy model), but
    // we also store the provider id string in order to identify the provider that the node
    // is linked to for cleanups after the provider is removed.
    QString mProviderId;
    QPointer< QgsProcessingProvider > mProvider;
 
};
 
class GUI_EXPORT QgsProcessingToolboxModelGroupNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
 
    QgsProcessingToolboxModelGroupNode( const QString &id, const QString &name );
 
    NodeType nodeType() const override { return NodeGroup; }
 
    QString id() const { return mId; }
 
    QString name() const { return mName; }
 
  private:
    QString mId;
    QString mName;
 
};
 
class GUI_EXPORT QgsProcessingToolboxModelAlgorithmNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
 
    QgsProcessingToolboxModelAlgorithmNode( const QgsProcessingAlgorithm *algorithm );
 
    NodeType nodeType() const override { return NodeAlgorithm; }
 
    const QgsProcessingAlgorithm *algorithm() const;
 
  private:
 
    const QgsProcessingAlgorithm *mAlgorithm = nullptr;
 
};
 
 
class GUI_EXPORT QgsProcessingToolboxModel : public QAbstractItemModel
{
    Q_OBJECT
 
  public:
 
    enum Roles
    {
      RoleNodeType = Qt::UserRole, 
      RoleAlgorithmFlags, 
      RoleAlgorithmId, 
      RoleAlgorithmName, 
      RoleAlgorithmShortDescription, 
      RoleAlgorithmTags, 
      RoleProviderFlags, 
    };
 
    QgsProcessingToolboxModel( QObject *parent SIP_TRANSFERTHIS = nullptr, QgsProcessingRegistry *registry = nullptr,
                               QgsProcessingRecentAlgorithmLog *recentLog = nullptr );
 
    Qt::ItemFlags flags( const QModelIndex &index ) const override;
    QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const override;
    int rowCount( const QModelIndex &parent = QModelIndex() ) const override;
    int columnCount( const QModelIndex & = QModelIndex() ) const override;
    QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const override;
    QModelIndex parent( const QModelIndex &index ) const override;
    QMimeData *mimeData( const QModelIndexList &indexes ) const override;
 
    QgsProcessingToolboxModelNode *index2node( const QModelIndex &index ) const;
 
    QModelIndex node2index( QgsProcessingToolboxModelNode *node ) const;
 
    QgsProcessingProvider *providerForIndex( const QModelIndex &index ) const;
 
    QString providerIdForIndex( const QModelIndex &index ) const;
 
    const QgsProcessingAlgorithm *algorithmForIndex( const QModelIndex &index ) const;
 
    bool isAlgorithm( const QModelIndex &index ) const;
 
    QModelIndex indexForProvider( const QString &providerId ) const;
 
    QModelIndex indexOfParentTreeNode( QgsProcessingToolboxModelNode *parentNode ) const;
 
  signals:
 
    void recentAlgorithmAdded();
 
  private slots:
 
    void rebuild();
    void repopulateRecentAlgorithms( bool resetting = false );
    void providerAdded( const QString &id );
    void providerRemoved( const QString &id );
 
  private:
 
    QPointer< QgsProcessingRegistry > mRegistry;
    QPointer< QgsProcessingRecentAlgorithmLog > mRecentLog;
 
    std::unique_ptr< QgsProcessingToolboxModelGroupNode > mRootNode;
    QgsProcessingToolboxModelRecentNode *mRecentNode = nullptr;
 
    void addProvider( QgsProcessingProvider *provider );
 
    static bool isTopLevelProvider( const QString &providerId );
 
    static QString toolTipForAlgorithm( const QgsProcessingAlgorithm *algorithm );
 
};
 
 
class GUI_EXPORT QgsProcessingToolboxProxyModel: public QSortFilterProxyModel
{
    Q_OBJECT
 
  public:
 
    enum Filter
    {
      FilterToolbox = 1 << 1, 
      FilterModeler = 1 << 2, 
      FilterInPlace = 1 << 3, 
      FilterShowKnownIssues = 1 << 4, 
    };
    Q_DECLARE_FLAGS( Filters, Filter )
    Q_FLAG( Filters )
 
    
    explicit QgsProcessingToolboxProxyModel( QObject *parent SIP_TRANSFERTHIS = nullptr,
        QgsProcessingRegistry *registry = nullptr,
        QgsProcessingRecentAlgorithmLog *recentLog = nullptr );
 
    QgsProcessingToolboxModel *toolboxModel();
 
    const QgsProcessingToolboxModel *toolboxModel() const SIP_SKIP;
 
    void setFilters( QgsProcessingToolboxProxyModel::Filters filters );
 
    Filters filters() const { return mFilters; }
 
    void setInPlaceLayer( QgsVectorLayer *layer );
 
    void setFilterString( const QString &filter );
 
    QString filterString() const { return mFilterString; }
 
    bool filterAcceptsRow( int sourceRow, const QModelIndex &sourceParent ) const override;
    bool lessThan( const QModelIndex &left, const QModelIndex &right ) const override;
    QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const override;
 
  private:
 
    QgsProcessingToolboxModel *mModel = nullptr;
    Filters mFilters = Filters();
    QString mFilterString;
    QPointer<QgsVectorLayer> mInPlaceLayer;
};
 
 
#endif // QGSPROCESSINGTOOLBOXMODEL_H