mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-26 00:02:08 -05:00
0396162d1f
This change "dims" the results from the SAGA provider when a search is made in the toolbox, to visually push users towards picking alternative algorithms instead. The Processing implementation of SAGA algorithms are a constant source of critical bugs for users, causing incorrect analysis results. There's zero community interest in actively maintaining this provider, so we need to take steps to push users to stop picking these algorithms wherever alternative (QGIS/GRASS/GDAL based) equivalents exist. And for 4.0, seriously re-consider dropping this provider from the out of the box install. We are causing more harm then good by offering it to users.
464 lines
12 KiB
Plaintext
464 lines
12 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingtoolboxmodel.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingToolboxModelNode : QObject
|
|
{
|
|
%Docstring
|
|
Abstract base class for nodes contained within a 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::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;
|
|
%End
|
|
public:
|
|
|
|
enum NodeType
|
|
{
|
|
NodeProvider,
|
|
NodeGroup,
|
|
NodeAlgorithm,
|
|
NodeRecent,
|
|
};
|
|
|
|
~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
|
|
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();
|
|
%Docstring
|
|
Constructor for QgsProcessingToolboxModelRecentNode.
|
|
%End
|
|
|
|
virtual NodeType nodeType() const;
|
|
|
|
};
|
|
|
|
class QgsProcessingToolboxModelProviderNode : QgsProcessingToolboxModelNode
|
|
{
|
|
%Docstring
|
|
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
|
|
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
|
|
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
|
|
A model for providers and algorithms shown within the Processing toolbox.
|
|
|
|
See QgsProcessingToolboxProxyModel for a sorted, filterable version
|
|
of this model.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingtoolboxmodel.h"
|
|
%End
|
|
public:
|
|
|
|
enum Roles
|
|
{
|
|
RoleNodeType,
|
|
RoleAlgorithmFlags,
|
|
RoleAlgorithmId,
|
|
RoleAlgorithmName,
|
|
RoleAlgorithmShortDescription,
|
|
RoleAlgorithmTags,
|
|
RoleProviderFlags,
|
|
};
|
|
|
|
QgsProcessingToolboxModel( QObject *parent /TransferThis/ = 0, QgsProcessingRegistry *registry = 0,
|
|
QgsProcessingRecentAlgorithmLog *recentLog = 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 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.
|
|
%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
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingToolboxProxyModel: QSortFilterProxyModel
|
|
{
|
|
%Docstring
|
|
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 Filter
|
|
{
|
|
FilterToolbox,
|
|
FilterModeler,
|
|
FilterInPlace,
|
|
FilterShowKnownIssues,
|
|
};
|
|
typedef QFlags<QgsProcessingToolboxProxyModel::Filter> Filters;
|
|
|
|
|
|
explicit QgsProcessingToolboxProxyModel( QObject *parent /TransferThis/ = 0,
|
|
QgsProcessingRegistry *registry = 0,
|
|
QgsProcessingRecentAlgorithmLog *recentLog = 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 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.
|
|
%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;
|
|
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingtoolboxmodel.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|