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 "qgsprocessingoutputs.h"
#include "qgsprocessingparametertype.h"
 
#include <QAbstractItemModel>
#include <QPointer>
#include <QSortFilterProxyModel>
 
class QgsVectorLayer;
class QgsProcessingRegistry;
class QgsProcessingProvider;
class QgsProcessingAlgorithm;
class QgsProcessingToolboxModelGroupNode;
class QgsProcessingRecentAlgorithmLog;
class QgsProcessingFavoriteAlgorithmManager;


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::NodeType::Provider )
        sipType = sipType_QgsProcessingToolboxModelProviderNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Group )
        sipType = sipType_QgsProcessingToolboxModelGroupNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Algorithm )
        sipType = sipType_QgsProcessingToolboxModelAlgorithmNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Parameter )
        sipType = sipType_QgsProcessingToolboxModelParameterNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Recent )
        sipType = sipType_QgsProcessingToolboxModelRecentNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Favorite )
        sipType = sipType_QgsProcessingToolboxModelFavoriteNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::ParameterGroup )
        sipType = sipType_QgsProcessingToolboxModelParameterGroupNode;
    }
    else
      sipType = 0;
  SIP_END
#endif
 
  public:
    // *INDENT-OFF*

    enum class NodeType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingToolboxModelNode, NodeType ) : int
    {
      Provider SIP_MONKEYPATCH_COMPAT_NAME( NodeProvider ) = 0, 
      Group SIP_MONKEYPATCH_COMPAT_NAME( NodeGroup ),           
      Algorithm SIP_MONKEYPATCH_COMPAT_NAME( NodeAlgorithm ),   
      Recent SIP_MONKEYPATCH_COMPAT_NAME( NodeRecent ),         
      Parameter,                                                
      ParameterGroup,                                           
      Favorite,                                                 
    };
    Q_ENUM( NodeType )
    // *INDENT-ON*
 
    ~QgsProcessingToolboxModelNode() override;

    virtual NodeType nodeType() const = 0;

    QgsProcessingToolboxModelNode *parent() { return mParent; }

    QList<QgsProcessingToolboxModelNode *> children() { return mChildren; }

    QList<QgsProcessingToolboxModelNode *> children() const SIP_SKIP { return mChildren; }

    QgsProcessingToolboxModelNode *takeChild( QgsProcessingToolboxModelNode *node );

    QgsProcessingToolboxModelGroupNode *getChildGroupNode( const QString &id );

    void addChildNode( QgsProcessingToolboxModelNode *node SIP_TRANSFER );

    void deleteChildren();
 
  private:
    QgsProcessingToolboxModelNode *mParent = nullptr;
    QList<QgsProcessingToolboxModelNode *> mChildren;
};

class GUI_EXPORT QgsProcessingToolboxModelRecentNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
    QgsProcessingToolboxModelRecentNode() = default;
 
    NodeType nodeType() const override { return NodeType::Recent; }
};

class GUI_EXPORT QgsProcessingToolboxModelFavoriteNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
    QgsProcessingToolboxModelFavoriteNode() = default;
 
    NodeType nodeType() const override { return NodeType::Favorite; }
};

class GUI_EXPORT QgsProcessingToolboxModelParameterGroupNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
    QgsProcessingToolboxModelParameterGroupNode() = default;
 
    NodeType nodeType() const override { return NodeType::ParameterGroup; }
};

class GUI_EXPORT QgsProcessingToolboxModelProviderNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
    QgsProcessingToolboxModelProviderNode( QgsProcessingProvider *provider );
 
    NodeType nodeType() const override { return NodeType::Provider; }

    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 NodeType::Group; }

    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 NodeType::Algorithm; }

    const QgsProcessingAlgorithm *algorithm() const;
 
  private:
    const QgsProcessingAlgorithm *mAlgorithm = nullptr;
};
 

class GUI_EXPORT QgsProcessingToolboxModelParameterNode : public QgsProcessingToolboxModelNode
{
    Q_OBJECT
 
  public:
    QgsProcessingToolboxModelParameterNode( const QgsProcessingParameterType *paramType );
 
    NodeType nodeType() const override { return NodeType::Parameter; }

    const QgsProcessingParameterType *parameterType() const;
 
  private:
    const QgsProcessingParameterType *mParamType = nullptr;
};


class GUI_EXPORT QgsProcessingToolboxModel : public QAbstractItemModel
{
    Q_OBJECT
 
  public:
    // *INDENT-OFF*

    enum class CustomRole SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingToolboxModel, Roles ) : int
    {
      NodeType SIP_MONKEYPATCH_COMPAT_NAME( RoleNodeType ) = Qt::UserRole,                    
      AlgorithmFlags SIP_MONKEYPATCH_COMPAT_NAME( RoleAlgorithmFlags ),                       
      AlgorithmId SIP_MONKEYPATCH_COMPAT_NAME( RoleAlgorithmId ),                             
      AlgorithmName SIP_MONKEYPATCH_COMPAT_NAME( RoleAlgorithmName ),                         
      AlgorithmShortDescription SIP_MONKEYPATCH_COMPAT_NAME( RoleAlgorithmShortDescription ), 
      AlgorithmTags SIP_MONKEYPATCH_COMPAT_NAME( RoleAlgorithmTags ),                         
      ProviderFlags SIP_MONKEYPATCH_COMPAT_NAME( RoleProviderFlags ),                         
      ParameterTypeId,                                                                        
    };
    Q_ENUM( CustomRole )
    // *INDENT-ON*
 
    
    QgsProcessingToolboxModel(
      QObject *parent SIP_TRANSFERTHIS = nullptr,
      QgsProcessingRegistry *registry = nullptr,
      QgsProcessingRecentAlgorithmLog *recentLog = nullptr,
      QgsProcessingFavoriteAlgorithmManager *favoriteManager = 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;

    const QgsProcessingParameterType *parameterTypeForIndex( const QModelIndex &index ) const;

    bool isParameter( const QModelIndex &index ) const;

    QModelIndex indexForProvider( const QString &providerId ) const;

    QModelIndex indexOfParentTreeNode( QgsProcessingToolboxModelNode *parentNode ) const;
 
  signals:

    void recentAlgorithmAdded();

    void favoriteAlgorithmAdded();
 
  private slots:
 
    void rebuild();
    void repopulateRecentAlgorithms( bool resetting = false );
    void repopulateFavoriteAlgorithms( bool resetting = false );
 
  private:
    QPointer<QgsProcessingRegistry> mRegistry;
    QPointer<QgsProcessingRecentAlgorithmLog> mRecentLog;
    QPointer<QgsProcessingFavoriteAlgorithmManager> mFavoriteManager;
 
    std::unique_ptr<QgsProcessingToolboxModelGroupNode> mRootNode;
    QgsProcessingToolboxModelRecentNode *mRecentNode = nullptr;
    QgsProcessingToolboxModelFavoriteNode *mFavoriteNode = 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:
    // *INDENT-OFF*

    enum class Filter SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingToolboxProxyModel, Filter ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Toolbox SIP_MONKEYPATCH_COMPAT_NAME( FilterToolbox ) = 1 << 1,                 
      Modeler SIP_MONKEYPATCH_COMPAT_NAME( FilterModeler ) = 1 << 2,                 
      InPlace SIP_MONKEYPATCH_COMPAT_NAME( FilterInPlace ) = 1 << 3,                 
      ShowKnownIssues SIP_MONKEYPATCH_COMPAT_NAME( FilterShowKnownIssues ) = 1 << 4, 
 
      SIP_SKIP // The naming could be improved, and it would be nice to be able to set them both at the same time
      SIP_SKIP // so for now don't expose these flags to Python. see https://github.com/qgis/QGIS/pull/67117#discussion_r3826016642
      SIP_SKIP ForSocketOutput
      = 1 << 5,                         
      SIP_SKIP ForSocketInput = 1 << 6, 
    };
    Q_ENUM( Filter )
    Q_DECLARE_FLAGS( Filters, Filter )
    Q_FLAG( Filters )
    // *INDENT-ON*

    explicit QgsProcessingToolboxProxyModel(
      QObject *parent SIP_TRANSFERTHIS = nullptr,
      QgsProcessingRegistry *registry = nullptr,
      QgsProcessingRecentAlgorithmLog *recentLog = nullptr,
      QgsProcessingFavoriteAlgorithmManager *favoriteManager = 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 );

    void setFilterParameter( const QgsProcessingParameterDefinition *parameterDefinition ) SIP_SKIP;

    void setFilterOutput( const QgsProcessingOutputDefinition *outputDefinition ) SIP_SKIP;

    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;

    std::unique_ptr<QgsProcessingOutputDefinition> mFilterOutputDefinition;

    std::unique_ptr<QgsProcessingParameterDefinition> mFilterParameterDefinition;
};
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingToolboxProxyModel::Filters )
 
#endif // QGSPROCESSINGTOOLBOXMODEL_H