mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-08 00:05:09 -04:00
685 lines
21 KiB
Plaintext
685 lines
21 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingwidgetwrapper.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingContextGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
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 QgsProcessingParametersGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
An interface for objects which can create sets of parameter values for
|
|
processing algorithms.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
enum class Flag
|
|
{
|
|
SkipDefaultValueParameters,
|
|
SkipValidation,
|
|
};
|
|
typedef QFlags<QgsProcessingParametersGenerator::Flag> Flags;
|
|
|
|
|
|
virtual QVariantMap createProcessingParameters( QgsProcessingParametersGenerator::Flags flags = QgsProcessingParametersGenerator::Flags() ) = 0;
|
|
%Docstring
|
|
This method needs to be reimplemented in all classes which implement
|
|
this interface and return a algorithm parameters.
|
|
|
|
Since QGIS 3.24 the optional ``flags`` argument can be used to control
|
|
the behavior of the parameter generation.
|
|
%End
|
|
|
|
virtual ~QgsProcessingParametersGenerator();
|
|
};
|
|
|
|
QFlags<QgsProcessingParametersGenerator::Flag> operator|(QgsProcessingParametersGenerator::Flag f1, QFlags<QgsProcessingParametersGenerator::Flag> f2);
|
|
|
|
|
|
|
|
class QgsProcessingParameterWidgetContext
|
|
{
|
|
%Docstring(signature="appended")
|
|
Contains settings which reflect the context in which a Processing
|
|
parameter widget is shown.
|
|
|
|
For instance, the parent model algorithm, a linked map canvas, and other
|
|
relevant information which allows the widget to fine-tune its behavior.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
QgsProcessingParameterWidgetContext();
|
|
|
|
void setMapCanvas( QgsMapCanvas *canvas );
|
|
%Docstring
|
|
Sets the map ``canvas`` associated with the widget. This allows the
|
|
widget to retrieve the current map scale and other properties from the
|
|
canvas.
|
|
|
|
.. seealso:: :py:func:`mapCanvas`
|
|
%End
|
|
|
|
QgsMapCanvas *mapCanvas() const;
|
|
%Docstring
|
|
Returns the map canvas associated with the widget.
|
|
|
|
.. seealso:: :py:func:`setMapCanvas`
|
|
%End
|
|
|
|
void setMessageBar( QgsMessageBar *bar );
|
|
%Docstring
|
|
Sets the message ``bar`` associated with the widget. This allows the
|
|
widget to push feedback messages to the user.
|
|
|
|
.. seealso:: :py:func:`messageBar`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
QgsMessageBar *messageBar() const;
|
|
%Docstring
|
|
Returns the message bar associated with the widget. This allows the
|
|
widget to push feedback messages to the user.
|
|
|
|
.. seealso:: :py:func:`setMessageBar`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setBrowserModel( QgsBrowserGuiModel *model );
|
|
%Docstring
|
|
Sets the browser ``model`` associated with the widget. This will usually
|
|
be the shared app instance of the browser model
|
|
|
|
.. seealso:: :py:func:`browserModel`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
QgsBrowserGuiModel *browserModel() const;
|
|
%Docstring
|
|
Returns the browser model associated with the widget.
|
|
|
|
.. seealso:: :py:func:`setBrowserModel`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setProject( QgsProject *project );
|
|
%Docstring
|
|
Sets the ``project`` associated with the widget. This allows the widget
|
|
to retrieve the map layers and other properties from the correct
|
|
project.
|
|
|
|
.. seealso:: :py:func:`project`
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
QgsProject *project() const;
|
|
%Docstring
|
|
Returns the project associated with the widget.
|
|
|
|
.. seealso:: :py:func:`setProject`
|
|
%End
|
|
|
|
QgsProcessingModelAlgorithm *model() const;
|
|
%Docstring
|
|
Returns the model which the parameter widget is associated with.
|
|
|
|
.. seealso:: :py:func:`setModel`
|
|
|
|
.. seealso:: :py:func:`modelChildAlgorithmId`
|
|
%End
|
|
|
|
void setModel( QgsProcessingModelAlgorithm *model );
|
|
%Docstring
|
|
Sets the ``model`` which the parameter widget is associated with.
|
|
|
|
.. seealso:: :py:func:`model`
|
|
|
|
.. seealso:: :py:func:`setModelChildAlgorithmId`
|
|
%End
|
|
|
|
QString modelChildAlgorithmId() const;
|
|
%Docstring
|
|
Returns the child algorithm ID within the model which the parameter
|
|
widget is associated with.
|
|
|
|
.. seealso:: :py:func:`setModelChildAlgorithmId`
|
|
|
|
.. seealso:: :py:func:`model`
|
|
%End
|
|
|
|
void setModelChildAlgorithmId( const QString &id );
|
|
%Docstring
|
|
Sets the child algorithm ``id`` within the model which the parameter
|
|
widget is associated with.
|
|
|
|
.. seealso:: :py:func:`modelChildAlgorithmId`
|
|
|
|
.. seealso:: :py:func:`setModel`
|
|
%End
|
|
|
|
QgsMapLayer *activeLayer() const;
|
|
%Docstring
|
|
Returns the current active layer.
|
|
|
|
.. seealso:: :py:func:`setActiveLayer`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
void setActiveLayer( QgsMapLayer *layer );
|
|
%Docstring
|
|
Sets the current active ``layer``.
|
|
|
|
.. seealso:: :py:func:`activeLayer`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsAbstractProcessingParameterWidgetWrapper : QObject, QgsExpressionContextGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
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
|
|
:py:func:`QgsGui.processingGuiRegistry()`->:py:func:`~createParameterWidgetWrapper`.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
QgsAbstractProcessingParameterWidgetWrapper( const QgsProcessingParameterDefinition *parameter = 0, Qgis::ProcessingMode type = Qgis::ProcessingMode::Standard, QObject *parent /TransferThis/ = 0 );
|
|
%Docstring
|
|
Constructor for QgsAbstractProcessingParameterWidgetWrapper, for the
|
|
specified ``parameter`` definition and dialog ``type``.
|
|
%End
|
|
|
|
Qgis::ProcessingMode type() const;
|
|
%Docstring
|
|
Returns the dialog type for which widgets and labels will be created by
|
|
this wrapper.
|
|
%End
|
|
|
|
virtual void setWidgetContext( const QgsProcessingParameterWidgetContext &context );
|
|
%Docstring
|
|
Sets the ``context`` in which the Processing parameter widget is shown,
|
|
e.g., the parent model algorithm, a linked map canvas, and other
|
|
relevant information which allows the widget to fine-tune its behavior.
|
|
|
|
Subclasses should take care to call the base class method when
|
|
reimplementing this method.
|
|
|
|
.. seealso:: :py:func:`widgetContext`
|
|
%End
|
|
|
|
const QgsProcessingParameterWidgetContext &widgetContext() const;
|
|
%Docstring
|
|
Returns the context in which the Processing parameter widget is shown,
|
|
e.g., the parent model algorithm, a linked map canvas, and other
|
|
relevant information which allows the widget to fine-tune its behavior.
|
|
|
|
.. seealso:: :py:func:`setWidgetContext`
|
|
%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
|
|
:py:func:`~QgsAbstractProcessingParameterWidgetWrapper.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
|
|
:py:func:`~QgsAbstractProcessingParameterWidgetWrapper.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
|
|
|
|
%Property( name = param, get = parameterDefinition )
|
|
|
|
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
|
|
|
|
virtual QVariantMap customProperties() const;
|
|
%Docstring
|
|
Returns any custom properties set by the wrapper.
|
|
%End
|
|
|
|
virtual void registerProcessingContextGenerator( QgsProcessingContextGenerator *generator );
|
|
%Docstring
|
|
Registers a Processing context ``generator`` class that will be used to
|
|
retrieve a Processing context for the wrapper when required.
|
|
|
|
Care must be taken to call the base class implementation if overwrite
|
|
this method.
|
|
%End
|
|
|
|
void registerProcessingParametersGenerator( QgsProcessingParametersGenerator *generator );
|
|
%Docstring
|
|
Registers a Processing parameters ``generator`` class that will be used
|
|
to retrieve algorithm parameters for the wrapper when required (e.g.
|
|
when a wrapper needs access to other parameter's values).
|
|
|
|
.. versionadded:: 3.14
|
|
%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
|
|
|
|
virtual int stretch() const;
|
|
%Docstring
|
|
Returns the Qt layout "stretch" factor to use when adding this widget to
|
|
a layout.
|
|
|
|
The default implementation returns 0.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
virtual QgsExpressionContext createExpressionContext() const;
|
|
|
|
|
|
virtual void setDialog( QDialog *dialog );
|
|
%Docstring
|
|
Sets the parent ``dialog`` in which the wrapper is shown.
|
|
|
|
.. versionadded:: 3.8
|
|
%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
|
|
|
|
virtual const QgsVectorLayer *linkedVectorLayer() const;
|
|
%Docstring
|
|
Returns the optional vector layer associated with this widget wrapper,
|
|
or ``None`` if no vector layer is applicable.
|
|
|
|
This is used to correctly generate expression contexts within the GUI,
|
|
e.g. to allow expression buttons and property override buttons to
|
|
correctly show the appropriate vector layer fields.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
protected:
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterWidgetFactoryInterface
|
|
{
|
|
%Docstring(signature="appended")
|
|
An interface for Processing widget wrapper factories.
|
|
|
|
Widget wrapper factories allow creation of
|
|
:py:class:`QgsAbstractProcessingParameterWidgetWrapper` objects. They
|
|
are centrally managed by :py:class:`QgsProcessingGuiRegistry`. Usually,
|
|
individual factories are not directly utilized, rather the
|
|
:py:func:`QgsGui.processingGuiRegistry()`->:py:func:`~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, Qgis::ProcessingMode 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
|
|
|
|
virtual QgsProcessingAbstractParameterDefinitionWidget *createParameterDefinitionWidget(
|
|
QgsProcessingContext &context,
|
|
const QgsProcessingParameterWidgetContext &widgetContext,
|
|
const QgsProcessingParameterDefinition *definition = 0,
|
|
const QgsProcessingAlgorithm *algorithm = 0
|
|
) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter definition widget allowing for configuration of
|
|
an instance of the parameter type handled by this factory.
|
|
|
|
The ``context`` argument must specify a Processing context, which will
|
|
be used by the widget to evaluate existing ``definition`` properties
|
|
such as default values. Similarly, the ``widgetContext`` argument
|
|
specifies the wider GUI context in which the widget will be used.
|
|
|
|
The optional ``definition`` argument may specify a parameter definition
|
|
which should be reflected in the initial state of the returned widget.
|
|
Subclasses must ensure that they correctly handle both the case when a
|
|
initial ``definition`` is passed, or when ``definition`` is ``None`` (in
|
|
which case sensible defaults should be shown in the returned widget).
|
|
|
|
Additionally, the optional ``algorithm`` parameter may be used to
|
|
specify the algorithm or model associated with the parameter.
|
|
|
|
If a factory subclass returns ``None`` for this method (i.e. as the base
|
|
class implementation does), it indicates that the parameter type cannot
|
|
be configured via GUI. In this case the parameter type will not be
|
|
configurable when users add it as an input to their graphical models.
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
protected:
|
|
virtual QStringList compatibleParameterTypes() const;
|
|
%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;
|
|
%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 QgsProcessingParameterDefinition *parameter ) const;
|
|
%Docstring
|
|
Returns a list of compatible Processing data types for inputs for this
|
|
widget for the specified ``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
|
|
:py:class:`QgsProcessing`.SourceType.
|
|
|
|
Subclasses should return a list of all
|
|
:py:class:`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
|
|
|
|
virtual Qgis::ProcessingModelChildParameterSource defaultModelSource( const QgsProcessingParameterDefinition *parameter ) const;
|
|
%Docstring
|
|
Returns the default source type to use for the widget for the specified
|
|
``parameter``.
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
};
|
|
|
|
class QgsProcessingHiddenWidgetWrapper : QgsAbstractProcessingParameterWidgetWrapper
|
|
{
|
|
%Docstring(signature="appended")
|
|
A widget wrapper for hidden widgets.
|
|
|
|
The hidden widget wrapper allows for creation of a widget wrapper which
|
|
does not provide a graphical widget, yet still implements the
|
|
:py:class:`QgsAbstractProcessingParameterWidgetWrapper` interface.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingwidgetwrapper.h"
|
|
%End
|
|
public:
|
|
QgsProcessingHiddenWidgetWrapper( const QgsProcessingParameterDefinition *parameter = 0, Qgis::ProcessingMode type = Qgis::ProcessingMode::Standard, QObject *parent /TransferThis/ = 0 );
|
|
%Docstring
|
|
Constructor for QgsProcessingHiddenWidgetWrapper, for the specified
|
|
``parameter`` definition and dialog ``type``.
|
|
%End
|
|
|
|
virtual void setWidgetValue( const QVariant &value, QgsProcessingContext &context );
|
|
|
|
virtual QVariant widgetValue() const;
|
|
|
|
|
|
virtual const QgsVectorLayer *linkedVectorLayer() const;
|
|
|
|
|
|
void setLinkedVectorLayer( const QgsVectorLayer *layer );
|
|
%Docstring
|
|
Sets the vector layer linked to the wrapper.
|
|
%End
|
|
|
|
protected:
|
|
virtual QWidget *createWidget();
|
|
|
|
virtual QLabel *createLabel();
|
|
|
|
|
|
};
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/gui/processing/qgsprocessingwidgetwrapper.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|