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;
    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, 
    };

    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, 
    };
    Q_DECLARE_FLAGS( Filters, Filter )
    Q_FLAG( Filters )

    
    explicit QgsProcessingToolboxProxyModel( QObject *parent SIP_TRANSFERTHIS = nullptr,
        QgsProcessingRegistry *registry = nullptr,
        QgsProcessingRecentAlgorithmLog *recentLog = nullptr );

    QgsProcessingToolboxModel *toolboxModel();

    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;

  private:

    QgsProcessingToolboxModel *mModel = nullptr;
    Filters mFilters = nullptr;
    QString mFilterString;
    QPointer<QgsVectorLayer> mInPlaceLayer;
};


#endif // QGSPROCESSINGTOOLBOXMODEL_H