/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/gui/processing/qgsprocessingtoolboxmodel.h                       *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/





class QgsProcessingToolboxModelNode : QObject
{
%Docstring(signature="appended")
Abstract base class for nodes contained within a
:py:class:`QgsProcessingToolboxModel`.

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
%ConvertToSubClassCode
    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::Recent )
        sipType = sipType_QgsProcessingToolboxModelRecentNode;
      else if ( node->nodeType() == QgsProcessingToolboxModelNode::NodeType::Favorite )
        sipType = sipType_QgsProcessingToolboxModelFavoriteNode;
    }
    else
      sipType = 0;
%End
  public:

    enum class NodeType /BaseType=IntEnum/
    {
      Provider,
      Group,
      Algorithm,
      Recent,
      Favorite,
    };

    ~QgsProcessingToolboxModelNode();

    virtual NodeType nodeType() const = 0;
%Docstring
Returns the node's type.
%End

    QgsProcessingToolboxModelNode *parent();
%Docstring
Returns the node's parent. If the node's parent is ``None``, then the
node is a root node.
%End

    QList<QgsProcessingToolboxModelNode *> children();
%Docstring
Returns a list of children belonging to the node.
%End


    QgsProcessingToolboxModelNode *takeChild( QgsProcessingToolboxModelNode *node );
%Docstring
Removes the specified ``node`` from this node's children, and gives
ownership back to the caller.
%End

    QgsProcessingToolboxModelGroupNode *getChildGroupNode( const QString &id );
%Docstring
Tries to find a child node belonging to this node, which corresponds to
a group node with the given group ``id``. Returns ``None`` if no
matching child group node was found.
%End

    void addChildNode( QgsProcessingToolboxModelNode *node /Transfer/ );
%Docstring
Adds a child ``node`` to this node, transferring ownership of the node
to this node.
%End

    void deleteChildren();
%Docstring
Deletes all child nodes from this node.
%End

};

class QgsProcessingToolboxModelRecentNode : QgsProcessingToolboxModelNode
{
%Docstring(signature="appended")
Processing toolbox model node corresponding to the recent algorithms
group

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:
    QgsProcessingToolboxModelRecentNode();

    virtual NodeType nodeType() const;
};

class QgsProcessingToolboxModelFavoriteNode : QgsProcessingToolboxModelNode
{
%Docstring(signature="appended")
Processing toolbox model node corresponding to the favorite algorithms
group

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.40
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:
    QgsProcessingToolboxModelFavoriteNode();

    virtual NodeType nodeType() const;
};

class QgsProcessingToolboxModelProviderNode : QgsProcessingToolboxModelNode
{
%Docstring(signature="appended")
Processing toolbox model node corresponding to a Processing provider.

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:
    QgsProcessingToolboxModelProviderNode( QgsProcessingProvider *provider );
%Docstring
Constructor for QgsProcessingToolboxModelProviderNode, linked to the
specified ``provider``.
%End

    virtual NodeType nodeType() const;

    QgsProcessingProvider *provider();
%Docstring
Returns the provider associated with this node.
%End

    QString providerId() const;
%Docstring
Returns the provider ID.
%End

};

class QgsProcessingToolboxModelGroupNode : QgsProcessingToolboxModelNode
{
%Docstring(signature="appended")
Processing toolbox model node corresponding to a group of algorithms.

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:
    QgsProcessingToolboxModelGroupNode( const QString &id, const QString &name );
%Docstring
Constructor for QgsProcessingToolboxModelGroupNode.

The ``id`` argument specifies the group ID (unique and untranslated),
and the ``name`` argument gives the translated, user-visible name of the
group.
%End

    virtual NodeType nodeType() const;

    QString id() const;
%Docstring
Returns the group's ID, which is unique and untranslated.
%End

    QString name() const;
%Docstring
Returns the group's name, which is translated and user-visible.
%End

};

class QgsProcessingToolboxModelAlgorithmNode : QgsProcessingToolboxModelNode
{
%Docstring(signature="appended")
Processing toolbox model node corresponding to an algorithm.

.. warning::

   Not part of stable API and may change in future QGIS releases.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:
    QgsProcessingToolboxModelAlgorithmNode( const QgsProcessingAlgorithm *algorithm );
%Docstring
Constructor for QgsProcessingToolboxModelAlgorithmNode, associated with
the specified ``algorithm``.
%End

    virtual NodeType nodeType() const;

    const QgsProcessingAlgorithm *algorithm() const;
%Docstring
Returns the algorithm associated with this node.
%End

};


class QgsProcessingToolboxModel : QAbstractItemModel
{
%Docstring(signature="appended")
A model for providers and algorithms shown within the Processing
toolbox.

See :py:class:`QgsProcessingToolboxProxyModel` for a sorted, filterable
version of this model.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:

    enum class CustomRole /BaseType=IntEnum/
    {
      NodeType,
      AlgorithmFlags,
      AlgorithmId,
      AlgorithmName,
      AlgorithmShortDescription,
      AlgorithmTags,
      ProviderFlags,
    };

    QgsProcessingToolboxModel( QObject *parent /TransferThis/ = 0, QgsProcessingRegistry *registry = 0, QgsProcessingRecentAlgorithmLog *recentLog = 0, QgsProcessingFavoriteAlgorithmManager *favoriteManager = 0 );
%Docstring
Constructor for QgsProcessingToolboxModel, with the given ``parent``
object.

If ``registry`` is specified then the model will show providers and
algorithms from the given registry. If no registry is specified, then
the processing registry attached to
:py:func:`QgsApplication.processingRegistry()` will be used by the
model.

If ``recentLog`` is specified then it will be used to create a "Recently
used" top level group containing recently used algorithms.

If ``favoriteManager`` is specified then it will be used to create a
"Favorites" top level group containing favorite algorithms. Since QGIS
3.40
%End

    virtual Qt::ItemFlags flags( const QModelIndex &index ) const;

    virtual QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const;

    virtual int rowCount( const QModelIndex &parent = QModelIndex() ) const;

    virtual int columnCount( const QModelIndex & = QModelIndex() ) const;

    virtual QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const;

    virtual QModelIndex parent( const QModelIndex &index ) const;

    virtual QMimeData *mimeData( const QModelIndexList &indexes ) const;


    QgsProcessingToolboxModelNode *index2node( const QModelIndex &index ) const;
%Docstring
Returns the model node corresponding to the given ``index``.

.. seealso:: :py:func:`node2index`
%End

    QModelIndex node2index( QgsProcessingToolboxModelNode *node ) const;
%Docstring
Returns the model index corresponding to the given ``node``.

.. seealso:: :py:func:`index2node`
%End

    QgsProcessingProvider *providerForIndex( const QModelIndex &index ) const;
%Docstring
Returns the provider which corresponds to a given ``index``, or ``None``
if the index does not represent a provider.

.. seealso:: :py:func:`algorithmForIndex`

.. seealso:: :py:func:`indexForProvider`
%End

    QString providerIdForIndex( const QModelIndex &index ) const;
%Docstring
Returns the provider ID which corresponds to a given ``index``, or an
empty string if the index does not represent a provider.

.. seealso:: :py:func:`algorithmForIndex`

.. seealso:: :py:func:`indexForProvider`
%End

    const QgsProcessingAlgorithm *algorithmForIndex( const QModelIndex &index ) const;
%Docstring
Returns the algorithm which corresponds to a given ``index``, or
``None`` if the index does not represent an algorithm.

.. seealso:: :py:func:`isAlgorithm`

.. seealso:: :py:func:`providerForIndex`
%End

    bool isAlgorithm( const QModelIndex &index ) const;
%Docstring
Returns ``True`` if ``index`` corresponds to an algorithm.

.. seealso:: :py:func:`algorithmForIndex`
%End

    QModelIndex indexForProvider( const QString &providerId ) const;
%Docstring
Returns the index corresponding to the specified ``providerId``.

.. seealso:: :py:func:`providerForIndex`
%End

    QModelIndex indexOfParentTreeNode( QgsProcessingToolboxModelNode *parentNode ) const;
%Docstring
Returns the index corresponding to the parent of a given node.
%End

  signals:

    void recentAlgorithmAdded();
%Docstring
Emitted whenever recent algorithms are added to the model.
%End

    void favoriteAlgorithmAdded();
%Docstring
Emitted whenever favorite algorithms are added to the model.
%End

};


class QgsProcessingToolboxProxyModel : QSortFilterProxyModel
{
%Docstring(signature="appended")
A sort/filter proxy model for providers and algorithms shown within the
Processing toolbox, which automatically sorts the toolbox in a logical
fashion and supports filtering the results.

.. versionadded:: 3.4
%End

%TypeHeaderCode
#include "qgsprocessingtoolboxmodel.h"
%End
  public:

    enum class Filter /BaseType=IntFlag/
    {
      Toolbox,
      Modeler,
      InPlace,
      ShowKnownIssues,
    };
    typedef QFlags<QgsProcessingToolboxProxyModel::Filter> Filters;


    explicit QgsProcessingToolboxProxyModel( QObject *parent /TransferThis/ = 0, QgsProcessingRegistry *registry = 0, QgsProcessingRecentAlgorithmLog *recentLog = 0, QgsProcessingFavoriteAlgorithmManager *favoriteManager = 0 );
%Docstring
Constructor for QgsProcessingToolboxProxyModel, with the given
``parent`` object.

If ``registry`` is specified then the model will show providers and
algorithms from the given registry. If no registry is specified, then
the processing registry attached to
:py:func:`QgsApplication.processingRegistry()` will be used by the
model.

If ``recentLog`` is specified then it will be used to create a "Recently
used" top level group containing recently used algorithms.

If ``favoriteManager`` is specified then it will be used to create a
"Favorites" top level group containing favorite algorithms. SInce QGIS
3.40
%End

    QgsProcessingToolboxModel *toolboxModel();
%Docstring
Returns the underlying source Processing toolbox model.
%End


    void setFilters( QgsProcessingToolboxProxyModel::Filters filters );
%Docstring
Set ``filters`` that affect how toolbox content is filtered.

.. seealso:: :py:func:`filters`
%End

    Filters filters() const;
%Docstring
Returns any filters that affect how toolbox content is filtered.

.. seealso:: :py:func:`setFilters`
%End

    void setInPlaceLayer( QgsVectorLayer *layer );
%Docstring
Sets the vector ``layer`` for in-place algorithm filter
%End

    void setFilterString( const QString &filter );
%Docstring
Sets a ``filter`` string, such that only algorithms matching the
specified string will be shown.

Matches are performed using a variety of tests, including checking
against the algorithm name, short description, tags, etc.

.. seealso:: :py:func:`filterString`
%End

    QString filterString() const;
%Docstring
Returns the current filter string, if set.

.. seealso:: :py:func:`setFilterString`
%End

    virtual bool filterAcceptsRow( int sourceRow, const QModelIndex &sourceParent ) const;

    virtual bool lessThan( const QModelIndex &left, const QModelIndex &right ) const;

    virtual QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const;


};
QFlags<QgsProcessingToolboxProxyModel::Filter> operator|(QgsProcessingToolboxProxyModel::Filter f1, QFlags<QgsProcessingToolboxProxyModel::Filter> f2);


/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/gui/processing/qgsprocessingtoolboxmodel.h                       *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/