mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-01 00:46:20 -05:00
330 lines
11 KiB
Plaintext
330 lines
11 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingwidgetwrapper.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingContextGenerator
|
|
{
|
|
%Docstring
|
|
|
|
An interface for objects which can create Processing contexts.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
|
|
virtual QgsProcessingContext *processingContext() = 0;
|
|
%Docstring
|
|
This method needs to be reimplemented in all classes which implement this interface
|
|
and return a Processing context.
|
|
|
|
Note that ownership of the context is not transferred - it is intended that subclasses
|
|
return a pointer to a context which they have already created and own.
|
|
%End
|
|
|
|
virtual ~QgsProcessingContextGenerator();
|
|
};
|
|
|
|
class QgsAbstractProcessingParameterWidgetWrapper : QObject
|
|
{
|
|
%Docstring
|
|
|
|
A widget wrapper for Processing parameter value widgets.
|
|
|
|
Widget wrappers are used to create widgets for individual Processing parameters, and
|
|
handle retrieving and setting the current value for those parameters.
|
|
|
|
Widget wrappers can be created for different dialog types, allowing different
|
|
appearance and behavior of widgets depending on whether they are being created for
|
|
use in a standard algorithm dialog, a batch processing dialog, or a modeler dialog.
|
|
|
|
Individual widget wrappers are not usually created directly, instead they are
|
|
constructed through the central registry, via calls to
|
|
QgsGui.processingGuiRegistry()->createParameterWidgetWrapper().
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
|
|
QgsAbstractProcessingParameterWidgetWrapper( const QgsProcessingParameterDefinition *parameter = 0,
|
|
QgsProcessingGui::WidgetType type = QgsProcessingGui::Standard, QObject *parent /TransferThis/ = 0 );
|
|
%Docstring
|
|
Constructor for QgsAbstractProcessingParameterWidgetWrapper, for the specified
|
|
``parameter`` definition and dialog ``type``.
|
|
%End
|
|
|
|
QgsProcessingGui::WidgetType type() const;
|
|
%Docstring
|
|
Returns the dialog type for which widgets and labels will be created by this wrapper.
|
|
%End
|
|
|
|
QWidget *createWrappedWidget( QgsProcessingContext &context ) /Factory/;
|
|
%Docstring
|
|
Creates and return a new wrapped widget which allows customization of the parameter's value.
|
|
|
|
The caller takes ownership of the returned widget. The wrapped widget can be retrieved at a later
|
|
stage by calling wrappedWidget().
|
|
|
|
The supplied ``context`` is used while initializing the widget to the parameter's default value.
|
|
|
|
.. seealso:: :py:func:`createWrappedLabel`
|
|
%End
|
|
|
|
QLabel *createWrappedLabel() /Factory/;
|
|
%Docstring
|
|
Creates and returns a new label to accompany widgets created by the wrapper.
|
|
|
|
The caller takes ownership of the returned label. Some parameter type and dialog type
|
|
combinations will return None for this method. If None is returned, then no
|
|
label should be shown for the parameter's widget (i.e. the label is embedded inside the
|
|
widget itself).
|
|
|
|
The wrapped label can be retrieved at a later stage by calling wrappedLabel().
|
|
|
|
.. seealso:: :py:func:`createWrappedWidget`
|
|
%End
|
|
|
|
QWidget *wrappedWidget();
|
|
%Docstring
|
|
Returns the current wrapped widget, if any.
|
|
|
|
.. seealso:: :py:func:`createWrappedWidget`
|
|
%End
|
|
|
|
QLabel *wrappedLabel();
|
|
%Docstring
|
|
Returns the current wrapped label, if any.
|
|
|
|
.. seealso:: :py:func:`createWrappedLabel`
|
|
%End
|
|
|
|
const QgsProcessingParameterDefinition *parameterDefinition() const;
|
|
%Docstring
|
|
Returns the parameter definition associated with this wrapper.
|
|
%End
|
|
|
|
void setParameterValue( const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Sets the current ``value`` for the parameter.
|
|
|
|
The ``context`` argument is used to specify the wider Processing context which the
|
|
current value is associated with.
|
|
|
|
.. seealso:: :py:func:`parameterValue`
|
|
%End
|
|
|
|
QVariant parameterValue() const;
|
|
%Docstring
|
|
Returns the current value of the parameter.
|
|
|
|
.. seealso:: :py:func:`setParameterValue`
|
|
%End
|
|
|
|
void registerProcessingContextGenerator( QgsProcessingContextGenerator *generator );
|
|
%Docstring
|
|
Register a Processing context generator class that will be used to retrieve
|
|
a Processing context for the wrapper when required.
|
|
%End
|
|
|
|
virtual void postInitialize( const QList< QgsAbstractProcessingParameterWidgetWrapper * > &wrappers );
|
|
%Docstring
|
|
Called after all wrappers have been created within a particular dialog or context,
|
|
allowing the wrapper to connect to the wrappers of other, related parameters.
|
|
%End
|
|
|
|
signals:
|
|
|
|
|
|
void widgetValueHasChanged( QgsAbstractProcessingParameterWidgetWrapper *wrapper );
|
|
%Docstring
|
|
Emitted whenever the parameter value (as defined by the wrapped widget) is changed.
|
|
%End
|
|
|
|
protected:
|
|
|
|
virtual QWidget *createWidget() = 0 /Factory/;
|
|
%Docstring
|
|
Creates a new widget which allows customization of the parameter's value.
|
|
|
|
The caller takes ownership of the returned widget.
|
|
|
|
.. seealso:: :py:func:`createLabel`
|
|
%End
|
|
|
|
virtual QLabel *createLabel() /Factory/;
|
|
%Docstring
|
|
Creates a new label to accompany widgets created by the wrapper.
|
|
|
|
The caller takes ownership of the returned label. Some parameter type and dialog type
|
|
combinations will return None for this method. If None is returned, then no
|
|
label should be shown for the parameter's widget (i.e. the label is embedded inside the
|
|
widget itself).
|
|
|
|
.. seealso:: :py:func:`createWidget`
|
|
%End
|
|
|
|
virtual void setWidgetValue( const QVariant &value, QgsProcessingContext &context ) = 0;
|
|
%Docstring
|
|
Sets the current ``value`` for the parameter to show in the widget.
|
|
|
|
The ``context`` argument is used to specify the wider Processing context which the
|
|
current value is associated with.
|
|
|
|
.. seealso:: :py:func:`widgetValue`
|
|
%End
|
|
|
|
virtual QVariant widgetValue() const = 0;
|
|
%Docstring
|
|
Returns the current value of the parameter.
|
|
|
|
.. seealso:: :py:func:`setWidgetValue`
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterWidgetFactoryInterface
|
|
{
|
|
%Docstring
|
|
|
|
An interface for Processing widget wrapper factories.
|
|
|
|
Widget wrapper factories allow creation of QgsAbstractProcessingParameterWidgetWrapper objects.
|
|
They are centrally managed by :py:class:`QgsProcessingGuiRegistry`. Usually, individual factories
|
|
are not directly utilized, rather the QgsGui.processingGuiRegistry()->createParameterWidgetWrapper()
|
|
method is used to create widget wrappers.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
|
|
virtual ~QgsProcessingParameterWidgetFactoryInterface();
|
|
|
|
virtual QString parameterType() const = 0;
|
|
%Docstring
|
|
Returns the type string for the parameter type the factory is associated with.
|
|
%End
|
|
|
|
virtual QgsAbstractProcessingParameterWidgetWrapper *createWidgetWrapper( const QgsProcessingParameterDefinition *parameter,
|
|
QgsProcessingGui::WidgetType type ) = 0 /Factory/;
|
|
%Docstring
|
|
Creates a new widget wrapper for the specified ``parameter`` definition.
|
|
|
|
The ``type`` argument indicates the dialog type to create a wrapper for.
|
|
|
|
.. seealso:: :py:func:`createModelerWidgetWrapper`
|
|
%End
|
|
|
|
virtual QgsProcessingModelerParameterWidget *createModelerWidgetWrapper( QgsProcessingModelAlgorithm *model,
|
|
const QString &childId,
|
|
const QgsProcessingParameterDefinition *parameter,
|
|
QgsProcessingContext &context );
|
|
%Docstring
|
|
Creates a new modeler parameter widget for the given ``parameter``. This widget allows
|
|
configuration of the parameter's value when used inside a Processing ``model``.
|
|
|
|
The ID of the child algorithm within the model must be specified via the ``childId``
|
|
argument. This value corresponds to the :py:func:`QgsProcessingModelChildAlgorithm.childId()`
|
|
string, which uniquely identifies which child algorithm the parameter is associated
|
|
with inside the given ``model``.
|
|
|
|
A Processing ``context`` must also be specified, which allows the widget
|
|
to resolve parameter values which are context dependent. The context must
|
|
last for the lifetime of the widget.
|
|
|
|
.. seealso:: :py:func:`createWidgetWrapper`
|
|
%End
|
|
|
|
protected:
|
|
|
|
virtual QStringList compatibleParameterTypes() const = 0;
|
|
%Docstring
|
|
Returns a list of compatible Processing parameter types for inputs
|
|
for this parameter.
|
|
|
|
In order to determine the available sources for the parameter in a model
|
|
the types returned by this method are checked. The returned list corresponds to the
|
|
various available values for :py:func:`QgsProcessingParameterDefinition.type()`
|
|
|
|
Subclasses should return a list of all :py:func:`QgsProcessingParameterDefinition.type()`
|
|
values which can be used as input values for the parameter.
|
|
|
|
.. seealso:: :py:func:`compatibleOutputTypes`
|
|
|
|
.. seealso:: :py:func:`compatibleDataTypes`
|
|
%End
|
|
|
|
virtual QStringList compatibleOutputTypes() const = 0;
|
|
%Docstring
|
|
Returns a list of compatible Processing output types for inputs
|
|
for this parameter.
|
|
|
|
In order to determine the available sources for the parameter in a model
|
|
the types returned by this method are checked. The returned list corresponds to the
|
|
various available values for :py:func:`QgsProcessingOutputDefinition.type()`
|
|
|
|
Subclasses should return a list of all :py:func:`QgsProcessingOutputDefinition.type()`
|
|
values which can be used as values for the parameter.
|
|
|
|
.. seealso:: :py:func:`compatibleParameterTypes`
|
|
|
|
.. seealso:: :py:func:`compatibleDataTypes`
|
|
%End
|
|
|
|
virtual QList< int > compatibleDataTypes() const = 0;
|
|
%Docstring
|
|
Returns a list of compatible Processing data types for inputs
|
|
for this parameter.
|
|
|
|
In order to determine the available sources for the parameter in a model
|
|
the types returned by this method are checked. The returned list corresponds
|
|
to the various available values from QgsProcessing.SourceType.
|
|
|
|
Subclasses should return a list of all QgsProcessing.SourceType
|
|
values which can be used as values for the parameter.
|
|
|
|
.. seealso:: :py:func:`compatibleParameterTypes`
|
|
|
|
.. seealso:: :py:func:`compatibleOutputTypes`
|
|
%End
|
|
|
|
virtual QString modelerExpressionFormatString() const;
|
|
%Docstring
|
|
Returns the expected expression format string for expression results for the parameter
|
|
within model child algorithms.
|
|
|
|
This is shown in modeler widget wrappers when using the "pre-calculated" expression mode,
|
|
and should give helpful text to users to indicate the expected results from the expression.
|
|
|
|
This is purely a text format and no expression validation is made against it.
|
|
%End
|
|
|
|
};
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingwidgetwrapper.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|