Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsprocessingparameters.h
3 : : -------------------------
4 : : begin : April 2017
5 : : copyright : (C) 2017 by Nyall Dawson
6 : : email : nyall dot dawson at gmail dot com
7 : : ***************************************************************************/
8 : :
9 : : /***************************************************************************
10 : : * *
11 : : * This program is free software; you can redistribute it and/or modify *
12 : : * it under the terms of the GNU General Public License as published by *
13 : : * the Free Software Foundation; either version 2 of the License, or *
14 : : * (at your option) any later version. *
15 : : * *
16 : : ***************************************************************************/
17 : :
18 : : #ifndef QGSPROCESSINGPARAMETERS_H
19 : : #define QGSPROCESSINGPARAMETERS_H
20 : :
21 : : #include "qgis_core.h"
22 : : #include "qgis.h"
23 : : #include "qgsprocessing.h"
24 : : #include "qgsproperty.h"
25 : : #include "qgscoordinatereferencesystem.h"
26 : : #include "qgsfeaturesource.h"
27 : : #include "qgsprocessingutils.h"
28 : : #include "qgsfilefiltergenerator.h"
29 : : #include "qgsremappingproxyfeaturesink.h"
30 : : #include <QMap>
31 : : #include <limits>
32 : :
33 : : class QgsProcessingContext;
34 : : class QgsProcessingAlgorithm;
35 : : class QgsRasterLayer;
36 : : class QgsMeshLayer;
37 : : class QgsVectorLayer;
38 : : class QgsFeatureSink;
39 : : class QgsProcessingFeatureSource;
40 : : class QgsProcessingOutputDefinition;
41 : : class QgsProcessingFeedback;
42 : : class QgsProcessingProvider;
43 : : class QgsPrintLayout;
44 : : class QgsLayoutItem;
45 : :
46 : : /**
47 : : * \class QgsProcessingFeatureSourceDefinition
48 : : * \ingroup core
49 : : *
50 : : * \brief Encapsulates settings relating to a feature source input to a processing algorithm.
51 : : *
52 : : * \since QGIS 3.0
53 : : */
54 : :
55 : 0 : class CORE_EXPORT QgsProcessingFeatureSourceDefinition
56 : : {
57 : : public:
58 : :
59 : : /**
60 : : * Flags which control source behavior.
61 : : * \since QGIS 3.14
62 : : */
63 : : enum Flag
64 : : {
65 : : FlagOverrideDefaultGeometryCheck = 1 << 0, //!< If set, the default geometry check method (as dictated by QgsProcessingContext) will be overridden for this source
66 : : FlagCreateIndividualOutputPerInputFeature = 1 << 1, //!< If set, every feature processed from this source will be placed into its own individually created output destination. Support for this flag depends on how an algorithm is executed.
67 : : };
68 : : Q_DECLARE_FLAGS( Flags, Flag )
69 : :
70 : : /**
71 : : * Constructor for QgsProcessingFeatureSourceDefinition, accepting a static string \a source.
72 : : *
73 : : * If \a selectedFeaturesOnly is TRUE, then only selected features from the source will be used.
74 : : *
75 : : * The optional \a featureLimit can be set to a value > 0 to place a hard limit on the maximum number
76 : : * of features which will be read from the source.
77 : : *
78 : : * The \a flags argument can be used to specify flags which dictate the source behavior.
79 : : *
80 : : * If the QgsProcessingFeatureSourceDefinition::Flag::FlagOverrideDefaultGeometryCheck is set in \a flags, then the value of \a geometryCheck will override
81 : : * the default geometry check method (as dictated by QgsProcessingContext) for this source.
82 : : */
83 : 0 : QgsProcessingFeatureSourceDefinition( const QString &source = QString(), bool selectedFeaturesOnly = false, long long featureLimit = -1,
84 : : QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid )
85 : 0 : : source( QgsProperty::fromValue( source ) )
86 : 0 : , selectedFeaturesOnly( selectedFeaturesOnly )
87 : 0 : , featureLimit( featureLimit )
88 : 0 : , flags( flags )
89 : 0 : , geometryCheck( geometryCheck )
90 : 0 : {}
91 : :
92 : : /**
93 : : * Constructor for QgsProcessingFeatureSourceDefinition, accepting a QgsProperty source.
94 : : *
95 : : * If \a selectedFeaturesOnly is TRUE, then only selected features from the source will be used.
96 : : *
97 : : * The optional \a featureLimit can be set to a value > 0 to place a hard limit on the maximum number
98 : : * of features which will be read from the source.
99 : : *
100 : : * The \a flags argument can be used to specify flags which dictate the source behavior.
101 : : *
102 : : * If the QgsProcessingFeatureSourceDefinition::Flag::FlagOverrideDefaultGeometryCheck is set in \a flags, then the value of \a geometryCheck will override
103 : : * the default geometry check method (as dictated by QgsProcessingContext) for this source.
104 : : */
105 : : QgsProcessingFeatureSourceDefinition( const QgsProperty &source, bool selectedFeaturesOnly = false, long long featureLimit = -1,
106 : : QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid )
107 : : : source( source )
108 : : , selectedFeaturesOnly( selectedFeaturesOnly )
109 : : , featureLimit( featureLimit )
110 : : , flags( flags )
111 : : , geometryCheck( geometryCheck )
112 : : {}
113 : :
114 : : /**
115 : : * Source definition. Usually a static property set to a source layer's ID or file name.
116 : : */
117 : : QgsProperty source;
118 : :
119 : : /**
120 : : * TRUE if only selected features in the source should be used by algorithms.
121 : : */
122 : : bool selectedFeaturesOnly;
123 : :
124 : : /**
125 : : * If set to a value > 0, places a limit on the maximum number of features which will be
126 : : * read from the source.
127 : : *
128 : : * \since QGIS 3.14
129 : : */
130 : : long long featureLimit = -1;
131 : :
132 : : /**
133 : : * Flags which dictate source behavior.
134 : : *
135 : : * \since QGIS 3.14
136 : : */
137 : : Flags flags = Flags();
138 : :
139 : : /**
140 : : * Geometry check method to apply to this source. This setting is only
141 : : * utilized if the QgsProcessingFeatureSourceDefinition::Flag::FlagCreateIndividualOutputPerInputFeature is
142 : : * set in QgsProcessingFeatureSourceDefinition::flags.
143 : : *
144 : : * \see overrideDefaultGeometryCheck
145 : : * \since QGIS 3.14
146 : : */
147 : : QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid;
148 : :
149 : : /**
150 : : * Saves this source definition to a QVariantMap, wrapped in a QVariant.
151 : : * You can use QgsXmlUtils::writeVariant to save it to an XML document.
152 : : * \see loadVariant()
153 : : * \since QGIS 3.14
154 : : */
155 : : QVariant toVariant() const;
156 : :
157 : : /**
158 : : * Loads this source definition from a QVariantMap, wrapped in a QVariant.
159 : : * You can use QgsXmlUtils::readVariant to load it from an XML document.
160 : : * \see toVariant()
161 : : * \since QGIS 3.14
162 : : */
163 : : bool loadVariant( const QVariantMap &map );
164 : :
165 : 0 : bool operator==( const QgsProcessingFeatureSourceDefinition &other ) const
166 : : {
167 : 0 : return source == other.source
168 : 0 : && selectedFeaturesOnly == other.selectedFeaturesOnly
169 : 0 : && featureLimit == other.featureLimit
170 : 0 : && flags == other.flags
171 : 0 : && geometryCheck == other.geometryCheck;
172 : : }
173 : :
174 : : bool operator!=( const QgsProcessingFeatureSourceDefinition &other ) const
175 : : {
176 : : return !( *this == other );
177 : : }
178 : :
179 : : //! Allows direct construction of QVariants.
180 : 0 : operator QVariant() const
181 : : {
182 : 0 : return QVariant::fromValue( *this );
183 : : }
184 : :
185 : : };
186 : :
187 : 10 : Q_DECLARE_METATYPE( QgsProcessingFeatureSourceDefinition )
188 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingFeatureSourceDefinition::Flags )
189 : :
190 : : /**
191 : : * \class QgsProcessingOutputLayerDefinition
192 : : * \ingroup core
193 : : *
194 : : * \brief Encapsulates settings relating to a feature sink or output raster layer for a processing algorithm.
195 : : *
196 : : * \since QGIS 3.0
197 : : */
198 : :
199 : 0 : class CORE_EXPORT QgsProcessingOutputLayerDefinition
200 : : {
201 : : public:
202 : :
203 : : /**
204 : : * Constructor for QgsProcessingOutputLayerDefinition, accepting a static sink/layer string.
205 : : * The \a destinationProject parameter can be set to a QgsProject instance in which
206 : : * to automatically load the resulting sink/layer after completing processing.
207 : : */
208 : 0 : QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = nullptr )
209 : 0 : : sink( QgsProperty::fromValue( sink ) )
210 : 0 : , destinationProject( destinationProject )
211 : 0 : {}
212 : :
213 : : /**
214 : : * Constructor for QgsProcessingOutputLayerDefinition, accepting a QgsProperty sink/layer.
215 : : * The \a destinationProject parameter can be set to a QgsProject instance in which
216 : : * to automatically load the resulting sink/layer after completing processing.
217 : : */
218 : : QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = nullptr )
219 : : : sink( sink )
220 : : , destinationProject( destinationProject )
221 : : {}
222 : :
223 : : /**
224 : : * Sink/layer definition. Usually a static property set to the destination file name for the sink's layer.
225 : : */
226 : : QgsProperty sink;
227 : :
228 : : /**
229 : : * Destination project. Can be set to a QgsProject instance in which
230 : : * to automatically load the resulting sink/layer after completing processing.
231 : : * The default behavior is not to load the result into any project (NULLPTR).
232 : : */
233 : : QgsProject *destinationProject = nullptr;
234 : :
235 : : /**
236 : : * Name to use for sink if it's to be loaded into a destination project.
237 : : */
238 : : QString destinationName;
239 : :
240 : : /**
241 : : * Map of optional sink/layer creation options, which
242 : : * are passed to the underlying provider when creating new layers. Known options also
243 : : * include 'fileEncoding', which is used to specify a file encoding to use for created
244 : : * files.
245 : : */
246 : : QVariantMap createOptions;
247 : :
248 : : /**
249 : : * Returns TRUE if the output uses a remapping definition.
250 : : *
251 : : * \see remappingDefinition()
252 : : * \since QGIS 3.14
253 : : */
254 : 0 : bool useRemapping() const { return mUseRemapping; }
255 : :
256 : : /**
257 : : * Returns the output remapping definition, if useRemapping() is TRUE.
258 : : *
259 : : * \see useRemapping()
260 : : * \see setRemappingDefinition()
261 : : * \since QGIS 3.14
262 : : */
263 : 0 : QgsRemappingSinkDefinition remappingDefinition() const { return mRemappingDefinition; }
264 : :
265 : : /**
266 : : * Sets the remapping \a definition to use when adding features to the output layer.
267 : : *
268 : : * Calling this method will set useRemapping() to TRUE.
269 : : *
270 : : * \see remappingDefinition()
271 : : * \see useRemapping()
272 : : *
273 : : * \since QGIS 3.14
274 : : */
275 : : void setRemappingDefinition( const QgsRemappingSinkDefinition &definition );
276 : :
277 : : /**
278 : : * Saves this output layer definition to a QVariantMap, wrapped in a QVariant.
279 : : * You can use QgsXmlUtils::writeVariant to save it to an XML document.
280 : : * \see loadVariant()
281 : : * \since QGIS 3.2
282 : : */
283 : : QVariant toVariant() const;
284 : :
285 : : /**
286 : : * Loads this output layer definition from a QVariantMap, wrapped in a QVariant.
287 : : * You can use QgsXmlUtils::readVariant to load it from an XML document.
288 : : * \see toVariant()
289 : : * \since QGIS 3.2
290 : : */
291 : : bool loadVariant( const QVariantMap &map );
292 : :
293 : : //! Allows direct construction of QVariants.
294 : 0 : operator QVariant() const
295 : : {
296 : 0 : return QVariant::fromValue( *this );
297 : : }
298 : :
299 : : bool operator==( const QgsProcessingOutputLayerDefinition &other ) const;
300 : : bool operator!=( const QgsProcessingOutputLayerDefinition &other ) const;
301 : :
302 : : private:
303 : :
304 : 0 : bool mUseRemapping = false;
305 : : QgsRemappingSinkDefinition mRemappingDefinition;
306 : :
307 : : };
308 : :
309 : 5 : Q_DECLARE_METATYPE( QgsProcessingOutputLayerDefinition )
310 : :
311 : :
312 : :
313 : :
314 : : //
315 : : // Parameter definitions
316 : : //
317 : :
318 : : /**
319 : : * \class QgsProcessingParameterDefinition
320 : : * \ingroup core
321 : : *
322 : : * \brief Base class for the definition of processing parameters.
323 : : *
324 : : * Parameter definitions encapsulate properties regarding the behavior of parameters,
325 : : * their acceptable ranges, defaults, etc.
326 : : *
327 : : * \since QGIS 3.0
328 : : */
329 : :
330 : 0 : class CORE_EXPORT QgsProcessingParameterDefinition
331 : : {
332 : :
333 : : #ifdef SIP_RUN
334 : : % TypeHeaderCode
335 : : #include "qgsprocessingparameteraggregate.h"
336 : : #include "qgsprocessingparameterdxflayers.h"
337 : : #include "qgsprocessingparameterfieldmap.h"
338 : : #include "qgsprocessingparametertininputlayers.h"
339 : : #include "qgsprocessingparametervectortilewriterlayers.h"
340 : : #include "qgsprocessingparametermeshdataset.h"
341 : : % End
342 : : SIP_CONVERT_TO_SUBCLASS_CODE
343 : : if ( sipCpp->type() == QgsProcessingParameterBoolean::typeName() )
344 : : sipType = sipType_QgsProcessingParameterBoolean;
345 : : else if ( sipCpp->type() == QgsProcessingParameterCrs::typeName() )
346 : : sipType = sipType_QgsProcessingParameterCrs;
347 : : else if ( sipCpp->type() == QgsProcessingParameterMapLayer::typeName() )
348 : : sipType = sipType_QgsProcessingParameterMapLayer;
349 : : else if ( sipCpp->type() == QgsProcessingParameterExtent::typeName() )
350 : : sipType = sipType_QgsProcessingParameterExtent;
351 : : else if ( sipCpp->type() == QgsProcessingParameterPoint::typeName() )
352 : : sipType = sipType_QgsProcessingParameterPoint;
353 : : else if ( sipCpp->type() == QgsProcessingParameterGeometry::typeName() )
354 : : sipType = sipType_QgsProcessingParameterGeometry;
355 : : else if ( sipCpp->type() == QgsProcessingParameterFile::typeName() )
356 : : sipType = sipType_QgsProcessingParameterFile;
357 : : else if ( sipCpp->type() == QgsProcessingParameterMatrix::typeName() )
358 : : sipType = sipType_QgsProcessingParameterMatrix;
359 : : else if ( sipCpp->type() == QgsProcessingParameterMultipleLayers::typeName() )
360 : : sipType = sipType_QgsProcessingParameterMultipleLayers;
361 : : else if ( sipCpp->type() == QgsProcessingParameterNumber::typeName() )
362 : : sipType = sipType_QgsProcessingParameterNumber;
363 : : else if ( sipCpp->type() == QgsProcessingParameterDistance::typeName() )
364 : : sipType = sipType_QgsProcessingParameterDistance;
365 : : else if ( sipCpp->type() == QgsProcessingParameterScale::typeName() )
366 : : sipType = sipType_QgsProcessingParameterScale;
367 : : else if ( sipCpp->type() == QgsProcessingParameterRange::typeName() )
368 : : sipType = sipType_QgsProcessingParameterRange;
369 : : else if ( sipCpp->type() == QgsProcessingParameterRasterLayer::typeName() )
370 : : sipType = sipType_QgsProcessingParameterRasterLayer;
371 : : else if ( sipCpp->type() == QgsProcessingParameterMeshLayer::typeName() )
372 : : sipType = sipType_QgsProcessingParameterMeshLayer;
373 : : else if ( sipCpp->type() == QgsProcessingParameterEnum::typeName() )
374 : : sipType = sipType_QgsProcessingParameterEnum;
375 : : else if ( sipCpp->type() == QgsProcessingParameterString::typeName() )
376 : : sipType = sipType_QgsProcessingParameterString;
377 : : else if ( sipCpp->type() == QgsProcessingParameterExpression::typeName() )
378 : : sipType = sipType_QgsProcessingParameterExpression;
379 : : else if ( sipCpp->type() == QgsProcessingParameterAuthConfig::typeName() )
380 : : sipType = sipType_QgsProcessingParameterAuthConfig;
381 : : else if ( sipCpp->type() == QgsProcessingParameterVectorLayer::typeName() )
382 : : sipType = sipType_QgsProcessingParameterVectorLayer;
383 : : else if ( sipCpp->type() == QgsProcessingParameterField::typeName() )
384 : : sipType = sipType_QgsProcessingParameterField;
385 : : else if ( sipCpp->type() == QgsProcessingParameterFeatureSource::typeName() )
386 : : sipType = sipType_QgsProcessingParameterFeatureSource;
387 : : else if ( sipCpp->type() == QgsProcessingParameterFeatureSink::typeName() )
388 : : sipType = sipType_QgsProcessingParameterFeatureSink;
389 : : else if ( sipCpp->type() == QgsProcessingParameterVectorDestination::typeName() )
390 : : sipType = sipType_QgsProcessingParameterVectorDestination;
391 : : else if ( sipCpp->type() == QgsProcessingParameterRasterDestination::typeName() )
392 : : sipType = sipType_QgsProcessingParameterRasterDestination;
393 : : else if ( sipCpp->type() == QgsProcessingParameterFileDestination::typeName() )
394 : : sipType = sipType_QgsProcessingParameterFileDestination;
395 : : else if ( sipCpp->type() == QgsProcessingParameterFolderDestination::typeName() )
396 : : sipType = sipType_QgsProcessingParameterFolderDestination;
397 : : else if ( sipCpp->type() == QgsProcessingParameterBand::typeName() )
398 : : sipType = sipType_QgsProcessingParameterBand;
399 : : else if ( sipCpp->type() == QgsProcessingParameterLayout::typeName() )
400 : : sipType = sipType_QgsProcessingParameterLayout;
401 : : else if ( sipCpp->type() == QgsProcessingParameterLayoutItem::typeName() )
402 : : sipType = sipType_QgsProcessingParameterLayoutItem;
403 : : else if ( sipCpp->type() == QgsProcessingParameterColor::typeName() )
404 : : sipType = sipType_QgsProcessingParameterColor;
405 : : else if ( sipCpp->type() == QgsProcessingParameterCoordinateOperation::typeName() )
406 : : sipType = sipType_QgsProcessingParameterCoordinateOperation;
407 : : else if ( sipCpp->type() == QgsProcessingParameterMapTheme::typeName() )
408 : : sipType = sipType_QgsProcessingParameterMapTheme;
409 : : else if ( sipCpp->type() == QgsProcessingParameterDateTime::typeName() )
410 : : sipType = sipType_QgsProcessingParameterDateTime;
411 : : else if ( sipCpp->type() == QgsProcessingParameterProviderConnection::typeName() )
412 : : sipType = sipType_QgsProcessingParameterProviderConnection;
413 : : else if ( sipCpp->type() == QgsProcessingParameterDatabaseSchema::typeName() )
414 : : sipType = sipType_QgsProcessingParameterDatabaseSchema;
415 : : else if ( sipCpp->type() == QgsProcessingParameterDatabaseTable::typeName() )
416 : : sipType = sipType_QgsProcessingParameterDatabaseTable;
417 : : else if ( sipCpp->type() == QgsProcessingParameterFieldMapping::typeName() )
418 : : sipType = sipType_QgsProcessingParameterFieldMapping;
419 : : else if ( sipCpp->type() == QgsProcessingParameterTinInputLayers::typeName() )
420 : : sipType = sipType_QgsProcessingParameterTinInputLayers;
421 : : else if ( sipCpp->type() == QgsProcessingParameterVectorTileWriterLayers::typeName() )
422 : : sipType = sipType_QgsProcessingParameterVectorTileWriterLayers;
423 : : else if ( sipCpp->type() == QgsProcessingParameterDxfLayers::typeName() )
424 : : sipType = sipType_QgsProcessingParameterDxfLayers;
425 : : else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetGroups::typeName() )
426 : : sipType = sipType_QgsProcessingParameterMeshDatasetGroups;
427 : : else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetTime::typeName() )
428 : : sipType = sipType_QgsProcessingParameterMeshDatasetTime;
429 : : else
430 : : sipType = nullptr;
431 : : SIP_END
432 : : #endif
433 : :
434 : : public:
435 : :
436 : : //! Parameter flags
437 : : enum Flag
438 : : {
439 : : FlagAdvanced = 1 << 1, //!< Parameter is an advanced parameter which should be hidden from users by default
440 : : FlagHidden = 1 << 2, //!< Parameter is hidden and should not be shown to users
441 : : FlagOptional = 1 << 3, //!< Parameter is optional
442 : : FlagIsModelOutput = 1 << 4, //!< Destination parameter is final output. The parameter name will be used.
443 : : };
444 : : Q_DECLARE_FLAGS( Flags, Flag )
445 : :
446 : : /**
447 : : * Constructor for QgsProcessingParameterDefinition.
448 : : */
449 : : QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
450 : : bool optional = false, const QString &help = QString() );
451 : :
452 : 5 : virtual ~QgsProcessingParameterDefinition() = default;
453 : :
454 : : /**
455 : : * Creates a clone of the parameter definition.
456 : : */
457 : : virtual QgsProcessingParameterDefinition *clone() const = 0 SIP_FACTORY;
458 : :
459 : : /**
460 : : * Unique parameter type name.
461 : : */
462 : : virtual QString type() const = 0;
463 : :
464 : : /**
465 : : * Returns TRUE if this parameter represents a file or layer destination, e.g. parameters
466 : : * which are used for the destination for layers output by an algorithm will return
467 : : * TRUE.
468 : : */
469 : 0 : virtual bool isDestination() const { return false; }
470 : :
471 : : /**
472 : : * Returns the name of the parameter. This is the internal identifier by which
473 : : * algorithms access this parameter.
474 : : * \see setName()
475 : : */
476 : 0 : QString name() const { return mName; }
477 : :
478 : : /**
479 : : * Sets the \a name of the parameter. This is the internal identifier by which
480 : : * algorithms access this parameter.
481 : : * \see name()
482 : : */
483 : 0 : void setName( const QString &name ) { mName = name; }
484 : :
485 : : /**
486 : : * Returns the description for the parameter. This is the user-visible string
487 : : * used to identify this parameter.
488 : : * \see setDescription()
489 : : */
490 : 0 : QString description() const { return mDescription; }
491 : :
492 : : /**
493 : : * Sets the \a description for the parameter. This is the user-visible string
494 : : * used to identify this parameter.
495 : : * \see description()
496 : : */
497 : 0 : void setDescription( const QString &description ) { mDescription = description; }
498 : :
499 : : /**
500 : : * Returns the help for the parameter.
501 : : *
502 : : * This is a descriptive (possibly lengthy), translated string explaining
503 : : * the parameter's behavior and use in depth.
504 : : *
505 : : * \see setHelp()
506 : : * \since QGIS 3.16
507 : : */
508 : 0 : QString help() const { return mHelp; }
509 : :
510 : : /**
511 : : * Sets the \a help for the parameter.
512 : : *
513 : : * The \a help string should be a descriptive, translated string explaining
514 : : * the parameter's behavior and use in depth.
515 : : *
516 : : * \see help()
517 : : * \since QGIS 3.16
518 : : */
519 : 0 : void setHelp( const QString &help ) { mHelp = help; }
520 : :
521 : : /**
522 : : * Returns the default value for the parameter.
523 : : * \see setDefaultValue()
524 : : * \see defaultValueForGui()
525 : : * \see guiDefaultValueOverride()
526 : : */
527 : 0 : QVariant defaultValue() const { return mDefault; }
528 : :
529 : : /**
530 : : * Sets the default \a value for the parameter. Caller takes responsibility
531 : : * to ensure that \a value is a valid input for the parameter subclass.
532 : : * \see defaultValue()
533 : : * \see setGuiDefaultValueOverride()
534 : : */
535 : 0 : void setDefaultValue( const QVariant &value ) { mDefault = value; }
536 : :
537 : : /**
538 : : * Returns the default value to use in the GUI for the parameter.
539 : : *
540 : : * Usually this will return an invalid variant, which indicates that the standard defaultValue()
541 : : * will be used in the GUI.
542 : : *
543 : : * \see defaultValue()
544 : : * \see setGuiDefaultValueOverride()
545 : : * \see defaultValueForGui()
546 : : *
547 : : * \since QGIS 3.18
548 : : */
549 : : QVariant guiDefaultValueOverride() const { return mGuiDefault; }
550 : :
551 : : /**
552 : : * Sets the default \a value to use for the parameter in GUI widgets. Caller takes responsibility
553 : : * to ensure that \a value is a valid input for the parameter subclass.
554 : : *
555 : : * Usually the guiDefaultValueOverride() is a invalid variant, which indicates that the standard defaultValue()
556 : : * should be used in the GUI. In cases where it is decided that a previous default value was inappropriate,
557 : : * setting a non-invalid default GUI value can be used to change the default value for the parameter shown
558 : : * to users when running algorithms without changing the actual defaultValue() and potentially breaking
559 : : * third party scripts.
560 : : *
561 : : * \see guiDefaultValueOverride()
562 : : * \see setDefaultValue()
563 : : *
564 : : * \since QGIS 3.18
565 : : */
566 : : void setGuiDefaultValueOverride( const QVariant &value ) { mGuiDefault = value; }
567 : :
568 : : /**
569 : : * Returns the default value to use for the parameter in a GUI.
570 : : *
571 : : * This will be the parameter's defaultValue(), unless a guiDefaultValueOverride() is set to
572 : : * override that.
573 : : *
574 : : * \since QGIS 3.18
575 : : */
576 : : QVariant defaultValueForGui() const { return mGuiDefault.isValid() ? mGuiDefault : mDefault; }
577 : :
578 : : /**
579 : : * Returns any flags associated with the parameter.
580 : : * \see setFlags()
581 : : */
582 : 0 : Flags flags() const { return mFlags; }
583 : :
584 : : /**
585 : : * Sets the \a flags associated with the parameter.
586 : : * \see flags()
587 : : */
588 : 0 : void setFlags( Flags flags ) { mFlags = flags; }
589 : :
590 : : /**
591 : : * Checks whether the specified \a input value is acceptable for the
592 : : * parameter. Returns TRUE if the value can be accepted.
593 : : * The optional \a context parameter can be specified to allow a more stringent
594 : : * check to be performed, capable of checking for the presence of required
595 : : * layers and other factors within the context.
596 : : */
597 : : virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const;
598 : :
599 : : /**
600 : : * Returns a string version of the parameter input \a value, which is suitable for use as an input
601 : : * parameter value when running an algorithm directly from a Python command.
602 : : */
603 : : virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
604 : :
605 : : /**
606 : : * Returns the parameter definition encoded in a string which can be used within a
607 : : * Processing script.
608 : : */
609 : : virtual QString asScriptCode() const;
610 : :
611 : : /**
612 : : * Returns the parameter definition as a Python command which can be used within a
613 : : * Python Processing script.
614 : : *
615 : : * The \a outputType argument specifies the desired output format for the Python string,
616 : : * i.e. the intended end use of the generated Python code.
617 : : *
618 : : * \since QGIS 3.6
619 : : */
620 : : virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
621 : :
622 : : /**
623 : : * Saves this parameter to a QVariantMap. Subclasses should ensure that they call the base class
624 : : * method and then extend the result with additional properties.
625 : : * \see fromVariantMap()
626 : : */
627 : : virtual QVariantMap toVariantMap() const;
628 : :
629 : : /**
630 : : * Restores this parameter to a QVariantMap. Subclasses should ensure that they call the base class
631 : : * method.
632 : : * \see toVariantMap()
633 : : */
634 : : virtual bool fromVariantMap( const QVariantMap &map );
635 : :
636 : : /**
637 : : * Returns the parameter's freeform metadata. This is mostly used by parameter widget wrappers
638 : : * in order to customize their appearance and behavior.
639 : : * \see setMetadata()
640 : : * \note not available in Python bindings.
641 : : */
642 : : SIP_SKIP QVariantMap metadata() const { return mMetadata; }
643 : :
644 : : /**
645 : : * Returns the parameter's freeform metadata. This is mostly used by parameter widget wrappers
646 : : * in order to customize their appearance and behavior.
647 : : * \see setMetadata()
648 : : */
649 : : QVariantMap &metadata() { return mMetadata; }
650 : :
651 : : /**
652 : : * Sets the parameter's freeform \a metadata. This is mostly used by parameter widget wrappers
653 : : * in order to customize their appearance and behavior.
654 : : * \see metadata()
655 : : */
656 : 0 : void setMetadata( const QVariantMap &metadata ) { mMetadata = metadata; }
657 : :
658 : : /**
659 : : * Returns a list of other parameter names on which this parameter is dependent (e.g.
660 : : * field parameters which depend on a parent layer parameter).
661 : : */
662 : 0 : virtual QStringList dependsOnOtherParameters() const { return QStringList(); }
663 : :
664 : : /**
665 : : * Returns a pointer to the algorithm which owns this parameter. May be NULLPTR
666 : : * for non-owned parameters.
667 : : * \see provider()
668 : : */
669 : : QgsProcessingAlgorithm *algorithm() const;
670 : :
671 : : /**
672 : : * Returns a pointer to the provider for the algorithm which owns this parameter. May be NULLPTR
673 : : * for non-owned parameters or algorithms.
674 : : * \see algorithm()
675 : : */
676 : : QgsProcessingProvider *provider() const;
677 : :
678 : : /**
679 : : * Returns a formatted tooltip for use with the parameter, which gives helpful information
680 : : * like parameter description, ID, and extra content like default values (depending on parameter type).
681 : : */
682 : : virtual QString toolTip() const;
683 : :
684 : : /**
685 : : * Returns TRUE if the parameter supports is dynamic, and can support data-defined values
686 : : * (i.e. QgsProperty based values).
687 : : * \see setIsDynamic()
688 : : * \see dynamicPropertyDefinition()
689 : : * \see dynamicLayerParameterName()
690 : : */
691 : : bool isDynamic() const { return mIsDynamic; }
692 : :
693 : : /**
694 : : * Sets whether the parameter is \a dynamic, and can support data-defined values
695 : : * (i.e. QgsProperty based values).
696 : : * \see isDynamic()
697 : : * \see setDynamicPropertyDefinition()
698 : : * \see setDynamicLayerParameterName()
699 : : */
700 : 0 : void setIsDynamic( bool dynamic ) { mIsDynamic = dynamic; }
701 : :
702 : : /**
703 : : * Returns the property definition for dynamic properties.
704 : : * \see isDynamic()
705 : : * \see setDynamicPropertyDefinition()
706 : : * \see dynamicLayerParameterName()
707 : : */
708 : : QgsPropertyDefinition dynamicPropertyDefinition() const { return mPropertyDefinition; }
709 : :
710 : : /**
711 : : * Sets the property \a definition for dynamic properties.
712 : : * \see isDynamic()
713 : : * \see dynamicPropertyDefinition()
714 : : * \see setDynamicLayerParameterName()
715 : : */
716 : 0 : void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition ) { mPropertyDefinition = definition; }
717 : :
718 : : /**
719 : : * Returns the name of the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
720 : : *
721 : : * Dynamic parameters (see isDynamic()) can have an optional vector layer parameter linked to them,
722 : : * which indicates which layer the fields and values will be available from when evaluating
723 : : * the dynamic parameter.
724 : : *
725 : : * \see setDynamicLayerParameterName()
726 : : * \see isDynamic()
727 : : * \see dynamicPropertyDefinition()
728 : : */
729 : : QString dynamicLayerParameterName() const { return mDynamicLayerParameterName; }
730 : :
731 : : /**
732 : : * Sets the \a name for the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
733 : : *
734 : : * Dynamic parameters (see isDynamic()) can have an optional vector layer parameter linked to them,
735 : : * which indicates which layer the fields and values will be available from when evaluating
736 : : * the dynamic parameter.
737 : : *
738 : : * \see dynamicLayerParameterName()
739 : : * \see isDynamic()
740 : : * \see setDynamicPropertyDefinition()
741 : : */
742 : 0 : void setDynamicLayerParameterName( const QString &name ) { mDynamicLayerParameterName = name; }
743 : :
744 : : /**
745 : : * Returns a list of additional expression context variables which are available for use when evaluating
746 : : * this parameter.
747 : : *
748 : : * The additional variables will be added to the variables exposed from the usual expression
749 : : * context available to the parameter. They can be used to expose variables which are ONLY available
750 : : * to this parameter.
751 : : *
752 : : * The returned list should contain the variable names only, without the usual "@" prefix.
753 : : *
754 : : * \see setAdditionalExpressionContextVariables()
755 : : * \since QGIS 3.8
756 : : */
757 : : QStringList additionalExpressionContextVariables() const { return mAdditionalExpressionVariables; }
758 : :
759 : : /**
760 : : * Sets a list of additional expression context \a variables which are available for use when evaluating
761 : : * this parameter.
762 : : *
763 : : * The additional variables will be added to the variables exposed from the usual expression
764 : : * context available to the parameter. They can be used to expose variables which are ONLY available
765 : : * to this parameter.
766 : : *
767 : : * The \a variables list should contain the variable names only, without the usual "@" prefix.
768 : : *
769 : : * \note Specifying variables via this method is for metadata purposes only. It is the algorithm's responsibility
770 : : * to correctly set the value of these additional variables in all expression context used when evaluating the parameter,
771 : : * in whichever way is appropriate for that particular variable.
772 : : *
773 : : * \see additionalExpressionContextVariables()
774 : : * \since QGIS 3.8
775 : : */
776 : : void setAdditionalExpressionContextVariables( const QStringList &variables ) { mAdditionalExpressionVariables = variables; }
777 : :
778 : : protected:
779 : :
780 : : //! Parameter name
781 : : QString mName;
782 : :
783 : : //! Parameter description
784 : : QString mDescription;
785 : :
786 : : //! Parameter help
787 : : QString mHelp;
788 : :
789 : : //! Default value for parameter
790 : : QVariant mDefault;
791 : :
792 : : //! Default value for parameter in GUI
793 : : QVariant mGuiDefault;
794 : :
795 : : //! Parameter flags
796 : : Flags mFlags;
797 : :
798 : : //! Freeform metadata for parameter. Mostly used by widget wrappers to customize their appearance and behavior.
799 : : QVariantMap mMetadata;
800 : :
801 : : //! Pointer to algorithm which owns this parameter
802 : : QgsProcessingAlgorithm *mAlgorithm = nullptr;
803 : :
804 : : //! True for dynamic parameters, which can have data-defined (QgsProperty) based values
805 : : bool mIsDynamic = false;
806 : :
807 : : //! Data defined property definition
808 : : QgsPropertyDefinition mPropertyDefinition;
809 : :
810 : : //! Linked vector layer parameter name for dynamic properties
811 : : QString mDynamicLayerParameterName;
812 : :
813 : : //! Additional expression context variables exposed for use by this parameter
814 : : QStringList mAdditionalExpressionVariables;
815 : :
816 : : // To allow access to mAlgorithm. We don't want a public setter for this!
817 : : friend class QgsProcessingAlgorithm;
818 : :
819 : : };
820 : :
821 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingParameterDefinition::Flags )
822 : :
823 : : //! List of processing parameters
824 : : typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;
825 : :
826 : : /**
827 : : * \class QgsProcessingParameters
828 : : * \ingroup core
829 : : *
830 : : * \brief A collection of utilities for working with parameters when running a processing algorithm.
831 : : *
832 : : * Parameters are stored in a QVariantMap and referenced by a unique string key.
833 : : * The QVariants in parameters are not usually accessed
834 : : * directly, and instead the high level API provided through QgsProcessingParameters
835 : : * parameterAsString(), parameterAsDouble() are used instead.
836 : : *
837 : : * Parameters are evaluated using a provided QgsProcessingContext, allowing
838 : : * the evaluation to understand available map layers and expression contexts
839 : : * (for expression based parameters).
840 : : *
841 : : * \since QGIS 3.0
842 : : */
843 : :
844 : : class CORE_EXPORT QgsProcessingParameters
845 : : {
846 : :
847 : : public:
848 : :
849 : : /**
850 : : * Returns TRUE if the parameter with matching \a name is a dynamic parameter, and must
851 : : * be evaluated once for every input feature processed.
852 : : */
853 : : static bool isDynamic( const QVariantMap ¶meters, const QString &name );
854 : :
855 : : /**
856 : : * Evaluates the parameter with matching \a definition to a static string value.
857 : : */
858 : : static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
859 : :
860 : : /**
861 : : * Evaluates the parameter with matching \a definition and \a value to a static string value.
862 : : * \since QGIS 3.4
863 : : */
864 : : static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
865 : :
866 : : /**
867 : : * Evaluates the parameter with matching \a definition to an expression.
868 : : */
869 : : static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
870 : :
871 : : /**
872 : : * Evaluates the parameter with matching \a definitionand \a value to an expression.
873 : : * \since QGIS 3.4
874 : : */
875 : : static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
876 : :
877 : : /**
878 : : * Evaluates the parameter with matching \a definition to a static double value.
879 : : */
880 : : static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
881 : :
882 : : /**
883 : : * Evaluates the parameter with matching \a definition and \a value to a static double value.
884 : : * \since QGIS 3.4
885 : : */
886 : : static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
887 : :
888 : : /**
889 : : * Evaluates the parameter with matching \a definition to a static integer value.
890 : : */
891 : : static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
892 : :
893 : : /**
894 : : * Evaluates the parameter with matching \a definition and \a value to a static integer value.
895 : : * \since QGIS 3.4
896 : : */
897 : : static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
898 : :
899 : : /**
900 : : * Evaluates the parameter with matching \a definition to a list of integer values.
901 : : * \since QGIS 3.4
902 : : */
903 : : static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
904 : :
905 : : /**
906 : : * Evaluates the parameter with matching \a definition and \a value to a list of integer values.
907 : : * \since QGIS 3.4
908 : : */
909 : : static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
910 : :
911 : : /**
912 : : * Evaluates the parameter with matching \a definition to a static datetime value.
913 : : *
914 : : * \see parameterAsDate()
915 : : * \see parameterAsTime()
916 : : *
917 : : * \since QGIS 3.14
918 : : */
919 : : static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
920 : :
921 : : /**
922 : : * Evaluates the parameter with matching \a definition and \a value to a static datetime value.
923 : : *
924 : : * \see parameterAsDate()
925 : : * \see parameterAsTime()
926 : : *
927 : : * \since QGIS 3.14
928 : : */
929 : : static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
930 : :
931 : : /**
932 : : * Evaluates the parameter with matching \a definition to a static date value.
933 : : *
934 : : * \see parameterAsDateTime()
935 : : * \see parameterAsTime()
936 : : *
937 : : * \since QGIS 3.14
938 : : */
939 : : static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
940 : :
941 : : /**
942 : : * Evaluates the parameter with matching \a definition and \a value to a static date value.
943 : : *
944 : : * \see parameterAsDateTime()
945 : : * \see parameterAsTime()
946 : : *
947 : : * \since QGIS 3.14
948 : : */
949 : : static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
950 : :
951 : : /**
952 : : * Evaluates the parameter with matching \a definition to a static time value.
953 : : *
954 : : * \see parameterAsDateTime()
955 : : * \see parameterAsDate()
956 : : *
957 : : * \since QGIS 3.14
958 : : */
959 : : static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
960 : :
961 : : /**
962 : : * Evaluates the parameter with matching \a definition and \a value to a static time value.
963 : : *
964 : : * \see parameterAsDateTime()
965 : : * \see parameterAsDate()
966 : : *
967 : : * \since QGIS 3.14
968 : : */
969 : : static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
970 : :
971 : : /**
972 : : * Evaluates the parameter with matching \a definition to a enum value.
973 : : */
974 : : static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
975 : :
976 : : /**
977 : : * Evaluates the parameter with matching \a definition and \a value to a enum value.
978 : : * \since QGIS 3.4
979 : : */
980 : : static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
981 : :
982 : : /**
983 : : * Evaluates the parameter with matching \a definition to list of enum values.
984 : : */
985 : : static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
986 : :
987 : : /**
988 : : * Evaluates the parameter with matching \a definition and \a value to list of enum values.
989 : : * \since QGIS 3.4
990 : : */
991 : : static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
992 : :
993 : : /**
994 : : * Evaluates the parameter with matching \a definition to a static enum string.
995 : : * \since QGIS 3.18
996 : : */
997 : : static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
998 : :
999 : : /**
1000 : : * Evaluates the parameter with matching \a definition and \a value to a static enum string.
1001 : : * \since QGIS 3.18
1002 : : */
1003 : : static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1004 : :
1005 : : /**
1006 : : * Evaluates the parameter with matching \a definition to list of static enum strings.
1007 : : * \since QGIS 3.18
1008 : : */
1009 : : static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1010 : :
1011 : : /**
1012 : : * Evaluates the parameter with matching \a definition and \a value to list of static enum strings.
1013 : : * \since QGIS 3.18
1014 : : */
1015 : : static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1016 : :
1017 : : /**
1018 : : * Evaluates the parameter with matching \a definition to a static boolean value.
1019 : : */
1020 : : static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1021 : :
1022 : : /**
1023 : : * Evaluates the parameter with matching \a definition to a static boolean value.
1024 : : *
1025 : : * \since QGIS 3.8
1026 : : */
1027 : : static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1028 : :
1029 : : /**
1030 : : * Evaluates the parameter with matching \a definition and \a value to a static boolean value.
1031 : : * \since QGIS 3.4
1032 : : */
1033 : : static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1034 : :
1035 : : /**
1036 : : * Evaluates the parameter with matching \a definition and \a value to a static boolean value.
1037 : : * \since QGIS 3.8
1038 : : */
1039 : : static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1040 : :
1041 : : /**
1042 : : * Evaluates the parameter with matching \a definition to a feature sink.
1043 : : *
1044 : : * The \a fields, \a geometryType and \a crs parameters dictate the properties
1045 : : * of the resulting feature sink.
1046 : : *
1047 : : * Sinks will either be taken from \a context's active project, or created from external
1048 : : * providers and stored temporarily in the \a context. The \a destinationIdentifier
1049 : : * argument will be set to a string which can be used to retrieve the layer corresponding
1050 : : * to the sink, e.g. via calling QgsProcessingUtils::mapLayerFromString().
1051 : : *
1052 : : * The \a createOptions argument is used to pass on creation options such as layer name.
1053 : : *
1054 : : * The \a datasourceOptions and \a layerOptions arguments is used to pass on GDAL-specific format driver options.
1055 : : *
1056 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1057 : : */
1058 : : static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1059 : : const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs,
1060 : : QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) SIP_FACTORY;
1061 : :
1062 : : /**
1063 : : * Evaluates the parameter with matching \a definition and \a value to a feature sink.
1064 : : *
1065 : : * The \a fields, \a geometryType and \a crs parameters dictate the properties
1066 : : * of the resulting feature sink.
1067 : : *
1068 : : * Sinks will either be taken from \a context's active project, or created from external
1069 : : * providers and stored temporarily in the \a context. The \a destinationIdentifier
1070 : : * argument will be set to a string which can be used to retrieve the layer corresponding
1071 : : * to the sink, e.g. via calling QgsProcessingUtils::mapLayerFromString().
1072 : : *
1073 : : * The \a createOptions argument is used to pass on creation options such as layer name.
1074 : : *
1075 : : * The \a datasourceOptions and \a layerOptions arguments is used to pass on GDAL-specific format driver options.
1076 : : *
1077 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1078 : : * \throws QgsProcessingException
1079 : : * \since QGIS 3.4
1080 : : */
1081 : : static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value,
1082 : : const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs,
1083 : : QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) SIP_THROW( QgsProcessingException ) SIP_FACTORY;
1084 : :
1085 : : /**
1086 : : * Evaluates the parameter with matching \a definition to a feature source.
1087 : : *
1088 : : * Sources will either be taken from \a context's active project, or loaded from external
1089 : : * sources and stored temporarily in the \a context.
1090 : : *
1091 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1092 : : */
1093 : : static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context ) SIP_FACTORY;
1094 : :
1095 : : /**
1096 : : * Evaluates the parameter with matching \a definition and \a value to a feature source.
1097 : : *
1098 : : * Sources will either be taken from \a context's active project, or loaded from external
1099 : : * sources and stored temporarily in the \a context.
1100 : : *
1101 : : * This function creates a new object and the caller takes responsibility for deleting the returned object.
1102 : : *
1103 : : * \since QGIS 3.4
1104 : : */
1105 : : static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) SIP_FACTORY;
1106 : :
1107 : : /**
1108 : : * Evaluates the parameter with matching \a definition to a source vector layer file path of compatible format.
1109 : : *
1110 : : * If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
1111 : : * \a compatibleFormats argument, then the layer will first be exported to a compatible format
1112 : : * in a temporary location. The function will then return the path to that temporary file.
1113 : : *
1114 : : * \a compatibleFormats should consist entirely of lowercase file extensions, e.g. 'shp'.
1115 : : *
1116 : : * The \a preferredFormat argument is used to specify to desired file extension to use when a temporary
1117 : : * layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
1118 : : *
1119 : : * When an algorithm is capable of handling multi-layer input files (such as Geopackage), it is preferable
1120 : : * to use parameterAsCompatibleSourceLayerPathAndLayerName() which may avoid conversion in more situations.
1121 : : */
1122 : : static QString parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1123 : : QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr );
1124 : :
1125 : : /**
1126 : : * Evaluates the parameter with matching \a definition to a source vector layer file path and layer name of compatible format.
1127 : : *
1128 : : * If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
1129 : : * \a compatibleFormats argument, then the layer will first be exported to a compatible format
1130 : : * in a temporary location. The function will then return the path to that temporary file.
1131 : : *
1132 : : * \a compatibleFormats should consist entirely of lowercase file extensions, e.g. 'shp'.
1133 : : *
1134 : : * The \a preferredFormat argument is used to specify to desired file extension to use when a temporary
1135 : : * layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
1136 : : *
1137 : : * This method should be preferred over parameterAsCompatibleSourceLayerPath() when an algorithm is able
1138 : : * to correctly handle files with multiple layers. Unlike parameterAsCompatibleSourceLayerPath(), it will not force
1139 : : * a conversion in this case and will return the target layer name in the \a layerName argument.
1140 : : *
1141 : : * \param definition associated parameter definition
1142 : : * \param parameters input parameter value map
1143 : : * \param context processing context
1144 : : * \param compatibleFormats a list of lowercase file extensions compatible with the algorithm
1145 : : * \param preferredFormat preferred format extension to use if conversion if required
1146 : : * \param feedback feedback object
1147 : : * \param layerName will be set to the target layer name for multi-layer sources (e.g. Geopackage)
1148 : : *
1149 : : * \returns path to source layer, or nearly converted compatible layer
1150 : : *
1151 : : * \see parameterAsCompatibleSourceLayerPath()
1152 : : * \since QGIS 3.10
1153 : : */
1154 : : static QString parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
1155 : : QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr, QString *layerName SIP_OUT = nullptr );
1156 : :
1157 : : /**
1158 : : * Evaluates the parameter with matching \a definition to a map layer.
1159 : : *
1160 : : * Layers will either be taken from \a context's active project, or loaded from external
1161 : : * sources and stored temporarily in the \a context. In either case, callers do not
1162 : : * need to handle deletion of the returned layer.
1163 : : */
1164 : : static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
1165 : :
1166 : : /**
1167 : : * Evaluates the parameter with matching \a definition and \a value to a map layer.
1168 : : *
1169 : : * Layers will either be taken from \a context's active project, or loaded from external
1170 : : * sources and stored temporarily in the \a context. In either case, callers do not
1171 : : * need to handle deletion of the returned layer.
1172 : : *
1173 : : * \since QGIS 3.4
1174 : : */
1175 : : static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
1176 : :
1177 : : /**
1178 : : * Evaluates the parameter with matching \a definition to a raster layer.
1179 : : *
1180 : : * Layers will either be taken from \a context's active project, or loaded from external
1181 : : * sources and stored temporarily in the \a context. In either case, callers do not
1182 : : * need to handle deletion of the returned layer.
1183 : : */
1184 : : static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1185 : :
1186 : : /**
1187 : : * Evaluates the parameter with matching \a definition and \a value to a raster layer.
1188 : : *
1189 : : * Layers will either be taken from \a context's active project, or loaded from external
1190 : : * sources and stored temporarily in the \a context. In either case, callers do not
1191 : : * need to handle deletion of the returned layer.
1192 : : *
1193 : : * \since QGIS 3.4
1194 : : */
1195 : : static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1196 : :
1197 : : /**
1198 : : * Evaluates the parameter with matching \a definition to a output layer destination.
1199 : : */
1200 : : static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1201 : :
1202 : : /**
1203 : : * Evaluates the parameter with matching \a definition and \a value to a output layer destination.
1204 : : * \since QGIS 3.4
1205 : : */
1206 : : static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1207 : :
1208 : : /**
1209 : : * Evaluates the parameter with matching \a definition to a file based output destination.
1210 : : */
1211 : : static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1212 : :
1213 : : /**
1214 : : * Evaluates the parameter with matching \a definition and \a value to a file based output destination.
1215 : : * \since QGIS 3.4
1216 : : */
1217 : : static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1218 : :
1219 : : /**
1220 : : * Evaluates the parameter with matching \a definition to a vector layer.
1221 : : *
1222 : : * Layers will either be taken from \a context's active project, or loaded from external
1223 : : * sources and stored temporarily in the \a context. In either case, callers do not
1224 : : * need to handle deletion of the returned layer.
1225 : : */
1226 : : static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1227 : :
1228 : : /**
1229 : : * Evaluates the parameter with matching \a definition and \a value to a vector layer.
1230 : : *
1231 : : * Layers will either be taken from \a context's active project, or loaded from external
1232 : : * sources and stored temporarily in the \a context. In either case, callers do not
1233 : : * need to handle deletion of the returned layer.
1234 : : *
1235 : : * \since QGIS 3.4
1236 : : */
1237 : : static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1238 : :
1239 : : /**
1240 : : * Evaluates the parameter with matching \a definition and \a value to a mesh layer.
1241 : : *
1242 : : * Layers will either be taken from \a context's active project, or loaded from external
1243 : : * sources and stored temporarily in the \a context. In either case, callers do not
1244 : : * need to handle deletion of the returned layer.
1245 : : *
1246 : : * \since QGIS 3.6
1247 : : */
1248 : : static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1249 : :
1250 : : /**
1251 : : * Evaluates the parameter with matching \a definition and \a value to a mesh layer.
1252 : : *
1253 : : * Layers will either be taken from \a context's active project, or loaded from external
1254 : : * sources and stored temporarily in the \a context. In either case, callers do not
1255 : : * need to handle deletion of the returned layer.
1256 : : *
1257 : : * \since QGIS 3.6
1258 : : */
1259 : : static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1260 : :
1261 : :
1262 : : /**
1263 : : * Evaluates the parameter with matching \a definition to a coordinate reference system.
1264 : : */
1265 : : static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1266 : :
1267 : : /**
1268 : : * Evaluates the parameter with matching \a definition and \a value to a coordinate reference system.
1269 : : * \since QGIS 3.4
1270 : : */
1271 : : static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1272 : :
1273 : : /**
1274 : : * Evaluates the parameter with matching \a definition to a rectangular extent.
1275 : : *
1276 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1277 : : * reprojected so that it is in the specified \a crs. In this case the extent of the reproject rectangle will be returned.
1278 : : *
1279 : : * \see parameterAsExtentGeometry()
1280 : : * \see parameterAsExtentCrs()
1281 : : */
1282 : : static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1283 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1284 : :
1285 : : /**
1286 : : * Evaluates the parameter with matching \a definition and \a value to a rectangular extent.
1287 : : *
1288 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1289 : : * reprojected so that it is in the specified \a crs. In this case the extent of the reproject rectangle will be returned.
1290 : : *
1291 : : * \see parameterAsExtentGeometry()
1292 : : * \see parameterAsExtentCrs()
1293 : : *
1294 : : * \since QGIS 3.4
1295 : : */
1296 : : static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
1297 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1298 : :
1299 : : /**
1300 : : * Evaluates the parameter with matching \a definition to a rectangular extent, and returns a geometry covering this extent.
1301 : : *
1302 : : * If \a crs is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
1303 : : * reprojected so that it is in the specified \a crs. Unlike parameterAsExtent(), the reprojected rectangle returned by this function
1304 : : * will no longer be a rectangle itself (i.e. this method returns the geometry of the actual reprojected rectangle, while parameterAsExtent() returns
1305 : : * just the extent of the reprojected rectangle).
1306 : : *
1307 : : * \see parameterAsExtent()
1308 : : * \see parameterAsExtentCrs()
1309 : : */
1310 : : static QgsGeometry parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1311 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1312 : :
1313 : : /**
1314 : : * Returns the coordinate reference system associated with an extent parameter value.
1315 : : *
1316 : : * \see parameterAsExtent()
1317 : : */
1318 : : static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1319 : :
1320 : : /**
1321 : : * Returns the coordinate reference system associated with an extent parameter value.
1322 : : *
1323 : : * \see parameterAsExtent()
1324 : : */
1325 : : static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1326 : :
1327 : :
1328 : : /**
1329 : : * Evaluates the parameter with matching \a definition to a point.
1330 : : *
1331 : : * If \a crs is set then the point will be automatically reprojected so that it is in the specified \a crs.
1332 : : *
1333 : : * \see parameterAsPointCrs()
1334 : : */
1335 : : static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
1336 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1337 : :
1338 : : /**
1339 : : * Evaluates the parameter with matching \a definition and \a value to a point.
1340 : : *
1341 : : * If \a crs is set then the point will be automatically reprojected so that it is in the specified \a crs.
1342 : : *
1343 : : * \see parameterAsPointCrs()
1344 : : * \since QGIS 3.4
1345 : : */
1346 : : static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
1347 : : const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1348 : :
1349 : : /**
1350 : : * Returns the coordinate reference system associated with an point parameter value.
1351 : : *
1352 : : * \see parameterAsPoint()
1353 : : */
1354 : : static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1355 : :
1356 : : /**
1357 : : * Returns the coordinate reference system associated with an point parameter value.
1358 : : *
1359 : : * \see parameterAsPoint()
1360 : : * \since QGIS 3.8
1361 : : */
1362 : : static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1363 : :
1364 : : /**
1365 : : * Evaluates the parameter with matching \a definition to a geometry.
1366 : : *
1367 : : * \since QGIS 3.16
1368 : : */
1369 : : static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1370 : :
1371 : : /**
1372 : : * Evaluates the parameter with matching \a definition and \a value to a geometry.
1373 : : *
1374 : : * \since QGIS 3.16
1375 : : */
1376 : : static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
1377 : :
1378 : : /**
1379 : : * Returns the coordinate reference system associated with a geometry parameter value.
1380 : : *
1381 : : * \see parameterAsGeometry()
1382 : : * \since QGIS 3.16
1383 : : */
1384 : : static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1385 : :
1386 : : /**
1387 : : * Returns the coordinate reference system associated with an point parameter value.
1388 : : *
1389 : : * \see parameterAsGeometry()
1390 : : * \since QGIS 3.16
1391 : : */
1392 : : static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1393 : :
1394 : : /**
1395 : : * Evaluates the parameter with matching \a definition to a file/folder name.
1396 : : */
1397 : : static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1398 : :
1399 : : /**
1400 : : * Evaluates the parameter with matching \a definition and \a value to a file/folder name.
1401 : : * \since QGIS 3.4
1402 : : */
1403 : : static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1404 : :
1405 : : /**
1406 : : * Evaluates the parameter with matching \a definition to a matrix/table of values.
1407 : : * Tables are collapsed to a 1 dimensional list.
1408 : : */
1409 : : static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1410 : :
1411 : : /**
1412 : : * Evaluates the parameter with matching \a definition and \a value to a matrix/table of values.
1413 : : * Tables are collapsed to a 1 dimensional list.
1414 : : * \since QGIS 3.4
1415 : : */
1416 : : static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1417 : :
1418 : : /**
1419 : : * Evaluates the parameter with matching \a definition to a list of map layers.
1420 : : */
1421 : : static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1422 : :
1423 : : /**
1424 : : * Evaluates the parameter with matching \a definition and \a value to a list of map layers.
1425 : : * \since QGIS 3.4
1426 : : */
1427 : : static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1428 : :
1429 : : /**
1430 : : * Evaluates the parameter with matching \a definition to a list of files (for QgsProcessingParameterMultipleLayers in QgsProcessing:TypeFile mode).
1431 : : *
1432 : : * \since QGIS 3.10
1433 : : */
1434 : : static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1435 : :
1436 : : /**
1437 : : * Evaluates the parameter with matching \a definition to a list of files (for QgsProcessingParameterMultipleLayers in QgsProcessing:TypeFile mode).
1438 : : *
1439 : : * \since QGIS 3.10
1440 : : */
1441 : : static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1442 : :
1443 : : /**
1444 : : * Evaluates the parameter with matching \a definition to a range of values.
1445 : : */
1446 : : static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1447 : :
1448 : : /**
1449 : : * Evaluates the parameter with matching \a definition and \a value to a range of values.
1450 : : * \since QGIS 3.4
1451 : : */
1452 : : static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1453 : :
1454 : : /**
1455 : : * Evaluates the parameter with matching \a definition to a list of fields.
1456 : : */
1457 : : static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1458 : :
1459 : : /**
1460 : : * Evaluates the parameter with matching \a definition and \a value to a list of fields.
1461 : : * \since QGIS 3.4
1462 : : */
1463 : : static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1464 : :
1465 : : /**
1466 : : * Evaluates the parameter with matching \a definition to a print layout.
1467 : : *
1468 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1469 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1470 : : *
1471 : : * \since QGIS 3.8
1472 : : */
1473 : : static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1474 : :
1475 : : /**
1476 : : * Evaluates the parameter with matching \a definition and \a value to a print layout.
1477 : : *
1478 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1479 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1480 : : *
1481 : : * \since QGIS 3.8
1482 : : */
1483 : : static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1484 : :
1485 : : /**
1486 : : * Evaluates the parameter with matching \a definition to a print layout item, taken from the specified \a layout.
1487 : : *
1488 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1489 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1490 : : *
1491 : : * \since QGIS 3.8
1492 : : */
1493 : : static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsPrintLayout *layout );
1494 : :
1495 : : /**
1496 : : * Evaluates the parameter with matching \a definition and \a value to a print layout, taken from the specified \a layout.
1497 : : *
1498 : : * \warning This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
1499 : : * implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
1500 : : *
1501 : : * \since QGIS 3.8
1502 : : */
1503 : : static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout );
1504 : :
1505 : : /**
1506 : : * Returns the color associated with an point parameter value, or an invalid color if the parameter was not set.
1507 : : *
1508 : : * \since QGIS 3.10
1509 : : */
1510 : : static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
1511 : :
1512 : : /**
1513 : : * Returns the color associated with an color parameter value, or an invalid color if the parameter was not set.
1514 : : *
1515 : : * \since QGIS 3.10
1516 : : */
1517 : : static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
1518 : :
1519 : : /**
1520 : : * Evaluates the parameter with matching \a definition to a connection name string.
1521 : : *
1522 : : * \since QGIS 3.14
1523 : : */
1524 : : static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1525 : :
1526 : : /**
1527 : : * Evaluates the parameter with matching \a definition and \a value to a connection name string.
1528 : : *
1529 : : * \since QGIS 3.14
1530 : : */
1531 : : static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1532 : :
1533 : : /**
1534 : : * Evaluates the parameter with matching \a definition to a database schema name.
1535 : : *
1536 : : * \since QGIS 3.14
1537 : : */
1538 : : static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1539 : :
1540 : : /**
1541 : : * Evaluates the parameter with matching \a definition and \a value to a database schema name.
1542 : : *
1543 : : * \since QGIS 3.14
1544 : : */
1545 : : static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1546 : :
1547 : : /**
1548 : : * Evaluates the parameter with matching \a definition to a database table name.
1549 : : *
1550 : : * \since QGIS 3.14
1551 : : */
1552 : : static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
1553 : :
1554 : : /**
1555 : : * Evaluates the parameter with matching \a definition and \a value to a database table name.
1556 : : *
1557 : : * \since QGIS 3.14
1558 : : */
1559 : : static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
1560 : :
1561 : : /**
1562 : : * Creates a new QgsProcessingParameterDefinition using the configuration from a
1563 : : * supplied variant \a map.
1564 : : * The caller takes responsibility for deleting the returned object.
1565 : : */
1566 : : static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) SIP_FACTORY;
1567 : :
1568 : : /**
1569 : : * Creates an autogenerated parameter description from a parameter \a name.
1570 : : */
1571 : : static QString descriptionFromName( const QString &name );
1572 : :
1573 : : /**
1574 : : * Creates a new QgsProcessingParameterDefinition using the configuration from a
1575 : : * supplied script \a code string.
1576 : : * The caller takes responsibility for deleting the returned object.
1577 : : */
1578 : : static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) SIP_FACTORY;
1579 : :
1580 : : private:
1581 : :
1582 : : static bool parseScriptCodeParameterOptions( const QString &code, bool &isOptional, QString &name, QString &type, QString &definition );
1583 : : };
1584 : :
1585 : :
1586 : :
1587 : : /**
1588 : : * \class QgsProcessingParameterBoolean
1589 : : * \ingroup core
1590 : : * \brief A boolean parameter for processing algorithms.
1591 : : * \since QGIS 3.0
1592 : : */
1593 : 0 : class CORE_EXPORT QgsProcessingParameterBoolean : public QgsProcessingParameterDefinition
1594 : : {
1595 : : public:
1596 : :
1597 : : /**
1598 : : * Constructor for QgsProcessingParameterBoolean.
1599 : : */
1600 : : QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1601 : : bool optional = false );
1602 : :
1603 : : /**
1604 : : * Returns the type name for the parameter class.
1605 : : */
1606 : 0 : static QString typeName() { return QStringLiteral( "boolean" ); }
1607 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1608 : 0 : QString type() const override { return typeName(); }
1609 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1610 : : QString asScriptCode() const override;
1611 : :
1612 : : /**
1613 : : * Creates a new parameter using the definition from a script code.
1614 : : */
1615 : : static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1616 : : };
1617 : :
1618 : : /**
1619 : : * \class QgsProcessingParameterCrs
1620 : : * \ingroup core
1621 : : * \brief A coordinate reference system parameter for processing algorithms.
1622 : : * \since QGIS 3.0
1623 : : */
1624 : 0 : class CORE_EXPORT QgsProcessingParameterCrs : public QgsProcessingParameterDefinition
1625 : : {
1626 : : public:
1627 : :
1628 : : /**
1629 : : * Constructor for QgsProcessingParameterCrs.
1630 : : */
1631 : : QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1632 : : bool optional = false );
1633 : :
1634 : : /**
1635 : : * Returns the type name for the parameter class.
1636 : : */
1637 : 0 : static QString typeName() { return QStringLiteral( "crs" ); }
1638 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1639 : 0 : QString type() const override { return typeName(); }
1640 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1641 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1642 : :
1643 : : /**
1644 : : * Creates a new parameter using the definition from a script code.
1645 : : */
1646 : : static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1647 : :
1648 : : };
1649 : :
1650 : : /**
1651 : : * \class QgsProcessingParameterExtent
1652 : : * \ingroup core
1653 : : * \brief A rectangular map extent parameter for processing algorithms.
1654 : : * \since QGIS 3.0
1655 : : */
1656 : 0 : class CORE_EXPORT QgsProcessingParameterExtent : public QgsProcessingParameterDefinition
1657 : : {
1658 : : public:
1659 : :
1660 : : /**
1661 : : * Constructor for QgsProcessingParameterExtent.
1662 : : */
1663 : : QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1664 : : bool optional = false );
1665 : :
1666 : : /**
1667 : : * Returns the type name for the parameter class.
1668 : : */
1669 : 0 : static QString typeName() { return QStringLiteral( "extent" ); }
1670 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1671 : 0 : QString type() const override { return typeName(); }
1672 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1673 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1674 : :
1675 : : /**
1676 : : * Creates a new parameter using the definition from a script code.
1677 : : */
1678 : : static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1679 : :
1680 : : };
1681 : :
1682 : :
1683 : : /**
1684 : : * \class QgsProcessingParameterPoint
1685 : : * \ingroup core
1686 : : * \brief A point parameter for processing algorithms.
1687 : : * \since QGIS 3.0
1688 : : */
1689 : 0 : class CORE_EXPORT QgsProcessingParameterPoint : public QgsProcessingParameterDefinition
1690 : : {
1691 : : public:
1692 : :
1693 : : /**
1694 : : * Constructor for QgsProcessingParameterPoint.
1695 : : */
1696 : : QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
1697 : : bool optional = false );
1698 : :
1699 : : /**
1700 : : * Returns the type name for the parameter class.
1701 : : */
1702 : 0 : static QString typeName() { return QStringLiteral( "point" ); }
1703 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1704 : 0 : QString type() const override { return typeName(); }
1705 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1706 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1707 : :
1708 : : /**
1709 : : * Creates a new parameter using the definition from a script code.
1710 : : */
1711 : : static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1712 : :
1713 : : };
1714 : :
1715 : : /**
1716 : : * \class QgsProcessingParameterGeometry
1717 : : * \ingroup core
1718 : : * \brief A geometry parameter for processing algorithms.
1719 : : * \since QGIS 3.16
1720 : : */
1721 : 0 : class CORE_EXPORT QgsProcessingParameterGeometry : public QgsProcessingParameterDefinition
1722 : : {
1723 : : public:
1724 : :
1725 : : /**
1726 : : * Constructor for QgsProcessingParameterGeometry.
1727 : : *
1728 : : * The \a geometryTypes argument allows for specifying a list of geometry types (see QgsWkbTypes::GeometryType) acceptable for this
1729 : : * parameter. Passing a empty list will allow for any type of geometry.
1730 : : */
1731 : : QgsProcessingParameterGeometry( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QList< int > &geometryTypes = QList< int >() );
1732 : :
1733 : : /**
1734 : : * Returns the type name for the parameter class.
1735 : : */
1736 : 0 : static QString typeName() { return QStringLiteral( "geometry" ); }
1737 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1738 : 0 : QString type() const override { return typeName(); }
1739 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1740 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1741 : : QString asScriptCode() const override;
1742 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1743 : : QVariantMap toVariantMap() const override;
1744 : : bool fromVariantMap( const QVariantMap &map ) override;
1745 : :
1746 : : /**
1747 : : * Returns the parameter allowed geometries, as a list of QgsWkbTypes::GeometryType values.
1748 : : * \see setGeometryTypes()
1749 : : */
1750 : : QList<int> geometryTypes() const { return mGeomTypes; }
1751 : :
1752 : : /**
1753 : : * Sets the allowed \a geometryTypes, as a list of QgsWkbTypes::GeometryType values.
1754 : : * \see geometryTypes()
1755 : : */
1756 : : void setGeometryTypes( const QList<int> &geometryTypes ) { mGeomTypes = geometryTypes; }
1757 : :
1758 : : /**
1759 : : * Creates a new parameter using the definition from a script code.
1760 : : */
1761 : : static QgsProcessingParameterGeometry *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1762 : :
1763 : : private:
1764 : :
1765 : : QList<int> mGeomTypes;
1766 : :
1767 : : };
1768 : :
1769 : : /**
1770 : : * \class QgsProcessingParameterFile
1771 : : * \ingroup core
1772 : : * \brief An input file or folder parameter for processing algorithms.
1773 : : * \since QGIS 3.0
1774 : : */
1775 : 0 : class CORE_EXPORT QgsProcessingParameterFile : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
1776 : : {
1777 : : public:
1778 : :
1779 : : //! Parameter behavior
1780 : : enum Behavior
1781 : : {
1782 : : File = 0, //!< Parameter is a single file
1783 : : Folder, //!< Parameter is a folder
1784 : : };
1785 : :
1786 : : /**
1787 : : * Constructor for QgsProcessingParameterFile.
1788 : : *
1789 : : * The \a extension argument allows for specifying a file extension associated with the parameter (e.g. "html"). Use \a fileFilter
1790 : : * for a more flexible approach which allows for multiple file extensions. Only one of \a extension or \a fileFilter should be specified,
1791 : : * if both are specified then \a fileFilter takes precedence.
1792 : : */
1793 : : QgsProcessingParameterFile( const QString &name, const QString &description = QString(), Behavior behavior = File, const QString &extension = QString(), const QVariant &defaultValue = QVariant(),
1794 : : bool optional = false, const QString &fileFilter = QString() );
1795 : :
1796 : : /**
1797 : : * Returns the type name for the parameter class.
1798 : : */
1799 : 0 : static QString typeName() { return QStringLiteral( "file" ); }
1800 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1801 : 0 : QString type() const override { return typeName(); }
1802 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1803 : : QString asScriptCode() const override;
1804 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1805 : : QString createFileFilter() const override;
1806 : :
1807 : : /**
1808 : : * Returns the parameter behavior (e.g. File or Folder).
1809 : : * \see setBehavior()
1810 : : */
1811 : : Behavior behavior() const { return mBehavior; }
1812 : :
1813 : : /**
1814 : : * Sets the parameter \a behavior (e.g. File or Folder).
1815 : : * \see behavior()
1816 : : */
1817 : : void setBehavior( Behavior behavior ) { mBehavior = behavior; }
1818 : :
1819 : : /**
1820 : : * Returns any specified file extension for the parameter.
1821 : : *
1822 : : * \note See fileFilter() for a more flexible approach.
1823 : : *
1824 : : * \see setExtension()
1825 : : */
1826 : : QString extension() const { return mExtension; }
1827 : :
1828 : : /**
1829 : : * Sets a file \a extension for the parameter.
1830 : : *
1831 : : * Calling this method resets any existing fileFilter().
1832 : : *
1833 : : * \note See setFileFilter() for a more flexible approach.
1834 : : *
1835 : : * \see extension()
1836 : : */
1837 : : void setExtension( const QString &extension );
1838 : :
1839 : : /**
1840 : : * Returns the file filter string for file destinations compatible with this parameter.
1841 : : * \see setFileFilter()
1842 : : * \see extension()
1843 : : * \since QGIS 3.10
1844 : : */
1845 : : QString fileFilter() const;
1846 : :
1847 : : /**
1848 : : * Sets the file \a filter string for file destinations compatible with this parameter.
1849 : : *
1850 : : * Calling this method resets any existing extension() setting.
1851 : : *
1852 : : * \see fileFilter()
1853 : : * \see setExtension()
1854 : : * \since QGIS 3.10
1855 : : */
1856 : : void setFileFilter( const QString &filter );
1857 : :
1858 : : QVariantMap toVariantMap() const override;
1859 : : bool fromVariantMap( const QVariantMap &map ) override;
1860 : :
1861 : : /**
1862 : : * Creates a new parameter using the definition from a script code.
1863 : : */
1864 : : static QgsProcessingParameterFile *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Behavior behavior = File ) SIP_FACTORY;
1865 : :
1866 : : private:
1867 : :
1868 : : Behavior mBehavior = File;
1869 : : QString mExtension;
1870 : : QString mFileFilter;
1871 : : };
1872 : :
1873 : : /**
1874 : : * \class QgsProcessingParameterMatrix
1875 : : * \ingroup core
1876 : : * \brief A table (matrix) parameter for processing algorithms.
1877 : : * \since QGIS 3.0
1878 : : */
1879 : 0 : class CORE_EXPORT QgsProcessingParameterMatrix : public QgsProcessingParameterDefinition
1880 : : {
1881 : : public:
1882 : :
1883 : : /**
1884 : : * Constructor for QgsProcessingParameterMatrix.
1885 : : */
1886 : : QgsProcessingParameterMatrix( const QString &name, const QString &description = QString(), int numberRows = 3,
1887 : : bool hasFixedNumberRows = false, const QStringList &headers = QStringList(),
1888 : : const QVariant &defaultValue = QVariant(),
1889 : : bool optional = false );
1890 : :
1891 : : /**
1892 : : * Returns the type name for the parameter class.
1893 : : */
1894 : 0 : static QString typeName() { return QStringLiteral( "matrix" ); }
1895 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1896 : 0 : QString type() const override { return typeName(); }
1897 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1898 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1899 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1900 : :
1901 : : /**
1902 : : * Returns a list of column headers (if set).
1903 : : * \see setHeaders()
1904 : : */
1905 : : QStringList headers() const;
1906 : :
1907 : : /**
1908 : : * Sets the list of column \a headers.
1909 : : * \see headers()
1910 : : */
1911 : : void setHeaders( const QStringList &headers );
1912 : :
1913 : : /**
1914 : : * Returns the fixed number of rows in the table. This parameter only has an
1915 : : * effect if hasFixedNumberRows() is TRUE.
1916 : : * \see setNumberRows()
1917 : : * \see setHasFixedNumberRows()
1918 : : */
1919 : : int numberRows() const;
1920 : :
1921 : : /**
1922 : : * Sets the fixed number of \a rows in the table. This parameter only has an
1923 : : * effect if hasFixedNumberRows() is TRUE.
1924 : : * \see numberRows()
1925 : : * \see setHasFixedNumberRows()
1926 : : */
1927 : : void setNumberRows( int rows );
1928 : :
1929 : : /**
1930 : : * Returns whether the table has a fixed number of rows.
1931 : : * \see numberRows()
1932 : : * \see setHasFixedNumberRows()
1933 : : */
1934 : : bool hasFixedNumberRows() const;
1935 : :
1936 : : /**
1937 : : * Sets whether the table has a fixed number of rows.
1938 : : * \see setNumberRows()
1939 : : * \see hasFixedNumberRows()
1940 : : */
1941 : : void setHasFixedNumberRows( bool hasFixedNumberRows );
1942 : :
1943 : : QVariantMap toVariantMap() const override;
1944 : : bool fromVariantMap( const QVariantMap &map ) override;
1945 : :
1946 : : /**
1947 : : * Creates a new parameter using the definition from a script code.
1948 : : */
1949 : : static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
1950 : :
1951 : : private:
1952 : :
1953 : : QStringList mHeaders;
1954 : : int mNumberRows = 3;
1955 : : bool mFixedNumberRows = false;
1956 : :
1957 : : };
1958 : :
1959 : : /**
1960 : : * \class QgsProcessingParameterMultipleLayers
1961 : : * \ingroup core
1962 : : * \brief A parameter for processing algorithms which accepts multiple map layers.
1963 : : * \since QGIS 3.0
1964 : : */
1965 : 0 : class CORE_EXPORT QgsProcessingParameterMultipleLayers : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
1966 : : {
1967 : : public:
1968 : :
1969 : : /**
1970 : : * Constructor for QgsProcessingParameterMultipleLayers.
1971 : : */
1972 : : QgsProcessingParameterMultipleLayers( const QString &name, const QString &description = QString(), QgsProcessing::SourceType layerType = QgsProcessing::TypeVectorAnyGeometry,
1973 : : const QVariant &defaultValue = QVariant(),
1974 : : bool optional = false );
1975 : :
1976 : : /**
1977 : : * Returns the type name for the parameter class.
1978 : : */
1979 : 0 : static QString typeName() { return QStringLiteral( "multilayer" ); }
1980 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
1981 : 0 : QString type() const override { return typeName(); }
1982 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
1983 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
1984 : : QString asScriptCode() const override;
1985 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
1986 : : QString createFileFilter() const override;
1987 : :
1988 : : /**
1989 : : * Returns the layer type for layers acceptable by the parameter.
1990 : : * \see setLayerType()
1991 : : */
1992 : : QgsProcessing::SourceType layerType() const;
1993 : :
1994 : : /**
1995 : : * Sets the layer \a type for layers acceptable by the parameter.
1996 : : * \see layerType()
1997 : : */
1998 : : void setLayerType( QgsProcessing::SourceType type );
1999 : :
2000 : : /**
2001 : : * Returns the minimum number of layers required for the parameter. If the return value is < 1
2002 : : * then the parameter accepts any number of layers.
2003 : : * \see setMinimumNumberInputs()
2004 : : */
2005 : : int minimumNumberInputs() const;
2006 : :
2007 : : /**
2008 : : * Sets the \a minimum number of layers required for the parameter. The minimum must be >= 1
2009 : : * if the parameter is not optional.
2010 : : * \see minimumNumberInputs()
2011 : : */
2012 : : void setMinimumNumberInputs( int minimum );
2013 : :
2014 : : QVariantMap toVariantMap() const override;
2015 : : bool fromVariantMap( const QVariantMap &map ) override;
2016 : :
2017 : : /**
2018 : : * Creates a new parameter using the definition from a script code.
2019 : : */
2020 : : static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2021 : :
2022 : : private:
2023 : :
2024 : : QgsProcessing::SourceType mLayerType = QgsProcessing::TypeVectorAnyGeometry;
2025 : : int mMinimumNumberInputs = 0;
2026 : :
2027 : : };
2028 : :
2029 : : /**
2030 : : * \class QgsProcessingParameterNumber
2031 : : * \ingroup core
2032 : : * \brief A numeric parameter for processing algorithms.
2033 : : *
2034 : : * For numeric parameters with a dataType() of Double, the number of decimals places
2035 : : * shown in the parameter's widget can be specified by setting the parameter's metadata. For example:
2036 : : *
2037 : : * \code{.py}
2038 : : * param = QgsProcessingParameterNumber( 'VAL', 'Threshold', type=QgsProcessingParameterNumber.Double)
2039 : : * # only show two decimal places in parameter's widgets, not 6:
2040 : : * param.setMetadata( {'widget_wrapper':
2041 : : * { 'decimals': 2 }
2042 : : * })
2043 : : * \endcode
2044 : : *
2045 : : * \since QGIS 3.0
2046 : : */
2047 : 0 : class CORE_EXPORT QgsProcessingParameterNumber : public QgsProcessingParameterDefinition
2048 : : {
2049 : : public:
2050 : :
2051 : : //! Numeric data type
2052 : : enum Type
2053 : : {
2054 : : Integer, //!< Integer values
2055 : : Double, //!< Double/float values
2056 : : };
2057 : :
2058 : : /**
2059 : : * Constructor for QgsProcessingParameterNumber.
2060 : : */
2061 : : explicit QgsProcessingParameterNumber( const QString &name, const QString &description = QString(),
2062 : : Type type = Integer,
2063 : : const QVariant &defaultValue = QVariant(),
2064 : : bool optional = false,
2065 : : double minValue = std::numeric_limits<double>::lowest() + 1,
2066 : : double maxValue = std::numeric_limits<double>::max()
2067 : : );
2068 : :
2069 : : /**
2070 : : * Returns the type name for the parameter class.
2071 : : */
2072 : 0 : static QString typeName() { return QStringLiteral( "number" ); }
2073 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2074 : 0 : QString type() const override { return typeName(); }
2075 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2076 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2077 : : QString toolTip() const override;
2078 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2079 : :
2080 : : /**
2081 : : * Returns the minimum value acceptable by the parameter.
2082 : : * \see setMinimum()
2083 : : */
2084 : : double minimum() const;
2085 : :
2086 : : /**
2087 : : * Sets the \a minimum value acceptable by the parameter.
2088 : : * \see minimum()
2089 : : */
2090 : : void setMinimum( double minimum );
2091 : :
2092 : : /**
2093 : : * Returns the maximum value acceptable by the parameter.
2094 : : * \see setMaximum()
2095 : : */
2096 : : double maximum() const;
2097 : :
2098 : : /**
2099 : : * Sets the \a maximum value acceptable by the parameter.
2100 : : * \see maximum()
2101 : : */
2102 : : void setMaximum( double maximum );
2103 : :
2104 : : /**
2105 : : * Returns the acceptable data type for the parameter.
2106 : : * \see setDataType()
2107 : : */
2108 : : Type dataType() const;
2109 : :
2110 : : /**
2111 : : * Sets the acceptable data \a type for the parameter.
2112 : : * \see dataType()
2113 : : */
2114 : : void setDataType( Type type );
2115 : :
2116 : : QVariantMap toVariantMap() const override;
2117 : : bool fromVariantMap( const QVariantMap &map ) override;
2118 : :
2119 : : /**
2120 : : * Creates a new parameter using the definition from a script code.
2121 : : */
2122 : : static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2123 : :
2124 : : private:
2125 : :
2126 : : double mMin = std::numeric_limits<double>::lowest() + 1;
2127 : : double mMax = std::numeric_limits<double>::max();
2128 : : Type mDataType = Integer;
2129 : : };
2130 : :
2131 : : /**
2132 : : * \class QgsProcessingParameterDistance
2133 : : * \ingroup core
2134 : : * \brief A double numeric parameter for distance values. Linked to a source layer or CRS parameter
2135 : : * to determine what units the distance values are in.
2136 : : *
2137 : : * The number of decimals places shown in a distance parameter's widget can be specified by
2138 : : * setting the parameter's metadata. For example:
2139 : : *
2140 : : * \code{.py}
2141 : : * param = QgsProcessingParameterDistance( 'VAL', 'Threshold')
2142 : : * # only show two decimal places in parameter's widgets, not 6:
2143 : : * param.setMetadata( {'widget_wrapper':
2144 : : * { 'decimals': 2 }
2145 : : * })
2146 : : * \endcode
2147 : : *
2148 : : * \since QGIS 3.2
2149 : : */
2150 : 0 : class CORE_EXPORT QgsProcessingParameterDistance : public QgsProcessingParameterNumber
2151 : : {
2152 : : public:
2153 : :
2154 : : /**
2155 : : * Constructor for QgsProcessingParameterDistance.
2156 : : */
2157 : : explicit QgsProcessingParameterDistance( const QString &name, const QString &description = QString(),
2158 : : const QVariant &defaultValue = QVariant(),
2159 : : const QString &parentParameterName = QString(),
2160 : : bool optional = false,
2161 : : double minValue = std::numeric_limits<double>::lowest() + 1,
2162 : : double maxValue = std::numeric_limits<double>::max() );
2163 : :
2164 : : /**
2165 : : * Returns the type name for the parameter class.
2166 : : */
2167 : 0 : static QString typeName() { return QStringLiteral( "distance" ); }
2168 : :
2169 : : QgsProcessingParameterDistance *clone() const override SIP_FACTORY;
2170 : :
2171 : : QString type() const override;
2172 : : QStringList dependsOnOtherParameters() const override;
2173 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2174 : :
2175 : : /**
2176 : : * Returns the name of the parent parameter, or an empty string if this is not set.
2177 : : * \see setParentParameterName()
2178 : : */
2179 : : QString parentParameterName() const;
2180 : :
2181 : : /**
2182 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2183 : : * \see parentParameterName()
2184 : : */
2185 : : void setParentParameterName( const QString &parentParameterName );
2186 : :
2187 : : /**
2188 : : * Returns the default distance unit for the parameter.
2189 : : *
2190 : : * \see setDefaultUnit()
2191 : : * \since QGIS 3.4.3
2192 : : */
2193 : : QgsUnitTypes::DistanceUnit defaultUnit() const { return mDefaultUnit; }
2194 : :
2195 : : /**
2196 : : * Sets the default distance \a unit for the parameter.
2197 : : *
2198 : : * \see defaultUnit()
2199 : : * \since QGIS 3.4.3
2200 : : */
2201 : 0 : void setDefaultUnit( QgsUnitTypes::DistanceUnit unit ) { mDefaultUnit = unit; }
2202 : :
2203 : : QVariantMap toVariantMap() const override;
2204 : : bool fromVariantMap( const QVariantMap &map ) override;
2205 : :
2206 : : private:
2207 : :
2208 : : QString mParentParameterName;
2209 : : QgsUnitTypes::DistanceUnit mDefaultUnit = QgsUnitTypes::DistanceUnknownUnit;
2210 : :
2211 : : };
2212 : :
2213 : : /**
2214 : : * \class QgsProcessingParameterScale
2215 : : * \ingroup core
2216 : : * \brief A double numeric parameter for map scale values.
2217 : : *
2218 : : * QgsProcessingParameterScale should be evaluated by calling QgsProcessingAlgorithm::parameterAsDouble(),
2219 : : * which will return a numeric value representing the scale denominator.
2220 : : *
2221 : : * \since QGIS 3.8
2222 : : */
2223 : 0 : class CORE_EXPORT QgsProcessingParameterScale : public QgsProcessingParameterNumber
2224 : : {
2225 : : public:
2226 : :
2227 : : /**
2228 : : * Constructor for QgsProcessingParameterScale.
2229 : : */
2230 : : explicit QgsProcessingParameterScale( const QString &name, const QString &description = QString(),
2231 : : const QVariant &defaultValue = QVariant(),
2232 : : bool optional = false );
2233 : :
2234 : : /**
2235 : : * Returns the type name for the parameter class.
2236 : : */
2237 : 0 : static QString typeName() { return QStringLiteral( "scale" ); }
2238 : :
2239 : : QgsProcessingParameterScale *clone() const override SIP_FACTORY;
2240 : :
2241 : : QString type() const override;
2242 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2243 : :
2244 : : /**
2245 : : * Creates a new parameter using the definition from a script code.
2246 : : */
2247 : : static QgsProcessingParameterScale *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2248 : :
2249 : : };
2250 : :
2251 : : /**
2252 : : * \class QgsProcessingParameterRange
2253 : : * \ingroup core
2254 : : * \brief A numeric range parameter for processing algorithms.
2255 : : * \since QGIS 3.0
2256 : : */
2257 : 0 : class CORE_EXPORT QgsProcessingParameterRange : public QgsProcessingParameterDefinition
2258 : : {
2259 : : public:
2260 : :
2261 : : /**
2262 : : * Constructor for QgsProcessingParameterRange.
2263 : : */
2264 : : QgsProcessingParameterRange( const QString &name, const QString &description = QString(),
2265 : : QgsProcessingParameterNumber::Type type = QgsProcessingParameterNumber::Integer,
2266 : : const QVariant &defaultValue = QVariant(),
2267 : : bool optional = false );
2268 : :
2269 : : /**
2270 : : * Returns the type name for the parameter class.
2271 : : */
2272 : 0 : static QString typeName() { return QStringLiteral( "range" ); }
2273 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2274 : 0 : QString type() const override { return typeName(); }
2275 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2276 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2277 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2278 : :
2279 : : /**
2280 : : * Returns the acceptable data type for the range.
2281 : : * \see setDataType()
2282 : : */
2283 : : QgsProcessingParameterNumber::Type dataType() const;
2284 : :
2285 : : /**
2286 : : * Sets the acceptable data \a type for the range.
2287 : : * \see dataType()
2288 : : */
2289 : : void setDataType( QgsProcessingParameterNumber::Type dataType );
2290 : :
2291 : : QVariantMap toVariantMap() const override;
2292 : : bool fromVariantMap( const QVariantMap &map ) override;
2293 : :
2294 : : /**
2295 : : * Creates a new parameter using the definition from a script code.
2296 : : */
2297 : : static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2298 : :
2299 : : private:
2300 : :
2301 : : QgsProcessingParameterNumber::Type mDataType = QgsProcessingParameterNumber::Integer;
2302 : : };
2303 : :
2304 : : /**
2305 : : * \class QgsProcessingParameterRasterLayer
2306 : : * \ingroup core
2307 : : * \brief A raster layer parameter for processing algorithms.
2308 : : * \since QGIS 3.0
2309 : : */
2310 : 0 : class CORE_EXPORT QgsProcessingParameterRasterLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2311 : : {
2312 : : public:
2313 : :
2314 : : /**
2315 : : * Constructor for QgsProcessingParameterRasterLayer.
2316 : : */
2317 : : QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2318 : : bool optional = false );
2319 : :
2320 : : /**
2321 : : * Returns the type name for the parameter class.
2322 : : */
2323 : 0 : static QString typeName() { return QStringLiteral( "raster" ); }
2324 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2325 : 0 : QString type() const override { return typeName(); }
2326 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2327 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2328 : : QString createFileFilter() const override;
2329 : :
2330 : : /**
2331 : : * Creates a new parameter using the definition from a script code.
2332 : : */
2333 : : static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2334 : :
2335 : : };
2336 : :
2337 : : /**
2338 : : * \class QgsProcessingParameterEnum
2339 : : * \ingroup core
2340 : : * \brief An enum based parameter for processing algorithms, allowing for selection from predefined values.
2341 : : * \since QGIS 3.0
2342 : : */
2343 : 10 : class CORE_EXPORT QgsProcessingParameterEnum : public QgsProcessingParameterDefinition
2344 : : {
2345 : : public:
2346 : :
2347 : : /**
2348 : : * Constructor for QgsProcessingParameterEnum.
2349 : : */
2350 : : QgsProcessingParameterEnum( const QString &name, const QString &description = QString(), const QStringList &options = QStringList(),
2351 : : bool allowMultiple = false,
2352 : : const QVariant &defaultValue = QVariant(),
2353 : : bool optional = false,
2354 : : bool usesStaticStrings = false );
2355 : :
2356 : : /**
2357 : : * Returns the type name for the parameter class.
2358 : : */
2359 : 0 : static QString typeName() { return QStringLiteral( "enum" ); }
2360 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2361 : 0 : QString type() const override { return typeName(); }
2362 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2363 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2364 : : QString asScriptCode() const override;
2365 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2366 : :
2367 : : /**
2368 : : * Returns the list of acceptable options for the parameter.
2369 : : * \see setOptions()
2370 : : */
2371 : : QStringList options() const;
2372 : :
2373 : : /**
2374 : : * Sets the list of acceptable \a options for the parameter.
2375 : : * \see options()
2376 : : */
2377 : : void setOptions( const QStringList &options );
2378 : :
2379 : : /**
2380 : : * Returns TRUE if the parameter allows multiple selected values.
2381 : : * \see setAllowMultiple()
2382 : : */
2383 : : bool allowMultiple() const;
2384 : :
2385 : : /**
2386 : : * Sets whether the parameter allows multiple selected values.
2387 : : * \see allowMultiple()
2388 : : */
2389 : : void setAllowMultiple( bool allowMultiple );
2390 : :
2391 : : /**
2392 : : * Returns TRUE if the parameter uses static (non-translated) string
2393 : : * values for its enumeration choice list.
2394 : : * \see setUsesStaticStrings()
2395 : : * \since QGIS 3.18
2396 : : */
2397 : : bool usesStaticStrings() const;
2398 : :
2399 : : /**
2400 : : * Sets whether the parameter uses static (non-translated) string
2401 : : * values for its enumeration choice list.
2402 : : * \see usesStaticStrings()
2403 : : * \since QGIS 3.18
2404 : : */
2405 : : void setUsesStaticStrings( bool usesStaticStrings );
2406 : :
2407 : : QVariantMap toVariantMap() const override;
2408 : : bool fromVariantMap( const QVariantMap &map ) override;
2409 : :
2410 : : /**
2411 : : * Creates a new parameter using the definition from a script code.
2412 : : */
2413 : : static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2414 : :
2415 : : private:
2416 : :
2417 : : QStringList mOptions;
2418 : : bool mAllowMultiple = false;
2419 : : bool mUsesStaticStrings = false;
2420 : : };
2421 : :
2422 : : /**
2423 : : * \class QgsProcessingParameterString
2424 : : * \ingroup core
2425 : : * \brief A string parameter for processing algorithms.
2426 : : * \since QGIS 3.0
2427 : : */
2428 : 0 : class CORE_EXPORT QgsProcessingParameterString : public QgsProcessingParameterDefinition
2429 : : {
2430 : : public:
2431 : :
2432 : : /**
2433 : : * Constructor for QgsProcessingParameterString.
2434 : : */
2435 : : QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2436 : : bool multiLine = false,
2437 : : bool optional = false );
2438 : :
2439 : : /**
2440 : : * Returns the type name for the parameter class.
2441 : : */
2442 : 0 : static QString typeName() { return QStringLiteral( "string" ); }
2443 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2444 : 0 : QString type() const override { return typeName(); }
2445 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2446 : : QString asScriptCode() const override;
2447 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2448 : :
2449 : : /**
2450 : : * Returns TRUE if the parameter allows multiline strings.
2451 : : * \see setMultiLine()
2452 : : */
2453 : : bool multiLine() const;
2454 : :
2455 : : /**
2456 : : * Sets whether the parameter allows multiline strings.
2457 : : * \see multiLine()
2458 : : */
2459 : : void setMultiLine( bool multiLine );
2460 : :
2461 : : QVariantMap toVariantMap() const override;
2462 : : bool fromVariantMap( const QVariantMap &map ) override;
2463 : :
2464 : : /**
2465 : : * Creates a new parameter using the definition from a script code.
2466 : : */
2467 : : static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2468 : :
2469 : : private:
2470 : :
2471 : : bool mMultiLine = false;
2472 : :
2473 : : };
2474 : :
2475 : :
2476 : : /**
2477 : : * \class QgsProcessingParameterAuthConfig
2478 : : * \ingroup core
2479 : : * \brief A string parameter for authentication configuration ID values.
2480 : : *
2481 : : * This parameter allows for users to select from available authentication configurations,
2482 : : * or create new authentication configurations as required.
2483 : : *
2484 : : * QgsProcessingParameterAuthConfig should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
2485 : : *
2486 : : * \since QGIS 3.6
2487 : : */
2488 : 0 : class CORE_EXPORT QgsProcessingParameterAuthConfig : public QgsProcessingParameterDefinition
2489 : : {
2490 : : public:
2491 : :
2492 : : /**
2493 : : * Constructor for QgsProcessingParameterAuthConfig.
2494 : : */
2495 : : QgsProcessingParameterAuthConfig( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2496 : : bool optional = false );
2497 : :
2498 : : /**
2499 : : * Returns the type name for the parameter class.
2500 : : */
2501 : 0 : static QString typeName() { return QStringLiteral( "authcfg" ); }
2502 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2503 : 0 : QString type() const override { return typeName(); }
2504 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2505 : : QString asScriptCode() const override;
2506 : :
2507 : : /**
2508 : : * Creates a new parameter using the definition from a script code.
2509 : : */
2510 : : static QgsProcessingParameterAuthConfig *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2511 : :
2512 : : };
2513 : :
2514 : : /**
2515 : : * \class QgsProcessingParameterExpression
2516 : : * \ingroup core
2517 : : * \brief An expression parameter for processing algorithms.
2518 : : * \since QGIS 3.0
2519 : : */
2520 : 0 : class CORE_EXPORT QgsProcessingParameterExpression : public QgsProcessingParameterDefinition
2521 : : {
2522 : : public:
2523 : :
2524 : : /**
2525 : : * Constructor for QgsProcessingParameterExpression.
2526 : : */
2527 : : QgsProcessingParameterExpression( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2528 : : const QString &parentLayerParameterName = QString(),
2529 : : bool optional = false );
2530 : :
2531 : : /**
2532 : : * Returns the type name for the parameter class.
2533 : : */
2534 : 0 : static QString typeName() { return QStringLiteral( "expression" ); }
2535 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2536 : 0 : QString type() const override { return typeName(); }
2537 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2538 : : QStringList dependsOnOtherParameters() const override;
2539 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2540 : :
2541 : : /**
2542 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
2543 : : * \see setParentLayerParameterName()
2544 : : */
2545 : : QString parentLayerParameterName() const;
2546 : :
2547 : : /**
2548 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2549 : : * \see parentLayerParameterName()
2550 : : */
2551 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
2552 : :
2553 : : QVariantMap toVariantMap() const override;
2554 : : bool fromVariantMap( const QVariantMap &map ) override;
2555 : :
2556 : : /**
2557 : : * Creates a new parameter using the definition from a script code.
2558 : : */
2559 : : static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2560 : :
2561 : : private:
2562 : :
2563 : : QString mParentLayerParameterName;
2564 : :
2565 : : };
2566 : :
2567 : :
2568 : : /**
2569 : : * \class QgsProcessingParameterLimitedDataTypes
2570 : : * \ingroup core
2571 : : * \brief Can be inherited by parameters which require limits to their acceptable data types.
2572 : : * \since QGIS 3.0
2573 : : */
2574 : 0 : class CORE_EXPORT QgsProcessingParameterLimitedDataTypes
2575 : : {
2576 : : public:
2577 : :
2578 : : /**
2579 : : * Constructor for QgsProcessingParameterLimitedDataTypes, with a list of acceptable data \a types.
2580 : : */
2581 : : QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );
2582 : :
2583 : : /**
2584 : : * Returns the geometry types for sources acceptable by the parameter.
2585 : : * \see setDataTypes()
2586 : : */
2587 : : QList< int > dataTypes() const;
2588 : :
2589 : : /**
2590 : : * Sets the geometry \a types for sources acceptable by the parameter.
2591 : : * \see dataTypes()
2592 : : */
2593 : : void setDataTypes( const QList< int > &types );
2594 : :
2595 : : protected:
2596 : :
2597 : : //! List of acceptable data types for the parameter
2598 : : QList< int > mDataTypes;
2599 : : };
2600 : :
2601 : : /**
2602 : : * \class QgsProcessingParameterVectorLayer
2603 : : * \ingroup core
2604 : : * \brief A vector layer (with or without geometry) parameter for processing algorithms. Consider using
2605 : : * the more versatile QgsProcessingParameterFeatureSource wherever possible.
2606 : : * \since QGIS 3.0
2607 : : */
2608 : 0 : class CORE_EXPORT QgsProcessingParameterVectorLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2609 : : {
2610 : : public:
2611 : :
2612 : : /**
2613 : : * Constructor for QgsProcessingParameterVectorLayer.
2614 : : */
2615 : : QgsProcessingParameterVectorLayer( const QString &name,
2616 : : const QString &description = QString(),
2617 : : const QList< int > &types = QList< int >(),
2618 : : const QVariant &defaultValue = QVariant(),
2619 : : bool optional = false );
2620 : :
2621 : : /**
2622 : : * Returns the type name for the parameter class.
2623 : : */
2624 : 0 : static QString typeName() { return QStringLiteral( "vector" ); }
2625 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2626 : 0 : QString type() const override { return typeName(); }
2627 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2628 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2629 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2630 : : QString createFileFilter() const override;
2631 : :
2632 : : QVariantMap toVariantMap() const override;
2633 : : bool fromVariantMap( const QVariantMap &map ) override;
2634 : :
2635 : : /**
2636 : : * Creates a new parameter using the definition from a script code.
2637 : : */
2638 : : static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2639 : :
2640 : : };
2641 : :
2642 : : /**
2643 : : * \class QgsProcessingParameterMeshLayer
2644 : : * \ingroup core
2645 : : * \brief A mesh layer parameter for processing algorithms.
2646 : : * \since QGIS 3.6
2647 : : */
2648 : 0 : class CORE_EXPORT QgsProcessingParameterMeshLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2649 : : {
2650 : : public:
2651 : :
2652 : : /**
2653 : : * Constructor for QgsProcessingParameterMeshLayer.
2654 : : */
2655 : : QgsProcessingParameterMeshLayer( const QString &name,
2656 : : const QString &description = QString(),
2657 : : const QVariant &defaultValue = QVariant(),
2658 : : bool optional = false );
2659 : :
2660 : : /**
2661 : : * Returns the type name for the parameter class.
2662 : : */
2663 : 0 : static QString typeName() { return QStringLiteral( "mesh" ); }
2664 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2665 : 0 : QString type() const override { return typeName(); }
2666 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2667 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2668 : : QString createFileFilter() const override;
2669 : :
2670 : : /**
2671 : : * Creates a new parameter using the definition from a script code.
2672 : : */
2673 : : static QgsProcessingParameterMeshLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2674 : : };
2675 : :
2676 : : /**
2677 : : * \class QgsProcessingParameterMapLayer
2678 : : * \ingroup core
2679 : : * \brief A map layer parameter for processing algorithms.
2680 : : * \since QGIS 3.0
2681 : : */
2682 : 0 : class CORE_EXPORT QgsProcessingParameterMapLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2683 : : {
2684 : : public:
2685 : :
2686 : : /**
2687 : : * Constructor for QgsProcessingParameterMapLayer.
2688 : : */
2689 : : QgsProcessingParameterMapLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2690 : : bool optional = false,
2691 : : const QList< int > &types = QList< int >() );
2692 : :
2693 : : /**
2694 : : * Returns the type name for the parameter class.
2695 : : */
2696 : 0 : static QString typeName() { return QStringLiteral( "layer" ); }
2697 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2698 : 0 : QString type() const override { return typeName(); }
2699 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2700 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2701 : : QString asScriptCode() const override;
2702 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2703 : : QString createFileFilter() const override;
2704 : :
2705 : : QVariantMap toVariantMap() const override;
2706 : : bool fromVariantMap( const QVariantMap &map ) override;
2707 : :
2708 : : /**
2709 : : * Creates a new parameter using the definition from a script code.
2710 : : */
2711 : : static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2712 : :
2713 : : };
2714 : :
2715 : : /**
2716 : : * \class QgsProcessingParameterField
2717 : : * \ingroup core
2718 : : * \brief A vector layer or feature source field parameter for processing algorithms.
2719 : : * \since QGIS 3.0
2720 : : */
2721 : 0 : class CORE_EXPORT QgsProcessingParameterField : public QgsProcessingParameterDefinition
2722 : : {
2723 : : public:
2724 : :
2725 : : //! Field data types
2726 : : enum DataType
2727 : : {
2728 : : Any = -1, //!< Accepts any field
2729 : : Numeric = 0, //!< Accepts numeric fields
2730 : : String = 1, //!< Accepts string fields
2731 : : DateTime = 2 //!< Accepts datetime fields
2732 : : };
2733 : :
2734 : : /**
2735 : : * Constructor for QgsProcessingParameterField.
2736 : : */
2737 : : QgsProcessingParameterField( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2738 : : const QString &parentLayerParameterName = QString(),
2739 : : DataType type = Any,
2740 : : bool allowMultiple = false,
2741 : : bool optional = false,
2742 : : bool defaultToAllFields = false );
2743 : :
2744 : : /**
2745 : : * Returns the type name for the parameter class.
2746 : : */
2747 : 0 : static QString typeName() { return QStringLiteral( "field" ); }
2748 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2749 : 0 : QString type() const override { return typeName(); }
2750 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2751 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2752 : : QString asScriptCode() const override;
2753 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2754 : : QStringList dependsOnOtherParameters() const override;
2755 : :
2756 : : /**
2757 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
2758 : : * \see setParentLayerParameterName()
2759 : : */
2760 : : QString parentLayerParameterName() const;
2761 : :
2762 : : /**
2763 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
2764 : : * \see parentLayerParameterName()
2765 : : */
2766 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
2767 : :
2768 : : /**
2769 : : * Returns the acceptable data type for the field.
2770 : : * \see setDataType()
2771 : : */
2772 : : DataType dataType() const;
2773 : :
2774 : : /**
2775 : : * Sets the acceptable data \a type for the field.
2776 : : * \see dataType()
2777 : : */
2778 : : void setDataType( DataType type );
2779 : :
2780 : : /**
2781 : : * Returns whether multiple field selections are permitted.
2782 : : * \see setAllowMultiple()
2783 : : */
2784 : : bool allowMultiple() const;
2785 : :
2786 : : /**
2787 : : * Sets whether multiple field selections are permitted.
2788 : : * \see allowMultiple()
2789 : : */
2790 : : void setAllowMultiple( bool allowMultiple );
2791 : :
2792 : : /**
2793 : : * Returns whether a parameter which allows multiple selections (see allowMultiple()) should automatically
2794 : : * select all fields as the default value.
2795 : : *
2796 : : * If TRUE, this will override any existing defaultValue() set on the parameter.
2797 : : *
2798 : : * \see setDefaultToAllFields()
2799 : : * \since QGIS 3.12
2800 : : */
2801 : : bool defaultToAllFields() const;
2802 : :
2803 : : /**
2804 : : * Sets whether a parameter which allows multiple selections (see allowMultiple()) should automatically
2805 : : * select all fields as the default value.
2806 : : *
2807 : : * If TRUE, this will override any existing defaultValue() set on the parameter.
2808 : : *
2809 : : * \see defaultToAllFields()
2810 : : * \since QGIS 3.12
2811 : : */
2812 : : void setDefaultToAllFields( bool enabled );
2813 : :
2814 : : QVariantMap toVariantMap() const override;
2815 : : bool fromVariantMap( const QVariantMap &map ) override;
2816 : :
2817 : : /**
2818 : : * Creates a new parameter using the definition from a script code.
2819 : : */
2820 : : static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2821 : :
2822 : : private:
2823 : :
2824 : : QString mParentLayerParameterName;
2825 : : DataType mDataType = Any;
2826 : : bool mAllowMultiple = false;
2827 : : bool mDefaultToAllFields = false;
2828 : :
2829 : : };
2830 : :
2831 : :
2832 : : /**
2833 : : * \class QgsProcessingParameterFeatureSource
2834 : : * \ingroup core
2835 : : * \brief An input feature source (such as vector layers) parameter for processing algorithms.
2836 : : * \since QGIS 3.0
2837 : : */
2838 : 0 : class CORE_EXPORT QgsProcessingParameterFeatureSource : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
2839 : : {
2840 : : public:
2841 : :
2842 : : /**
2843 : : * Constructor for QgsProcessingParameterFeatureSource.
2844 : : */
2845 : : QgsProcessingParameterFeatureSource( const QString &name, const QString &description = QString(),
2846 : : const QList< int > &types = QList< int >(),
2847 : : const QVariant &defaultValue = QVariant(), bool optional = false );
2848 : :
2849 : : /**
2850 : : * Returns the type name for the parameter class.
2851 : : */
2852 : 0 : static QString typeName() { return QStringLiteral( "source" ); }
2853 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
2854 : 0 : QString type() const override { return typeName(); }
2855 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
2856 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
2857 : : QString asScriptCode() const override;
2858 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2859 : : QString createFileFilter() const override;
2860 : :
2861 : : QVariantMap toVariantMap() const override;
2862 : : bool fromVariantMap( const QVariantMap &map ) override;
2863 : :
2864 : : /**
2865 : : * Creates a new parameter using the definition from a script code.
2866 : : */
2867 : : static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
2868 : :
2869 : : };
2870 : :
2871 : : /**
2872 : : * \class QgsProcessingDestinationParameter
2873 : : * \ingroup core
2874 : : * \brief Base class for all parameter definitions which represent file or layer destinations, e.g. parameters
2875 : : * which are used for the destination for layers output by an algorithm.
2876 : : * \since QGIS 3.0
2877 : : */
2878 : 0 : class CORE_EXPORT QgsProcessingDestinationParameter : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
2879 : : {
2880 : : public:
2881 : :
2882 : : /**
2883 : : * Constructor for QgsProcessingDestinationParameter.
2884 : : *
2885 : : * If \a createByDefault is FALSE and the parameter is \a optional, then the destination
2886 : : * output will not be created by default.
2887 : : */
2888 : : QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
2889 : : bool optional = false, bool createByDefault = true );
2890 : :
2891 : 0 : bool isDestination() const override { return true; }
2892 : : QVariantMap toVariantMap() const override;
2893 : : bool fromVariantMap( const QVariantMap &map ) override;
2894 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
2895 : : QString createFileFilter() const override;
2896 : :
2897 : : /**
2898 : : * Returns a new QgsProcessingOutputDefinition corresponding to the definition of the destination
2899 : : * parameter.
2900 : : */
2901 : : virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 SIP_FACTORY;
2902 : :
2903 : : /**
2904 : : * Returns TRUE if the destination parameter supports non filed-based outputs,
2905 : : * such as memory layers or direct database outputs.
2906 : : * \see setSupportsNonFileBasedOutput()
2907 : : */
2908 : 0 : bool supportsNonFileBasedOutput() const { return mSupportsNonFileBasedOutputs; }
2909 : :
2910 : : /**
2911 : : * Sets whether the destination parameter supports non filed-based outputs,
2912 : : * such as memory layers or direct database outputs.
2913 : : * \see supportsNonFileBasedOutput()
2914 : : */
2915 : 0 : void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput ) { mSupportsNonFileBasedOutputs = supportsNonFileBasedOutput; }
2916 : :
2917 : : /**
2918 : : * Returns the default file extension for destination file paths
2919 : : * associated with this parameter.
2920 : : */
2921 : : virtual QString defaultFileExtension() const = 0;
2922 : :
2923 : : /**
2924 : : * Generates a temporary destination value for this parameter. The returned
2925 : : * value will be a file path or QGIS data provider URI suitable for
2926 : : * temporary storage of created layers and files.
2927 : : */
2928 : : virtual QString generateTemporaryDestination() const;
2929 : :
2930 : : /**
2931 : : * Tests whether a \a value is a supported value for this parameter.
2932 : : *
2933 : : * Will return FALSE when a \a value with an unsupported file extension is specified. The default implementation
2934 : : * calls QgsProcessingProvider::isSupportedOutputValue() to test compatibility.
2935 : : *
2936 : : * \param value value to test
2937 : : * \param context Processing context
2938 : : * \param error will be set to a descriptive error string
2939 : : *
2940 : : * \returns TRUE if \a value is supported.
2941 : : *
2942 : : * \since QGIS 3.14
2943 : : */
2944 : : virtual bool isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error SIP_OUT ) const;
2945 : :
2946 : : /**
2947 : : * Returns TRUE if the destination should be created by default. For optional parameters,
2948 : : * a return value of FALSE indicates that the destination should not be created by default.
2949 : : * \see setCreateByDefault()
2950 : : */
2951 : : bool createByDefault() const;
2952 : :
2953 : : /**
2954 : : * Sets whether the destination should be created by default. For optional parameters,
2955 : : * a value of FALSE indicates that the destination should not be created by default.
2956 : : * \see createByDefault()
2957 : : */
2958 : : void setCreateByDefault( bool createByDefault );
2959 : :
2960 : : protected:
2961 : :
2962 : : /**
2963 : : * Original (source) provider which this parameter has been derived from.
2964 : : * In the case of destination parameters which are part of model algorithms, this
2965 : : * will reflect the child algorithm's provider which actually generates the
2966 : : * parameter, as opposed to the provider which this parameter belongs to (i.e.
2967 : : * the model provider)
2968 : : * \since QGIS 3.2
2969 : : */
2970 : 0 : QgsProcessingProvider *originalProvider() const { return mOriginalProvider; }
2971 : :
2972 : : private:
2973 : :
2974 : : /**
2975 : : * Original (source) provider which this parameter has been derived from.
2976 : : * In the case of destination parameters which are part of model algorithms, this
2977 : : * will reflect the child algorithm's provider which actually generates the
2978 : : * parameter, as opposed to the provider which this parameter belongs to (i.e.
2979 : : * the model provider)
2980 : : */
2981 : : QgsProcessingProvider *mOriginalProvider = nullptr;
2982 : :
2983 : : bool mSupportsNonFileBasedOutputs = true;
2984 : : bool mCreateByDefault = true;
2985 : :
2986 : : friend class QgsProcessingModelAlgorithm;
2987 : : friend class TestQgsProcessing;
2988 : : };
2989 : :
2990 : :
2991 : : /**
2992 : : * \class QgsProcessingParameterFeatureSink
2993 : : * \ingroup core
2994 : : * \brief A feature sink output for processing algorithms.
2995 : : *
2996 : : * A parameter which represents the destination feature sink for features created by an algorithm.
2997 : : * \since QGIS 3.0
2998 : : */
2999 : 0 : class CORE_EXPORT QgsProcessingParameterFeatureSink : public QgsProcessingDestinationParameter
3000 : : {
3001 : : public:
3002 : :
3003 : : /**
3004 : : * Constructor for QgsProcessingParameterFeatureSink.
3005 : : *
3006 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3007 : : * output will not be created by default.
3008 : : */
3009 : : QgsProcessingParameterFeatureSink( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
3010 : : bool optional = false, bool createByDefault = true, bool supportsAppend = false );
3011 : :
3012 : : /**
3013 : : * Returns the type name for the parameter class.
3014 : : */
3015 : 0 : static QString typeName() { return QStringLiteral( "sink" ); }
3016 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3017 : 0 : QString type() const override { return typeName(); }
3018 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3019 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3020 : : QString asScriptCode() const override;
3021 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3022 : : QString defaultFileExtension() const override;
3023 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3024 : : QString createFileFilter() const override;
3025 : :
3026 : : /**
3027 : : * Returns a list of the vector format file extensions supported by this parameter.
3028 : : * \see defaultFileExtension()
3029 : : * \since QGIS 3.2
3030 : : */
3031 : : virtual QStringList supportedOutputVectorLayerExtensions() const;
3032 : :
3033 : : /**
3034 : : * Returns the layer type for sinks associated with the parameter.
3035 : : * \see setDataType()
3036 : : */
3037 : : QgsProcessing::SourceType dataType() const;
3038 : :
3039 : : /**
3040 : : * Returns TRUE if sink is likely to include geometries. In cases were presence of geometry
3041 : : * cannot be reliably determined in advance, this method will default to returning TRUE.
3042 : : */
3043 : : bool hasGeometry() const;
3044 : :
3045 : : /**
3046 : : * Sets the layer \a type for the sinks associated with the parameter.
3047 : : * \see dataType()
3048 : : */
3049 : : void setDataType( QgsProcessing::SourceType type );
3050 : :
3051 : : /**
3052 : : * Returns TRUE if the sink supports appending features to an existing table.
3053 : : *
3054 : : * A sink only supports appending if the algorithm implements QgsProcessingAlgorithm::sinkProperties for the sink parameter.
3055 : : *
3056 : : * \see setSupportsAppend()
3057 : : * \since QGIS 3.14
3058 : : */
3059 : : bool supportsAppend() const;
3060 : :
3061 : : /**
3062 : : * Sets whether the sink supports appending features to an existing table.
3063 : : *
3064 : : * \warning A sink only supports appending if the algorithm implements QgsProcessingAlgorithm::sinkProperties for the sink parameter.
3065 : : *
3066 : : * \see supportsAppend()
3067 : : * \since QGIS 3.14
3068 : : */
3069 : : void setSupportsAppend( bool supportsAppend );
3070 : :
3071 : : QVariantMap toVariantMap() const override;
3072 : : bool fromVariantMap( const QVariantMap &map ) override;
3073 : : QString generateTemporaryDestination() const override;
3074 : :
3075 : : /**
3076 : : * Creates a new parameter using the definition from a script code.
3077 : : */
3078 : : static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3079 : :
3080 : : private:
3081 : :
3082 : : QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
3083 : : bool mSupportsAppend = false;
3084 : : };
3085 : :
3086 : :
3087 : : /**
3088 : : * \class QgsProcessingParameterVectorDestination
3089 : : * \ingroup core
3090 : : * \brief A vector layer destination parameter, for specifying the destination path for a vector layer
3091 : : * created by the algorithm.
3092 : : *
3093 : : * \note Consider using the more flexible QgsProcessingParameterFeatureSink wherever
3094 : : * possible.
3095 : : * \since QGIS 3.0
3096 : : */
3097 : 0 : class CORE_EXPORT QgsProcessingParameterVectorDestination : public QgsProcessingDestinationParameter
3098 : : {
3099 : : public:
3100 : :
3101 : : /**
3102 : : * Constructor for QgsProcessingParameterVectorDestination.
3103 : : *
3104 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3105 : : * output will not be created by default.
3106 : : */
3107 : : QgsProcessingParameterVectorDestination( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
3108 : : bool optional = false, bool createByDefault = true );
3109 : :
3110 : : /**
3111 : : * Returns the type name for the parameter class.
3112 : : */
3113 : 0 : static QString typeName() { return QStringLiteral( "vectorDestination" ); }
3114 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3115 : 0 : QString type() const override { return typeName(); }
3116 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3117 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3118 : : QString asScriptCode() const override;
3119 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3120 : : QString defaultFileExtension() const override;
3121 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3122 : : QString createFileFilter() const override;
3123 : :
3124 : : /**
3125 : : * Returns a list of the vector format file extensions supported by this parameter.
3126 : : * \see defaultFileExtension()
3127 : : * \since QGIS 3.2
3128 : : */
3129 : : virtual QStringList supportedOutputVectorLayerExtensions() const;
3130 : :
3131 : : /**
3132 : : * Returns the layer type for this created vector layer.
3133 : : * \see setDataType()
3134 : : */
3135 : : QgsProcessing::SourceType dataType() const;
3136 : :
3137 : : /**
3138 : : * Returns TRUE if the created layer is likely to include geometries. In cases were presence of geometry
3139 : : * cannot be reliably determined in advance, this method will default to returning TRUE.
3140 : : */
3141 : : bool hasGeometry() const;
3142 : :
3143 : : /**
3144 : : * Sets the layer \a type for the created vector layer.
3145 : : * \see dataType()
3146 : : */
3147 : : void setDataType( QgsProcessing::SourceType type );
3148 : :
3149 : : QVariantMap toVariantMap() const override;
3150 : : bool fromVariantMap( const QVariantMap &map ) override;
3151 : :
3152 : : /**
3153 : : * Creates a new parameter using the definition from a script code.
3154 : : */
3155 : : static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3156 : :
3157 : :
3158 : : private:
3159 : :
3160 : : QgsProcessing::SourceType mDataType = QgsProcessing::TypeVectorAnyGeometry;
3161 : : };
3162 : :
3163 : : /**
3164 : : * \class QgsProcessingParameterRasterDestination
3165 : : * \ingroup core
3166 : : * \brief A raster layer destination parameter, for specifying the destination path for a raster layer
3167 : : * created by the algorithm.
3168 : : * \since QGIS 3.0
3169 : : */
3170 : 0 : class CORE_EXPORT QgsProcessingParameterRasterDestination : public QgsProcessingDestinationParameter
3171 : : {
3172 : : public:
3173 : :
3174 : : /**
3175 : : * Constructor for QgsProcessingParameterRasterDestination.
3176 : : *
3177 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3178 : : * output will not be created by default.
3179 : : */
3180 : : QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(),
3181 : : const QVariant &defaultValue = QVariant(),
3182 : : bool optional = false,
3183 : : bool createByDefault = true );
3184 : :
3185 : : /**
3186 : : * Returns the type name for the parameter class.
3187 : : */
3188 : 0 : static QString typeName() { return QStringLiteral( "rasterDestination" ); }
3189 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3190 : 0 : QString type() const override { return typeName(); }
3191 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3192 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3193 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3194 : : QString defaultFileExtension() const override;
3195 : : QString createFileFilter() const override;
3196 : :
3197 : : /**
3198 : : * Returns a list of the raster format file extensions supported for this parameter.
3199 : : * \see defaultFileExtension()
3200 : : * \since QGIS 3.2
3201 : : */
3202 : : virtual QStringList supportedOutputRasterLayerExtensions() const;
3203 : :
3204 : : /**
3205 : : * Creates a new parameter using the definition from a script code.
3206 : : */
3207 : : static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3208 : : };
3209 : :
3210 : : /**
3211 : : * \class QgsProcessingParameterFileDestination
3212 : : * \ingroup core
3213 : : * \brief A generic file based destination parameter, for specifying the destination path for a file (non-map layer)
3214 : : * created by the algorithm.
3215 : : *
3216 : : * In some circumstances it is desirable to avoid the usual file overwriting confirmation prompt when
3217 : : * users select an existing destination file for this parameter type (e.g., for algorithms which
3218 : : * append to an existing destination file instead of overwriting them.). This can be done by setting
3219 : : * the widget wrapper metadata "dontconfirmoverwrite" option:
3220 : : *
3221 : : * \code{.py}
3222 : : * param = QgsProcessingParameterFileDestination( 'OUTPUT', 'Destination file')
3223 : : * # don't show the file overwrite warning when users select a destination file:
3224 : : * param.setMetadata( {'widget_wrapper':
3225 : : * { 'dontconfirmoverwrite': True }
3226 : : * })
3227 : : * \endcode
3228 : : *
3229 : : * \since QGIS 3.0
3230 : : */
3231 : 0 : class CORE_EXPORT QgsProcessingParameterFileDestination : public QgsProcessingDestinationParameter
3232 : : {
3233 : : public:
3234 : :
3235 : : /**
3236 : : * Constructor for QgsProcessingParameterFileDestination.
3237 : : *
3238 : : * If \a createByDefault is FALSE and the parameter is \a optional, then this destination
3239 : : * output will not be created by default.
3240 : : */
3241 : : QgsProcessingParameterFileDestination( const QString &name, const QString &description = QString(),
3242 : : const QString &fileFilter = QString(),
3243 : : const QVariant &defaultValue = QVariant(),
3244 : : bool optional = false,
3245 : : bool createByDefault = true );
3246 : :
3247 : : /**
3248 : : * Returns the type name for the parameter class.
3249 : : */
3250 : 0 : static QString typeName() { return QStringLiteral( "fileDestination" ); }
3251 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3252 : 0 : QString type() const override { return typeName(); }
3253 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3254 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3255 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3256 : : QString defaultFileExtension() const override;
3257 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3258 : : QString createFileFilter() const override;
3259 : :
3260 : : /**
3261 : : * Returns the file filter string for file destinations compatible with this parameter.
3262 : : * \see setFileFilter()
3263 : : */
3264 : : QString fileFilter() const;
3265 : :
3266 : : /**
3267 : : * Sets the file \a filter string for file destinations compatible with this parameter.
3268 : : * \see fileFilter()
3269 : : */
3270 : : void setFileFilter( const QString &filter );
3271 : :
3272 : : QVariantMap toVariantMap() const override;
3273 : : bool fromVariantMap( const QVariantMap &map ) override;
3274 : :
3275 : : /**
3276 : : * Creates a new parameter using the definition from a script code.
3277 : : */
3278 : : static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3279 : :
3280 : :
3281 : : private:
3282 : :
3283 : : QString mFileFilter;
3284 : : };
3285 : :
3286 : : /**
3287 : : * \class QgsProcessingParameterFolderDestination
3288 : : * \ingroup core
3289 : : * \brief A folder destination parameter, for specifying the destination path for a folder created
3290 : : * by the algorithm or used for creating new files within the algorithm.
3291 : : * \since QGIS 3.0
3292 : : */
3293 : 0 : class CORE_EXPORT QgsProcessingParameterFolderDestination : public QgsProcessingDestinationParameter
3294 : : {
3295 : : public:
3296 : :
3297 : : /**
3298 : : * Constructor for QgsProcessingParameterFolderDestination.
3299 : : */
3300 : : QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(),
3301 : : const QVariant &defaultValue = QVariant(),
3302 : : bool optional = false,
3303 : : bool createByDefault = true );
3304 : :
3305 : : /**
3306 : : * Returns the type name for the parameter class.
3307 : : */
3308 : 0 : static QString typeName() { return QStringLiteral( "folderDestination" ); }
3309 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3310 : 0 : QString type() const override { return typeName(); }
3311 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3312 : : QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
3313 : : QString defaultFileExtension() const override;
3314 : :
3315 : : /**
3316 : : * Creates a new parameter using the definition from a script code.
3317 : : */
3318 : : static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3319 : :
3320 : : };
3321 : :
3322 : : /**
3323 : : * \class QgsProcessingParameterBand
3324 : : * \ingroup core
3325 : : * \brief A raster band parameter for Processing algorithms.
3326 : : * \since QGIS 3.0
3327 : : */
3328 : 0 : class CORE_EXPORT QgsProcessingParameterBand : public QgsProcessingParameterDefinition
3329 : : {
3330 : : public:
3331 : :
3332 : : /**
3333 : : * Constructor for QgsProcessingParameterBand.
3334 : : */
3335 : : QgsProcessingParameterBand( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3336 : : const QString &parentLayerParameterName = QString(),
3337 : : bool optional = false,
3338 : : bool allowMultiple = false );
3339 : :
3340 : : /**
3341 : : * Returns the type name for the parameter class.
3342 : : */
3343 : 0 : static QString typeName() { return QStringLiteral( "band" ); }
3344 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3345 : 0 : QString type() const override { return typeName(); }
3346 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3347 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3348 : : QString asScriptCode() const override;
3349 : : QStringList dependsOnOtherParameters() const override;
3350 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3351 : :
3352 : : /**
3353 : : * Returns the name of the parent layer parameter, or an empty string if this is not set.
3354 : : * \see setParentLayerParameterName()
3355 : : */
3356 : : QString parentLayerParameterName() const;
3357 : :
3358 : : /**
3359 : : * Sets the name of the parent layer parameter. Use an empty string if this is not required.
3360 : : * \see parentLayerParameterName()
3361 : : */
3362 : : void setParentLayerParameterName( const QString &parentLayerParameterName );
3363 : :
3364 : : QVariantMap toVariantMap() const override;
3365 : : bool fromVariantMap( const QVariantMap &map ) override;
3366 : :
3367 : : /**
3368 : : * Creates a new parameter using the definition from a script code.
3369 : : */
3370 : : static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3371 : :
3372 : : /**
3373 : : * Returns whether multiple band selections are permitted.
3374 : : * \see setAllowMultiple()
3375 : : * \since QGIS 3.4
3376 : : */
3377 : : bool allowMultiple() const;
3378 : :
3379 : : /**
3380 : : * Sets whether multiple band selections are permitted.
3381 : : * \see allowMultiple()
3382 : : * \since QGIS 3.4
3383 : : */
3384 : : void setAllowMultiple( bool allowMultiple );
3385 : :
3386 : : private:
3387 : :
3388 : : QString mParentLayerParameterName;
3389 : : bool mAllowMultiple = false;
3390 : : };
3391 : :
3392 : : /**
3393 : : * \class QgsProcessingParameterLayout
3394 : : * \ingroup core
3395 : : * \brief A print layout parameter, allowing users to select a print layout.
3396 : : *
3397 : : * QgsProcessingParameterLayout should be evaluated by calling QgsProcessingAlgorithm::parameterAsLayout().
3398 : : * This will return the matching layout from the context's current project. Alternatively, calling
3399 : : * QgsProcessingAlgorithm::parameterAsString() will return the name of the target print layout.
3400 : : *
3401 : : * \since QGIS 3.8
3402 : : */
3403 : 0 : class CORE_EXPORT QgsProcessingParameterLayout : public QgsProcessingParameterDefinition
3404 : : {
3405 : : public:
3406 : :
3407 : : /**
3408 : : * Constructor for QgsProcessingParameterLayout.
3409 : : */
3410 : : QgsProcessingParameterLayout( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3411 : : bool optional = false );
3412 : :
3413 : : /**
3414 : : * Returns the type name for the parameter class.
3415 : : */
3416 : 0 : static QString typeName() { return QStringLiteral( "layout" ); }
3417 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3418 : 0 : QString type() const override { return typeName(); }
3419 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3420 : : QString asScriptCode() const override;
3421 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3422 : :
3423 : : /**
3424 : : * Creates a new parameter using the definition from a script code.
3425 : : */
3426 : : static QgsProcessingParameterLayout *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3427 : :
3428 : : };
3429 : :
3430 : : /**
3431 : : * \class QgsProcessingParameterLayoutItem
3432 : : * \ingroup core
3433 : : * \brief A print layout item parameter, allowing users to select a particular item from a print layout.
3434 : : *
3435 : : * QgsProcessingParameterLayoutItem should be evaluated by calling QgsProcessingAlgorithm::parameterAsLayoutItem().
3436 : : * Internally, QgsProcessingParameterLayoutItems are string parameters, storing references to items either by
3437 : : * their UUID (QgsLayoutItem::uuid()) or ID (QgsLayoutItem::id()).
3438 : : *
3439 : : * \since QGIS 3.8
3440 : : */
3441 : 0 : class CORE_EXPORT QgsProcessingParameterLayoutItem : public QgsProcessingParameterDefinition
3442 : : {
3443 : : public:
3444 : :
3445 : : /**
3446 : : * Constructor for QgsProcessingParameterLayoutItem.
3447 : : */
3448 : : QgsProcessingParameterLayoutItem( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3449 : : const QString &parentLayoutParameterName = QString(),
3450 : : int itemType = -1,
3451 : : bool optional = false );
3452 : :
3453 : : /**
3454 : : * Returns the type name for the parameter class.
3455 : : */
3456 : 0 : static QString typeName() { return QStringLiteral( "layoutitem" ); }
3457 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3458 : 0 : QString type() const override { return typeName(); }
3459 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3460 : : QString asScriptCode() const override;
3461 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3462 : : QVariantMap toVariantMap() const override;
3463 : : bool fromVariantMap( const QVariantMap &map ) override;
3464 : : QStringList dependsOnOtherParameters() const override;
3465 : :
3466 : : /**
3467 : : * Creates a new parameter using the definition from a script code.
3468 : : */
3469 : : static QgsProcessingParameterLayoutItem *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3470 : :
3471 : : /**
3472 : : * Returns the name of the parent layout parameter, or an empty string if this is not set.
3473 : : * \see setParentLayoutParameterName()
3474 : : */
3475 : : QString parentLayoutParameterName() const;
3476 : :
3477 : : /**
3478 : : * Sets the \a name of the parent layout parameter. Use an empty string if this is not required.
3479 : : * \see parentLayoutParameterName()
3480 : : */
3481 : : void setParentLayoutParameterName( const QString &name );
3482 : :
3483 : : /**
3484 : : * Returns the acceptable item type, or -1 if any item type is allowed.
3485 : : *
3486 : : * These values correspond to the registered item types from QgsLayoutItemRegistry.
3487 : : *
3488 : : * \see setItemType()
3489 : : */
3490 : : int itemType() const;
3491 : :
3492 : : /**
3493 : : * Sets the acceptable item \a type, or -1 if any item type is allowed.
3494 : : *
3495 : : * These values correspond to the registered item types from QgsLayoutItemRegistry.
3496 : : *
3497 : : * \see itemType()
3498 : : */
3499 : : void setItemType( int type );
3500 : :
3501 : : private:
3502 : : QString mParentLayoutParameterName;
3503 : : int mItemType = -1;
3504 : : };
3505 : :
3506 : : /**
3507 : : * \class QgsProcessingParameterColor
3508 : : * \ingroup core
3509 : : * \brief A color parameter for processing algorithms.
3510 : : *
3511 : : * QgsProcessingParameterColor should be evaluated by calling QgsProcessingAlgorithm::parameterAsColor().
3512 : : *
3513 : : * \since QGIS 3.10
3514 : : */
3515 : 0 : class CORE_EXPORT QgsProcessingParameterColor : public QgsProcessingParameterDefinition
3516 : : {
3517 : : public:
3518 : :
3519 : : /**
3520 : : * Constructor for QgsProcessingParameterColor.
3521 : : *
3522 : : * If \a opacityEnabled is TRUE, then users will have the option of varying color opacity.
3523 : : */
3524 : : QgsProcessingParameterColor( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3525 : : bool opacityEnabled = true,
3526 : : bool optional = false );
3527 : :
3528 : : /**
3529 : : * Returns the type name for the parameter class.
3530 : : */
3531 : 0 : static QString typeName() { return QStringLiteral( "color" ); }
3532 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3533 : 0 : QString type() const override { return typeName(); }
3534 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3535 : : QString asScriptCode() const override;
3536 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3537 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3538 : : QVariantMap toVariantMap() const override;
3539 : : bool fromVariantMap( const QVariantMap &map ) override;
3540 : :
3541 : : /**
3542 : : * Returns TRUE if the parameter allows opacity control.
3543 : : *
3544 : : * The default behavior is to allow users to set opacity for the color.
3545 : : * \see setOpacityEnabled()
3546 : : */
3547 : : bool opacityEnabled() const;
3548 : :
3549 : : /**
3550 : : * Sets whether the parameter allows opacity control.
3551 : : *
3552 : : * The default behavior is to allow users to set opacity for the color.
3553 : : *
3554 : : * \see opacityEnabled()
3555 : : */
3556 : : void setOpacityEnabled( bool enabled );
3557 : :
3558 : : /**
3559 : : * Creates a new parameter using the definition from a script code.
3560 : : */
3561 : : static QgsProcessingParameterColor *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3562 : :
3563 : : private:
3564 : :
3565 : : bool mAllowOpacity = true;
3566 : :
3567 : : };
3568 : :
3569 : :
3570 : : /**
3571 : : * \class QgsProcessingParameterCoordinateOperation
3572 : : * \ingroup core
3573 : : * \brief A coordinate operation parameter for processing algorithms, for selection between available
3574 : : * coordinate operations to use when projecting between a source and destination coordinate reference system.
3575 : : *
3576 : : * QgsProcessingParameterCoordinateOperation should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
3577 : : * \since QGIS 3.12
3578 : : */
3579 : 0 : class CORE_EXPORT QgsProcessingParameterCoordinateOperation : public QgsProcessingParameterDefinition
3580 : : {
3581 : : public:
3582 : :
3583 : : /**
3584 : : * Constructor for QgsProcessingParameterCoordinateOperation.
3585 : : */
3586 : : QgsProcessingParameterCoordinateOperation( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3587 : : const QString &sourceCrsParameterName = QString(), const QString &destinationCrsParameterName = QString(),
3588 : : const QVariant &staticSourceCrs = QVariant(), const QVariant &staticDestinationCrs = QVariant(),
3589 : : bool optional = false );
3590 : :
3591 : : /**
3592 : : * Returns the type name for the parameter class.
3593 : : */
3594 : 0 : static QString typeName() { return QStringLiteral( "coordinateoperation" ); }
3595 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3596 : 0 : QString type() const override { return typeName(); }
3597 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3598 : : QString asScriptCode() const override;
3599 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3600 : : QStringList dependsOnOtherParameters() const override;
3601 : :
3602 : : QVariantMap toVariantMap() const override;
3603 : : bool fromVariantMap( const QVariantMap &map ) override;
3604 : :
3605 : : /**
3606 : : * Creates a new parameter using the definition from a script code.
3607 : : */
3608 : : static QgsProcessingParameterCoordinateOperation *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3609 : :
3610 : : /**
3611 : : * Returns the name of the source CRS parameter, or an empty string if this is not set.
3612 : : * \see setSourceCrsParameterName()
3613 : : * \see destinationCrsParameterName()
3614 : : */
3615 : : QString sourceCrsParameterName() const { return mSourceParameterName; }
3616 : :
3617 : : /**
3618 : : * Sets the \a name of the source CRS parameter. Use an empty string if this is not required.
3619 : : * \see sourceCrsParameterName()
3620 : : * \see setDestinationCrsParameterName()
3621 : : */
3622 : : void setSourceCrsParameterName( const QString &name ) { mSourceParameterName = name; }
3623 : :
3624 : : /**
3625 : : * Returns the name of the destination CRS parameter, or an empty string if this is not set.
3626 : : * \see setDestinationCrsParameterName()
3627 : : * \see sourceCrsParameterName()
3628 : : */
3629 : : QString destinationCrsParameterName() const { return mDestParameterName; }
3630 : :
3631 : : /**
3632 : : * Sets the \a name of the destination CRS parameter. Use an empty string if this is not required.
3633 : : * \see destinationCrsParameterName()
3634 : : * \see setSourceCrsParameterName()
3635 : : */
3636 : : void setDestinationCrsParameterName( const QString &name ) { mDestParameterName = name; }
3637 : :
3638 : : /**
3639 : : * Returns the static source CRS, or an invalid value if this is not set.
3640 : : * \see setSourceCrs()
3641 : : * \see destinationCrs()
3642 : : */
3643 : : QVariant sourceCrs() const { return mSourceCrs; }
3644 : :
3645 : : /**
3646 : : * Sets the static source \a crs.
3647 : : * \see sourceCrs()
3648 : : * \see setDestinationCrs()
3649 : : */
3650 : : void setSourceCrs( const QVariant &crs ) { mSourceCrs = crs; }
3651 : :
3652 : : /**
3653 : : * Returns the static destination CRS, or an invalid value if this is not set.
3654 : : * \see setDestinationCrs()
3655 : : * \see sourceCrs()
3656 : : */
3657 : : QVariant destinationCrs() const { return mDestCrs; }
3658 : :
3659 : : /**
3660 : : * Sets the static destination \a crs.
3661 : : * \see destinationCrs()
3662 : : * \see setSourceCrs()
3663 : : */
3664 : : void setDestinationCrs( const QVariant &crs ) { mDestCrs = crs; }
3665 : :
3666 : : private:
3667 : :
3668 : : QString mSourceParameterName;
3669 : : QString mDestParameterName;
3670 : : QVariant mSourceCrs;
3671 : : QVariant mDestCrs;
3672 : :
3673 : : };
3674 : :
3675 : :
3676 : : /**
3677 : : * \class QgsProcessingParameterMapTheme
3678 : : * \ingroup core
3679 : : * \brief A map theme parameter for processing algorithms, allowing users to select an existing map theme from a project.
3680 : : *
3681 : : * QgsProcessingParameterMapTheme should be evaluated by calling QgsProcessingAlgorithm::parameterAsString().
3682 : : *
3683 : : * \since QGIS 3.12
3684 : : */
3685 : 0 : class CORE_EXPORT QgsProcessingParameterMapTheme : public QgsProcessingParameterDefinition
3686 : : {
3687 : : public:
3688 : :
3689 : : /**
3690 : : * Constructor for QgsProcessingParameterMapTheme.
3691 : : */
3692 : : QgsProcessingParameterMapTheme( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
3693 : : bool optional = false );
3694 : :
3695 : : /**
3696 : : * Returns the type name for the parameter class.
3697 : : */
3698 : 0 : static QString typeName() { return QStringLiteral( "maptheme" ); }
3699 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3700 : 0 : QString type() const override { return typeName(); }
3701 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3702 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3703 : : QString asScriptCode() const override;
3704 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3705 : : QVariantMap toVariantMap() const override;
3706 : : bool fromVariantMap( const QVariantMap &map ) override;
3707 : :
3708 : : /**
3709 : : * Creates a new parameter using the definition from a script code.
3710 : : */
3711 : : static QgsProcessingParameterMapTheme *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3712 : :
3713 : : private:
3714 : :
3715 : : };
3716 : :
3717 : :
3718 : : /**
3719 : : * \class QgsProcessingParameterDateTime
3720 : : * \ingroup core
3721 : : * \brief A datetime (or pure date or time) parameter for processing algorithms.
3722 : : *
3723 : : * QgsProcessingParameterDateTime should be evaluated by calling QgsProcessingAlgorithm::parameterAsDateTime(),
3724 : : * which will return a date time value.
3725 : : *
3726 : : * \since QGIS 3.14
3727 : : */
3728 : 0 : class CORE_EXPORT QgsProcessingParameterDateTime : public QgsProcessingParameterDefinition
3729 : : {
3730 : : public:
3731 : :
3732 : : //! Datetime data type
3733 : : enum Type
3734 : : {
3735 : : DateTime, //!< Datetime values
3736 : : Date, //!< Date values
3737 : : Time, //!< Time values
3738 : : };
3739 : :
3740 : : /**
3741 : : * Constructor for QgsProcessingParameterDateTime.
3742 : : */
3743 : : explicit QgsProcessingParameterDateTime( const QString &name, const QString &description = QString(),
3744 : : Type type = DateTime,
3745 : : const QVariant &defaultValue = QVariant(),
3746 : : bool optional = false,
3747 : : const QDateTime &minValue = QDateTime(),
3748 : : const QDateTime &maxValue = QDateTime()
3749 : : );
3750 : :
3751 : : /**
3752 : : * Returns the type name for the parameter class.
3753 : : */
3754 : 0 : static QString typeName() { return QStringLiteral( "datetime" ); }
3755 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3756 : 0 : QString type() const override { return typeName(); }
3757 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3758 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3759 : : QString toolTip() const override;
3760 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3761 : :
3762 : : /**
3763 : : * Returns the minimum value acceptable by the parameter.
3764 : : *
3765 : : * An invalid QDateTime value indicates no minimum value.
3766 : : *
3767 : : * \see setMinimum()
3768 : : */
3769 : : QDateTime minimum() const;
3770 : :
3771 : : /**
3772 : : * Sets the \a minimum value acceptable by the parameter.
3773 : : *
3774 : : * An invalid QDateTime value indicates no minimum value.
3775 : : *
3776 : : * If the dataType() is QgsProcessingParameterDateTime::Time, then the date component of \a minimum
3777 : : * must be set to any valid date (but this date will not actually be considered when comparing parameter
3778 : : * values to the specified minimum value, only the time component will be considered).
3779 : : *
3780 : : * \see minimum()
3781 : : */
3782 : : void setMinimum( const QDateTime &minimum );
3783 : :
3784 : : /**
3785 : : * Returns the maximum value acceptable by the parameter.
3786 : : *
3787 : : * An invalid QDateTime value indicates no maximum value.
3788 : : *
3789 : : * \see setMaximum()
3790 : : */
3791 : : QDateTime maximum() const;
3792 : :
3793 : : /**
3794 : : * Sets the \a maximum value acceptable by the parameter.
3795 : : *
3796 : : * An invalid QDateTime value indicates no maximum value.
3797 : : *
3798 : : * If the dataType() is QgsProcessingParameterDateTime::Time, then the date component of \a maximum
3799 : : * must be set to any valid date (but this date will not actually be considered when comparing parameter
3800 : : * values to the specified maximum value, only the time component will be considered).
3801 : : *
3802 : : * \see maximum()
3803 : : */
3804 : : void setMaximum( const QDateTime &maximum );
3805 : :
3806 : : /**
3807 : : * Returns the acceptable data type for the parameter.
3808 : : * \see setDataType()
3809 : : */
3810 : : Type dataType() const;
3811 : :
3812 : : /**
3813 : : * Sets the acceptable data \a type for the parameter.
3814 : : * \see dataType()
3815 : : */
3816 : : void setDataType( Type type );
3817 : :
3818 : : QVariantMap toVariantMap() const override;
3819 : : bool fromVariantMap( const QVariantMap &map ) override;
3820 : :
3821 : : /**
3822 : : * Creates a new parameter using the definition from a script code.
3823 : : */
3824 : : static QgsProcessingParameterDateTime *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3825 : :
3826 : : private:
3827 : :
3828 : : QDateTime mMin;
3829 : : QDateTime mMax;
3830 : : Type mDataType = DateTime;
3831 : : };
3832 : :
3833 : :
3834 : : /**
3835 : : * \class QgsProcessingParameterProviderConnection
3836 : : * \ingroup core
3837 : : * \brief A data provider connection parameter for processing algorithms, allowing users to select from available registered
3838 : : * connections for a particular data provider.
3839 : : *
3840 : : * QgsProcessingParameterProviderConnection should be evaluated by calling QgsProcessingAlgorithm::parameterAsConnectionName().
3841 : : *
3842 : : * \since QGIS 3.14
3843 : : */
3844 : 0 : class CORE_EXPORT QgsProcessingParameterProviderConnection : public QgsProcessingParameterDefinition
3845 : : {
3846 : : public:
3847 : :
3848 : : /**
3849 : : * Constructor for QgsProcessingParameterProviderConnection, for the specified \a provider type.
3850 : : *
3851 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
3852 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
3853 : : */
3854 : : QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue = QVariant(),
3855 : : bool optional = false );
3856 : :
3857 : : /**
3858 : : * Returns the type name for the parameter class.
3859 : : */
3860 : 0 : static QString typeName() { return QStringLiteral( "providerconnection" ); }
3861 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3862 : 0 : QString type() const override { return typeName(); }
3863 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3864 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3865 : : QString asScriptCode() const override;
3866 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3867 : : QVariantMap toVariantMap() const override;
3868 : : bool fromVariantMap( const QVariantMap &map ) override;
3869 : :
3870 : : /**
3871 : : * Returns the ID of the provider associated with the connections.
3872 : : * \see setProviderId()
3873 : : */
3874 : : QString providerId() const { return mProviderId; }
3875 : :
3876 : : /**
3877 : : * Sets the ID of the \a provider associated with the connections.
3878 : : * \see providerId()
3879 : : */
3880 : : void setProviderId( const QString &provider ) { mProviderId = provider; }
3881 : :
3882 : : /**
3883 : : * Creates a new parameter using the definition from a script code.
3884 : : */
3885 : : static QgsProcessingParameterProviderConnection *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3886 : :
3887 : : private:
3888 : :
3889 : : QString mProviderId;
3890 : : };
3891 : :
3892 : :
3893 : : /**
3894 : : * \class QgsProcessingParameterDatabaseSchema
3895 : : * \ingroup core
3896 : : * \brief A database schema parameter for processing algorithms, allowing users to select from existing schemas
3897 : : * on a registered database connection.
3898 : : *
3899 : : * QgsProcessingParameterDatabaseSchema should be evaluated by calling QgsProcessingAlgorithm::parameterAsSchema().
3900 : : *
3901 : : * \since QGIS 3.14
3902 : : */
3903 : 0 : class CORE_EXPORT QgsProcessingParameterDatabaseSchema : public QgsProcessingParameterDefinition
3904 : : {
3905 : : public:
3906 : :
3907 : : /**
3908 : : * Constructor for QgsProcessingParameterDatabaseSchema.
3909 : : *
3910 : : * The \a connectionParameterName specifies the name of the parent QgsProcessingParameterProviderConnection parameter.
3911 : : *
3912 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
3913 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
3914 : : */
3915 : : QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &connectionParameterName = QString(), const QVariant &defaultValue = QVariant(),
3916 : : bool optional = false );
3917 : :
3918 : : /**
3919 : : * Returns the type name for the parameter class.
3920 : : */
3921 : 0 : static QString typeName() { return QStringLiteral( "databaseschema" ); }
3922 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3923 : 0 : QString type() const override { return typeName(); }
3924 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3925 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3926 : : QString asScriptCode() const override;
3927 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3928 : : QVariantMap toVariantMap() const override;
3929 : : bool fromVariantMap( const QVariantMap &map ) override;
3930 : : QStringList dependsOnOtherParameters() const override;
3931 : :
3932 : : /**
3933 : : * Returns the name of the parent connection parameter, or an empty string if this is not set.
3934 : : * \see setParentConnectionParameterName()
3935 : : */
3936 : : QString parentConnectionParameterName() const;
3937 : :
3938 : : /**
3939 : : * Sets the \a name of the parent connection parameter. Use an empty string if this is not required.
3940 : : * \see parentConnectionParameterName()
3941 : : */
3942 : : void setParentConnectionParameterName( const QString &name );
3943 : :
3944 : : /**
3945 : : * Creates a new parameter using the definition from a script code.
3946 : : */
3947 : : static QgsProcessingParameterDatabaseSchema *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
3948 : :
3949 : : private:
3950 : :
3951 : : QString mParentConnectionParameterName;
3952 : : };
3953 : :
3954 : :
3955 : : /**
3956 : : * \class QgsProcessingParameterDatabaseTable
3957 : : * \ingroup core
3958 : : * \brief A database table name parameter for processing algorithms, allowing users to select from existing database tables
3959 : : * on a registered database connection (or optionally to enter a new table name).
3960 : : *
3961 : : * QgsProcessingParameterDatabaseTable should be evaluated by calling QgsProcessingAlgorithm::parameterAsDatabaseTableName().
3962 : : *
3963 : : * \since QGIS 3.14
3964 : : */
3965 : 0 : class CORE_EXPORT QgsProcessingParameterDatabaseTable : public QgsProcessingParameterDefinition
3966 : : {
3967 : : public:
3968 : :
3969 : : /**
3970 : : * Constructor for QgsProcessingParameterDatabaseTable.
3971 : : *
3972 : : * The \a connectionParameterName specifies the name of the parent QgsProcessingParameterProviderConnection parameter.
3973 : : * The \a schemaParameterName specifies the name of the parent QgsProcessingParameterDatabaseSchema parameter.
3974 : : *
3975 : : * \warning The provider must support the connection API methods in its QgsProviderMetadata implementation
3976 : : * in order for the model to work correctly. This is only implemented for a subset of current data providers.
3977 : : */
3978 : : QgsProcessingParameterDatabaseTable( const QString &name, const QString &description,
3979 : : const QString &connectionParameterName = QString(),
3980 : : const QString &schemaParameterName = QString(),
3981 : : const QVariant &defaultValue = QVariant(),
3982 : : bool optional = false,
3983 : : bool allowNewTableNames = false );
3984 : :
3985 : : /**
3986 : : * Returns the type name for the parameter class.
3987 : : */
3988 : 0 : static QString typeName() { return QStringLiteral( "databasetable" ); }
3989 : : QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
3990 : 0 : QString type() const override { return typeName(); }
3991 : : bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
3992 : : QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
3993 : : QString asScriptCode() const override;
3994 : : QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const override;
3995 : : QVariantMap toVariantMap() const override;
3996 : : bool fromVariantMap( const QVariantMap &map ) override;
3997 : : QStringList dependsOnOtherParameters() const override;
3998 : :
3999 : : /**
4000 : : * Returns the name of the parent connection parameter, or an empty string if this is not set.
4001 : : * \see setParentConnectionParameterName()
4002 : : */
4003 : : QString parentConnectionParameterName() const;
4004 : :
4005 : : /**
4006 : : * Sets the \a name of the parent connection parameter. Use an empty string if this is not required.
4007 : : * \see parentConnectionParameterName()
4008 : : */
4009 : : void setParentConnectionParameterName( const QString &name );
4010 : :
4011 : : /**
4012 : : * Returns the name of the parent schema parameter, or an empty string if this is not set.
4013 : : * \see setParentSchemaParameterName()
4014 : : */
4015 : : QString parentSchemaParameterName() const;
4016 : :
4017 : : /**
4018 : : * Sets the \a name of the parent schema parameter. Use an empty string if this is not required.
4019 : : * \see parentSchemaParameterName()
4020 : : */
4021 : : void setParentSchemaParameterName( const QString &name );
4022 : :
4023 : : /**
4024 : : * Creates a new parameter using the definition from a script code.
4025 : : */
4026 : : static QgsProcessingParameterDatabaseTable *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
4027 : :
4028 : : /**
4029 : : * Returns TRUE if the parameter allows users to enter names for
4030 : : * a new (non-existing) tables.
4031 : : *
4032 : : * \see setAllowNewTableNames()
4033 : : */
4034 : : bool allowNewTableNames() const;
4035 : :
4036 : : /**
4037 : : * Sets whether the parameter allows users to enter names for
4038 : : * a new (non-existing) tables.
4039 : : *
4040 : : * \see allowNewTableNames()
4041 : : */
4042 : : void setAllowNewTableNames( bool allowed );
4043 : :
4044 : : private:
4045 : :
4046 : : QString mParentConnectionParameterName;
4047 : : QString mParentSchemaParameterName;
4048 : : bool mAllowNewTableNames = false;
4049 : : };
4050 : :
4051 : :
4052 : : // clazy:excludeall=qstring-allocations
4053 : :
4054 : : #endif // QGSPROCESSINGPARAMETERS_H
4055 : :
4056 : :
|
