mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-25 00:05:24 -04:00
1fbba79a0f
[processing] Infrastructure for QgsMeshLayer to add processing algorithms, dataset group paramater and dataset time parameter to allow the user to easily choose a dataset.
622 lines
19 KiB
Plaintext
622 lines
19 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingcontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingContext
|
|
{
|
|
%Docstring
|
|
Contains information about the context in which a processing algorithm is executed.
|
|
|
|
Contextual information includes settings such as the associated project, and
|
|
expression context.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingcontext.h"
|
|
%End
|
|
public:
|
|
|
|
enum Flag
|
|
{
|
|
// UseSelectionIfPresent = 1 << 0,
|
|
};
|
|
typedef QFlags<QgsProcessingContext::Flag> Flags;
|
|
|
|
|
|
QgsProcessingContext();
|
|
%Docstring
|
|
Constructor for QgsProcessingContext.
|
|
%End
|
|
|
|
|
|
~QgsProcessingContext();
|
|
|
|
void copyThreadSafeSettings( const QgsProcessingContext &other );
|
|
%Docstring
|
|
Copies all settings which are safe for use across different threads from
|
|
``other`` to this context.
|
|
%End
|
|
|
|
QgsProcessingContext::Flags flags() const;
|
|
%Docstring
|
|
Returns any flags set in the context.
|
|
|
|
.. seealso:: :py:func:`setFlags`
|
|
%End
|
|
|
|
void setFlags( QgsProcessingContext::Flags flags );
|
|
%Docstring
|
|
Sets ``flags`` for the context.
|
|
|
|
.. seealso:: :py:func:`flags`
|
|
%End
|
|
|
|
QgsProject *project() const;
|
|
%Docstring
|
|
Returns the project in which the algorithm is being executed.
|
|
|
|
.. seealso:: :py:func:`setProject`
|
|
%End
|
|
|
|
void setProject( QgsProject *project );
|
|
%Docstring
|
|
Sets the ``project`` in which the algorithm will be executed.
|
|
|
|
This also automatically sets the :py:func:`~QgsProcessingContext.transformContext`, :py:func:`~QgsProcessingContext.ellipsoid`, :py:func:`~QgsProcessingContext.distanceUnit` and
|
|
:py:func:`~QgsProcessingContext.areaUnit` to match the project's settings.
|
|
|
|
.. seealso:: :py:func:`project`
|
|
%End
|
|
|
|
QgsExpressionContext &expressionContext();
|
|
%Docstring
|
|
Returns the expression context.
|
|
%End
|
|
|
|
|
|
void setExpressionContext( const QgsExpressionContext &context );
|
|
%Docstring
|
|
Sets the expression ``context``.
|
|
%End
|
|
|
|
QgsCoordinateTransformContext transformContext() const;
|
|
%Docstring
|
|
Returns the coordinate transform context.
|
|
|
|
.. seealso:: :py:func:`setTransformContext`
|
|
%End
|
|
|
|
void setTransformContext( const QgsCoordinateTransformContext &context );
|
|
%Docstring
|
|
Sets the coordinate transform ``context``.
|
|
|
|
Note that setting a project for the context will automatically set the coordinate transform
|
|
context.
|
|
|
|
.. seealso:: :py:func:`transformContext`
|
|
%End
|
|
|
|
QString ellipsoid() const;
|
|
%Docstring
|
|
Returns the ellipsoid to use for distance and area calculations.
|
|
|
|
.. seealso:: :py:func:`setEllipsoid`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setEllipsoid( const QString &ellipsoid );
|
|
%Docstring
|
|
Sets a specified ``ellipsoid`` to use for distance and area calculations.
|
|
|
|
If not explicitly set, the ellipsoid will default to the :py:func:`~QgsProcessingContext.project`'s ellipsoid setting.
|
|
|
|
.. seealso:: :py:func:`ellipsoid`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QgsUnitTypes::DistanceUnit distanceUnit() const;
|
|
%Docstring
|
|
Returns the distance unit to use for distance calculations.
|
|
|
|
.. seealso:: :py:func:`setDistanceUnit`
|
|
|
|
.. seealso:: :py:func:`areaUnit`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setDistanceUnit( QgsUnitTypes::DistanceUnit unit );
|
|
%Docstring
|
|
Sets the ``unit`` to use for distance calculations.
|
|
|
|
If not explicitly set, the unit will default to the :py:func:`~QgsProcessingContext.project`'s distance unit setting.
|
|
|
|
.. seealso:: :py:func:`distanceUnit`
|
|
|
|
.. seealso:: :py:func:`setAreaUnit`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QgsUnitTypes::AreaUnit areaUnit() const;
|
|
%Docstring
|
|
Returns the area unit to use for area calculations.
|
|
|
|
.. seealso:: :py:func:`setAreaUnit`
|
|
|
|
.. seealso:: :py:func:`distanceUnit`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setAreaUnit( QgsUnitTypes::AreaUnit areaUnit );
|
|
%Docstring
|
|
Sets the ``unit`` to use for area calculations.
|
|
|
|
If not explicitly set, the unit will default to the :py:func:`~QgsProcessingContext.project`'s area unit setting.
|
|
|
|
.. seealso:: :py:func:`areaUnit`
|
|
|
|
.. seealso:: :py:func:`setDistanceUnit`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QgsDateTimeRange currentTimeRange() const;
|
|
%Docstring
|
|
Returns the current time range to use for temporal operations.
|
|
|
|
.. seealso:: :py:func:`setCurrentTimeRange`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
void setCurrentTimeRange( const QgsDateTimeRange ¤tTimeRange );
|
|
%Docstring
|
|
Sets the ``current`` time range to use for temporal operations.
|
|
|
|
.. seealso:: :py:func:`currentTimeRange`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
QgsMapLayerStore *temporaryLayerStore();
|
|
%Docstring
|
|
Returns a reference to the layer store used for storing temporary layers during
|
|
algorithm execution.
|
|
%End
|
|
|
|
class LayerDetails
|
|
{
|
|
%Docstring
|
|
Details for layers to load into projects.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingcontext.h"
|
|
%End
|
|
public:
|
|
|
|
LayerDetails( const QString &name, QgsProject *project, const QString &outputName = QString(), QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType );
|
|
%Docstring
|
|
Constructor for LayerDetails.
|
|
%End
|
|
|
|
LayerDetails();
|
|
%Docstring
|
|
Default constructor
|
|
%End
|
|
|
|
QString name;
|
|
|
|
bool forceName;
|
|
|
|
QString outputName;
|
|
|
|
QgsProcessingUtils::LayerHint layerTypeHint;
|
|
|
|
QgsProcessingLayerPostProcessorInterface *postProcessor() const;
|
|
%Docstring
|
|
Layer post-processor. May be ``None`` if no post-processing is required.
|
|
|
|
.. seealso:: :py:func:`setPostProcessor`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
void setPostProcessor( QgsProcessingLayerPostProcessorInterface *processor /Transfer/ );
|
|
%Docstring
|
|
Sets the layer post-processor. May be ``None`` if no post-processing is required.
|
|
|
|
Ownership of ``processor`` is transferred.
|
|
|
|
.. seealso:: :py:func:`postProcessor`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
void setOutputLayerName( QgsMapLayer *layer ) const;
|
|
%Docstring
|
|
Sets a ``layer`` name to match this output, respecting any local user settings which affect this name.
|
|
|
|
.. versionadded:: 3.10.1
|
|
%End
|
|
|
|
QgsProject *project;
|
|
|
|
};
|
|
|
|
QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const;
|
|
%Docstring
|
|
Returns a map of layers (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model.
|
|
|
|
.. seealso:: :py:func:`setLayersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`addLayerToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`willLoadLayerOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layerToLoadOnCompletionDetails`
|
|
%End
|
|
|
|
bool willLoadLayerOnCompletion( const QString &layer ) const;
|
|
%Docstring
|
|
Returns ``True`` if the given ``layer`` (by ID or datasource) will be loaded into the current project
|
|
upon completion of the algorithm or model.
|
|
|
|
.. seealso:: :py:func:`layersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`setLayersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`addLayerToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layerToLoadOnCompletionDetails`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
void setLayersToLoadOnCompletion( const QMap< QString, QgsProcessingContext::LayerDetails > &layers );
|
|
%Docstring
|
|
Sets the map of ``layers`` (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model.
|
|
|
|
.. seealso:: :py:func:`addLayerToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`willLoadLayerOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layerToLoadOnCompletionDetails`
|
|
%End
|
|
|
|
void addLayerToLoadOnCompletion( const QString &layer, const QgsProcessingContext::LayerDetails &details );
|
|
%Docstring
|
|
Adds a ``layer`` to load (by ID or datasource) into the canvas upon completion of the algorithm or model.
|
|
The ``details`` parameter dictates the LayerDetails.
|
|
|
|
.. seealso:: :py:func:`setLayersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`willLoadLayerOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layerToLoadOnCompletionDetails`
|
|
%End
|
|
|
|
QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer );
|
|
%Docstring
|
|
Returns a reference to the details for a given ``layer`` which is loaded on completion of the
|
|
algorithm or model.
|
|
|
|
.. warning::
|
|
|
|
First check :py:func:`~QgsProcessingContext.willLoadLayerOnCompletion`, or calling this method will incorrectly
|
|
add ``layer`` as a layer to load on completion.
|
|
|
|
.. seealso:: :py:func:`willLoadLayerOnCompletion`
|
|
|
|
.. seealso:: :py:func:`addLayerToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`setLayersToLoadOnCompletion`
|
|
|
|
.. seealso:: :py:func:`layersToLoadOnCompletion`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
QgsFeatureRequest::InvalidGeometryCheck invalidGeometryCheck() const;
|
|
%Docstring
|
|
Returns the behavior used for checking invalid geometries in input layers.
|
|
|
|
.. seealso:: :py:func:`setInvalidGeometryCheck`
|
|
%End
|
|
|
|
void setInvalidGeometryCheck( QgsFeatureRequest::InvalidGeometryCheck check );
|
|
%Docstring
|
|
Sets the behavior used for checking invalid geometries in input layers.
|
|
Settings this to anything but QgsFeatureRequest.GeometryNoCheck will also
|
|
reset the :py:func:`~QgsProcessingContext.invalidGeometryCallback` to a default implementation.
|
|
|
|
.. seealso:: :py:func:`invalidGeometryCheck`
|
|
%End
|
|
|
|
void setInvalidGeometryCallback( SIP_PYCALLABLE / AllowNone / );
|
|
%Docstring
|
|
Sets a callback function to use when encountering an invalid geometry and
|
|
:py:func:`~QgsProcessingContext.invalidGeometryCheck` is set to GeometryAbortOnInvalid. This function will be
|
|
called using the feature with invalid geometry as a parameter.
|
|
|
|
.. seealso:: :py:func:`invalidGeometryCallback`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
%MethodCode
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
sipCpp->setInvalidGeometryCallback( [a0]( const QgsFeature &arg )
|
|
{
|
|
SIP_BLOCK_THREADS
|
|
Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
|
|
SIP_UNBLOCK_THREADS
|
|
} );
|
|
|
|
Py_END_ALLOW_THREADS
|
|
%End
|
|
|
|
|
|
|
|
void setTransformErrorCallback( SIP_PYCALLABLE / AllowNone / );
|
|
%Docstring
|
|
Sets a callback function to use when encountering a transform error when iterating
|
|
features. This function will be
|
|
called using the feature which encountered the transform error as a parameter.
|
|
|
|
.. seealso:: :py:func:`transformErrorCallback`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
%MethodCode
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
sipCpp->setTransformErrorCallback( [a0]( const QgsFeature &arg )
|
|
{
|
|
SIP_BLOCK_THREADS
|
|
Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
|
|
SIP_UNBLOCK_THREADS
|
|
} );
|
|
|
|
Py_END_ALLOW_THREADS
|
|
%End
|
|
|
|
|
|
QString defaultEncoding() const;
|
|
%Docstring
|
|
Returns the default encoding to use for newly created files.
|
|
|
|
.. seealso:: :py:func:`setDefaultEncoding`
|
|
%End
|
|
|
|
void setDefaultEncoding( const QString &encoding );
|
|
%Docstring
|
|
Sets the default ``encoding`` to use for newly created files.
|
|
|
|
.. seealso:: :py:func:`defaultEncoding`
|
|
%End
|
|
|
|
QgsProcessingFeedback *feedback();
|
|
%Docstring
|
|
Returns the associated feedback object.
|
|
|
|
.. seealso:: :py:func:`setFeedback`
|
|
%End
|
|
|
|
void setFeedback( QgsProcessingFeedback *feedback );
|
|
%Docstring
|
|
Sets an associated ``feedback`` object. This allows context related functions
|
|
to report feedback and errors to users and processing logs. While ideally this feedback
|
|
object should outlive the context, only a weak pointer to ``feedback`` is stored
|
|
and no errors will occur if feedback is deleted before the context.
|
|
Ownership of ``feedback`` is not transferred.
|
|
|
|
.. seealso:: :py:func:`setFeedback`
|
|
%End
|
|
|
|
QThread *thread();
|
|
%Docstring
|
|
Returns the thread in which the context lives.
|
|
|
|
.. seealso:: :py:func:`pushToThread`
|
|
%End
|
|
|
|
void pushToThread( QThread *thread );
|
|
%Docstring
|
|
Pushes the thread affinity for the context (including all layers contained in the :py:func:`~QgsProcessingContext.temporaryLayerStore`) into
|
|
another ``thread``. This method is only safe to call when the current thread matches the existing thread
|
|
affinity for the context (see :py:func:`~QgsProcessingContext.thread`).
|
|
|
|
.. seealso:: :py:func:`thread`
|
|
%End
|
|
|
|
void takeResultsFrom( QgsProcessingContext &context );
|
|
%Docstring
|
|
Takes the results from another ``context`` and merges them with the results currently
|
|
stored in this context. This includes settings like any layers loaded in the :py:func:`~QgsProcessingContext.temporaryLayerStore`
|
|
and :py:func:`~QgsProcessingContext.layersToLoadOnCompletion`.
|
|
This is only safe to call when both this context and the other ``context`` share the same
|
|
:py:func:`~QgsProcessingContext.thread` affinity, and that thread is the current thread.
|
|
%End
|
|
|
|
QgsMapLayer *getMapLayer( const QString &identifier );
|
|
%Docstring
|
|
Returns a map layer from the context with a matching ``identifier``.
|
|
This method considers layer IDs, names and sources when matching
|
|
the ``identifier`` (see :py:func:`QgsProcessingUtils.mapLayerFromString()`
|
|
for details).
|
|
|
|
Ownership is not transferred and remains with the context.
|
|
|
|
.. seealso:: :py:func:`takeResultLayer`
|
|
%End
|
|
|
|
QgsMapLayer *takeResultLayer( const QString &id ) /TransferBack/;
|
|
%Docstring
|
|
Takes the result map layer with matching ``id`` from the context and
|
|
transfers ownership of it back to the caller. This method can be used
|
|
to remove temporary layers which are not required for further processing
|
|
from a context.
|
|
|
|
.. seealso:: :py:func:`getMapLayer`
|
|
%End
|
|
|
|
QString preferredVectorFormat() const;
|
|
%Docstring
|
|
Returns the preferred vector format to use for vector outputs.
|
|
|
|
This method returns a file extension to use when creating vector outputs (e.g. "shp"). Generally,
|
|
it is preferable to use the extension associated with a particular parameter, which can be retrieved through
|
|
:py:func:`QgsProcessingDestinationParameter.defaultFileExtension()`. However, in some cases, a specific parameter
|
|
may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
|
|
and which creates multiple output layers in that folder). In this case, the format returned by this
|
|
function should be used when creating these outputs.
|
|
|
|
It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm,
|
|
and to provide an appropriate fallback when the returned format is not usable.
|
|
|
|
.. seealso:: :py:func:`setPreferredVectorFormat`
|
|
|
|
.. seealso:: :py:func:`preferredRasterFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
void setPreferredVectorFormat( const QString &format );
|
|
%Docstring
|
|
Sets the preferred vector ``format`` to use for vector outputs.
|
|
|
|
This method sets a file extension to use when creating vector outputs (e.g. "shp"). Generally,
|
|
it is preferable to use the extension associated with a particular parameter, which can be retrieved through
|
|
:py:func:`QgsProcessingDestinationParameter.defaultFileExtension()`. However, in some cases, a specific parameter
|
|
may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
|
|
and which creates multiple output layers in that folder). In this case, the format set by this
|
|
function will be used when creating these outputs.
|
|
|
|
.. seealso:: :py:func:`preferredVectorFormat`
|
|
|
|
.. seealso:: :py:func:`setPreferredRasterFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
QString preferredRasterFormat() const;
|
|
%Docstring
|
|
Returns the preferred raster format to use for vector outputs.
|
|
|
|
This method returns a file extension to use when creating raster outputs (e.g. "tif"). Generally,
|
|
it is preferable to use the extension associated with a particular parameter, which can be retrieved through
|
|
:py:func:`QgsProcessingDestinationParameter.defaultFileExtension()`. However, in some cases, a specific parameter
|
|
may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
|
|
and which creates multiple output layers in that folder). In this case, the format returned by this
|
|
function should be used when creating these outputs.
|
|
|
|
It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm,
|
|
and to provide an appropriate fallback when the returned format is not usable.
|
|
|
|
.. seealso:: :py:func:`setPreferredRasterFormat`
|
|
|
|
.. seealso:: :py:func:`preferredVectorFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
void setPreferredRasterFormat( const QString &format );
|
|
%Docstring
|
|
Sets the preferred raster ``format`` to use for vector outputs.
|
|
|
|
This method sets a file extension to use when creating raster outputs (e.g. "tif"). Generally,
|
|
it is preferable to use the extension associated with a particular parameter, which can be retrieved through
|
|
:py:func:`QgsProcessingDestinationParameter.defaultFileExtension()`. However, in some cases, a specific parameter
|
|
may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
|
|
and which creates multiple output layers in that folder). In this case, the format set by this
|
|
function will be used when creating these outputs.
|
|
|
|
.. seealso:: :py:func:`preferredRasterFormat`
|
|
|
|
.. seealso:: :py:func:`setPreferredVectorFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
private:
|
|
QgsProcessingContext( const QgsProcessingContext &other );
|
|
};
|
|
|
|
QFlags<QgsProcessingContext::Flag> operator|(QgsProcessingContext::Flag f1, QFlags<QgsProcessingContext::Flag> f2);
|
|
|
|
|
|
|
|
class QgsProcessingLayerPostProcessorInterface
|
|
{
|
|
%Docstring
|
|
An interface for layer post-processing handlers for execution following a processing algorithm operation.
|
|
|
|
Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project
|
|
on algorithm completion. See :py:func:`QgsProcessingContext.layersToLoadOnCompletion()`.
|
|
|
|
Algorithms that wish to set post-processing steps for generated layers should implement this interface
|
|
in a separate class (NOT the algorithm class itself!).
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingcontext.h"
|
|
%End
|
|
public:
|
|
|
|
virtual ~QgsProcessingLayerPostProcessorInterface();
|
|
|
|
virtual void postProcessLayer( QgsMapLayer *layer, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) = 0;
|
|
%Docstring
|
|
Post-processes the specified ``layer``, following successful execution of a processing algorithm. This method
|
|
always runs in the main thread and can be used to setup renderers, editor widgets, metadata, etc for
|
|
the given layer.
|
|
|
|
Post-processing classes can utilize settings from the algorithm's ``context`` and report logging messages
|
|
or errors via the given ``feedback`` object.
|
|
|
|
In the case of an algorithm run as part of a larger model, the post-processing occurs following the completed
|
|
execution of the entire model.
|
|
|
|
Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project
|
|
on algorithm completion. See :py:func:`QgsProcessingContext.layersToLoadOnCompletion()`.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingcontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|