mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-08 00:05:09 -04:00
583 lines
16 KiB
Plaintext
583 lines
16 KiB
Plaintext
/************************************************************************
|
|
* 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::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;
|
|
%End
|
|
public:
|
|
|
|
enum class NodeType
|
|
{
|
|
Provider,
|
|
Group,
|
|
Algorithm,
|
|
Recent,
|
|
Parameter,
|
|
ParameterGroup,
|
|
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 QgsProcessingToolboxModelParameterGroupNode : QgsProcessingToolboxModelNode
|
|
{
|
|
%Docstring(signature="appended")
|
|
Processing toolbox model node corresponding to the parameter group.
|
|
|
|
.. warning::
|
|
|
|
Not part of stable API and may change in future QGIS releases.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingtoolboxmodel.h"
|
|
%End
|
|
public:
|
|
QgsProcessingToolboxModelParameterGroupNode();
|
|
|
|
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 QgsProcessingToolboxModelParameterNode : QgsProcessingToolboxModelNode
|
|
{
|
|
%Docstring(signature="appended")
|
|
Processing toolbox model node corresponding to a parameter.
|
|
|
|
.. warning::
|
|
|
|
Not part of stable API and may change in future QGIS releases.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingtoolboxmodel.h"
|
|
%End
|
|
public:
|
|
QgsProcessingToolboxModelParameterNode( const QgsProcessingParameterType *paramType );
|
|
%Docstring
|
|
Constructor for QgsProcessingToolboxModelParameterNode, associated with
|
|
the specified ``paramType``.
|
|
%End
|
|
|
|
virtual NodeType nodeType() const;
|
|
|
|
const QgsProcessingParameterType *parameterType() const;
|
|
%Docstring
|
|
Returns the parameter type 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
|
|
{
|
|
NodeType,
|
|
AlgorithmFlags,
|
|
AlgorithmId,
|
|
AlgorithmName,
|
|
AlgorithmShortDescription,
|
|
AlgorithmTags,
|
|
ProviderFlags,
|
|
ParameterTypeId,
|
|
};
|
|
|
|
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
|
|
|
|
const QgsProcessingParameterType *parameterTypeForIndex( 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:`isParameter`
|
|
|
|
.. seealso:: :py:func:`providerForIndex`
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
bool isParameter( const QModelIndex &index ) const;
|
|
%Docstring
|
|
Returns ``True`` if ``index`` corresponds to a parameter.
|
|
|
|
.. seealso:: :py:func:`parameterTypeForIndex`
|
|
|
|
.. versionadded:: 3.44
|
|
%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 proxy model for providers and algorithms shown within the Processing
|
|
toolbox.
|
|
|
|
The model 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
|
|
{
|
|
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 *
|
|
************************************************************************/
|