/************************************************************************
 * 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,
    };
    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, e.g., 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, 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

    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, 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

    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 = 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 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")
An 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, QgsProcessingGui::WidgetType type = QgsProcessingGui::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   *
 ************************************************************************/