QGIS API Documentation 3.43.0-Master (e737cc10456)
qgsprocessingparametertypeimpl.h
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingparametertypeimpl.h
3 ------------------------
4 begin : March 2018
5 copyright : (C) 2018 by Matthias Kuhn
6 email : matthias@opengis.ch
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 QGSPROCESSINGPARAMETERTYPEIMPL_H
19#define QGSPROCESSINGPARAMETERTYPEIMPL_H
20
21#include "qgis.h"
22#include "qgis_sip.h"
23#include "qgsprocessingparametertype.h"
24#include <QCoreApplication>
25
26#define SIP_NO_FILE
27
35class CORE_EXPORT QgsProcessingParameterTypeRasterLayer : public QgsProcessingParameterType
36{
37 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
38 {
39 return new QgsProcessingParameterRasterLayer( name );
40 }
41
42 QString description() const override
43 {
44 return QCoreApplication::translate( "Processing", "A raster layer parameter." );
45 }
46
47 QString name() const override
48 {
49 return QCoreApplication::translate( "Processing", "Raster Layer" );
50 }
51
52 QString pythonImportString() const override
53 {
54 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterLayer" );
55 }
56
57 QString className() const override
58 {
59 return QStringLiteral( "QgsProcessingParameterRasterLayer" );
60 }
61
62 QString id() const override
63 {
64 return QStringLiteral( "raster" );
65 }
66
67 QStringList acceptedPythonTypes() const override
68 {
69 return QStringList() << QObject::tr( "str: layer ID" )
70 << QObject::tr( "str: layer name" )
71 << QObject::tr( "str: layer source" )
72 << QStringLiteral( "QgsProperty" )
73 << QStringLiteral( "QgsRasterLayer" );
74 }
75
76 QStringList acceptedStringValues() const override
77 {
78 return QStringList() << QObject::tr( "Path to a raster layer" );
79 }
80
81 QStringList acceptedParameterTypes() const override
82 {
83 return QStringList()
84 << QgsProcessingParameterRasterLayer::typeName()
85 << QgsProcessingParameterMapLayer::typeName()
86 << QgsProcessingParameterString::typeName()
87 << QgsProcessingParameterExpression::typeName();
88 }
89
90 QStringList acceptedOutputTypes() const override
91 {
92 return QStringList()
93 << QgsProcessingOutputString::typeName()
94 << QgsProcessingOutputRasterLayer::typeName()
95 << QgsProcessingOutputMapLayer::typeName()
96 << QgsProcessingOutputFile::typeName()
97 << QgsProcessingOutputFolder::typeName();
98 }
99};
100
108class CORE_EXPORT QgsProcessingParameterTypeMeshLayer : public QgsProcessingParameterType
109{
110 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
111 {
112 return new QgsProcessingParameterMeshLayer( name );
113 }
114
115 QString description() const override
116 {
117 return QCoreApplication::translate( "Processing", "A mesh layer parameter." );
118 }
119
120 QString name() const override
121 {
122 return QCoreApplication::translate( "Processing", "Mesh Layer" );
123 }
124
125 QString pythonImportString() const override
126 {
127 return QStringLiteral( "from qgis.core import QgsProcessingParameterMeshLayer" );
128 }
129
130 QString className() const override
131 {
132 return QStringLiteral( "QgsProcessingParameterMeshLayer" );
133 }
134
135 QString id() const override
136 {
137 return QStringLiteral( "mesh" );
138 }
139
140 QStringList acceptedPythonTypes() const override
141 {
142 return QStringList() << QObject::tr( "str: layer ID" )
143 << QObject::tr( "str: layer name" )
144 << QObject::tr( "str: layer source" )
145 << QStringLiteral( "QgsMeshLayer" );
146 }
147
148 QStringList acceptedStringValues() const override
149 {
150 return QStringList() << QObject::tr( "Path to a mesh layer" );
151 }
152
153 QStringList acceptedParameterTypes() const override
154 {
155 return QStringList()
156 << QgsProcessingParameterMeshLayer::typeName()
157 << QgsProcessingParameterMapLayer::typeName()
158 << QgsProcessingParameterString::typeName()
159 << QgsProcessingParameterExpression::typeName();
160 }
161
162 QStringList acceptedOutputTypes() const override
163 {
164 return QStringList()
165 << QgsProcessingOutputString::typeName()
166 // TODO << QgsProcessingOutputMeshLayer::typeName()
167 << QgsProcessingOutputMapLayer::typeName()
168 << QgsProcessingOutputFile::typeName()
169 << QgsProcessingOutputFolder::typeName();
170 }
171};
172
180class CORE_EXPORT QgsProcessingParameterTypeVectorLayer : public QgsProcessingParameterType
181{
182 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
183 {
184 return new QgsProcessingParameterVectorLayer( name );
185 }
186
187 QString description() const override
188 {
189 return QCoreApplication::translate( "Processing", "A vector layer parameter, e.g. for algorithms which change layer styles, edit layers in place, or other operations which affect an entire layer." );
190 }
191
192 QString name() const override
193 {
194 return QCoreApplication::translate( "Processing", "Vector Layer" );
195 }
196
197 QString pythonImportString() const override
198 {
199 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorLayer" );
200 }
201
202 QString className() const override
203 {
204 return QStringLiteral( "QgsProcessingParameterVectorLayer" );
205 }
206
207 QString id() const override
208 {
209 return QStringLiteral( "vector" );
210 }
211
212 QStringList acceptedPythonTypes() const override
213 {
214 return QStringList() << QObject::tr( "str: layer ID" )
215 << QObject::tr( "str: layer name" )
216 << QObject::tr( "str: layer source" )
217 << QStringLiteral( "QgsProperty" )
218 << QStringLiteral( "QgsVectorLayer" );
219 }
220
221 QStringList acceptedStringValues() const override
222 {
223 return QStringList() << QObject::tr( "Path to a vector layer" );
224 }
225
226 QStringList acceptedParameterTypes() const override
227 {
228 return QStringList()
229 << QgsProcessingParameterVectorLayer::typeName()
230 << QgsProcessingParameterMapLayer::typeName()
231 << QgsProcessingParameterString::typeName()
232 << QgsProcessingParameterExpression::typeName();
233 }
234
235 QStringList acceptedOutputTypes() const override
236 {
237 return QStringList()
238 << QgsProcessingOutputString::typeName()
239 << QgsProcessingOutputVectorLayer::typeName()
240 << QgsProcessingOutputMapLayer::typeName()
241 << QgsProcessingOutputFile::typeName()
242 << QgsProcessingOutputFolder::typeName();
243 }
244
245 QList<int> acceptedDataTypes( const QgsProcessingParameterDefinition *parameter ) const override
246 {
247 if ( const QgsProcessingParameterVectorLayer *param = dynamic_cast<const QgsProcessingParameterVectorLayer *>( parameter ) )
248 return param->dataTypes();
249 else
250 return QList<int>();
251 }
252};
253
261class CORE_EXPORT QgsProcessingParameterTypeMapLayer : public QgsProcessingParameterType
262{
263 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
264 {
265 return new QgsProcessingParameterMapLayer( name );
266 }
267
268 QString description() const override
269 {
270 return QCoreApplication::translate( "Processing", "A generic map layer parameter, which accepts either vector or raster layers." );
271 }
272
273 QString name() const override
274 {
275 return QCoreApplication::translate( "Processing", "Map Layer" );
276 }
277
278 QString id() const override
279 {
280 return QStringLiteral( "layer" );
281 }
282
283 QString pythonImportString() const override
284 {
285 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapLayer" );
286 }
287
288 QString className() const override
289 {
290 return QStringLiteral( "QgsProcessingParameterMapLayer" );
291 }
292
293 QStringList acceptedPythonTypes() const override
294 {
295 return QStringList() << QObject::tr( "str: layer ID" )
296 << QObject::tr( "str: layer name" )
297 << QObject::tr( "str: layer source" )
298 << QStringLiteral( "QgsMapLayer" )
299 << QStringLiteral( "QgsProperty" )
300 << QStringLiteral( "QgsRasterLayer" )
301 << QStringLiteral( "QgsVectorLayer" );
302 }
303
304 QStringList acceptedStringValues() const override
305 {
306 return QStringList() << QObject::tr( "Path to a vector, raster or mesh layer" );
307 }
308
309 QStringList acceptedParameterTypes() const override
310 {
311 return QStringList()
312 << QgsProcessingParameterRasterLayer::typeName()
313 << QgsProcessingParameterMeshLayer::typeName()
314 << QgsProcessingParameterVectorLayer::typeName()
315 << QgsProcessingParameterMapLayer::typeName()
316 << QgsProcessingParameterPointCloudLayer::typeName()
317 << QgsProcessingParameterAnnotationLayer::typeName()
318 << QgsProcessingParameterString::typeName()
319 << QgsProcessingParameterExpression::typeName();
320 }
321
322 QStringList acceptedOutputTypes() const override
323 {
324 return QStringList()
325 << QgsProcessingOutputString::typeName()
326 << QgsProcessingOutputRasterLayer::typeName()
327 << QgsProcessingOutputVectorLayer::typeName()
328 << QgsProcessingOutputMapLayer::typeName()
329 << QgsProcessingOutputFile::typeName()
330 << QgsProcessingOutputVariant::typeName();
331 }
332};
333
341class CORE_EXPORT QgsProcessingParameterTypeBoolean : public QgsProcessingParameterType
342{
343 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
344 {
345 return new QgsProcessingParameterBoolean( name );
346 }
347
348 QString description() const override
349 {
350 return QCoreApplication::translate( "Processing", "A boolean parameter, for true/false values." );
351 }
352
353 QString name() const override
354 {
355 return QCoreApplication::translate( "Processing", "Boolean" );
356 }
357
358 QString id() const override
359 {
360 return QStringLiteral( "boolean" );
361 }
362
363 QString pythonImportString() const override
364 {
365 return QStringLiteral( "from qgis.core import QgsProcessingParameterBoolean" );
366 }
367
368 QString className() const override
369 {
370 return QStringLiteral( "QgsProcessingParameterBoolean" );
371 }
372
373 QStringList acceptedPythonTypes() const override
374 {
375 return QStringList() << QStringLiteral( "bool" )
376 << QStringLiteral( "int" )
377 << QStringLiteral( "str" )
378 << QStringLiteral( "QgsProperty" );
379 }
380
381 QStringList acceptedStringValues() const override
382 {
383 return QStringList() << QObject::tr( "1 for true/yes" )
384 << QObject::tr( "0 for false/no" )
385 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
386 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
387 }
388
389 QStringList acceptedParameterTypes() const override
390 {
391 //pretty much everything is compatible here and can be converted to a bool!
392 return QStringList() << QgsProcessingParameterBoolean::typeName()
393 << QgsProcessingParameterString::typeName()
394 << QgsProcessingParameterNumber::typeName()
395 << QgsProcessingParameterDistance::typeName()
396 << QgsProcessingParameterArea::typeName()
397 << QgsProcessingParameterVolume::typeName()
398 << QgsProcessingParameterDuration::typeName()
399 << QgsProcessingParameterScale::typeName()
400 << QgsProcessingParameterFile::typeName()
401 << QgsProcessingParameterField::typeName()
402 << QgsProcessingParameterFeatureSource::typeName()
403 << QgsProcessingParameterMapLayer::typeName()
404 << QgsProcessingParameterRasterLayer::typeName()
405 << QgsProcessingParameterVectorLayer::typeName()
406 << QgsProcessingParameterMeshLayer::typeName()
407 << QgsProcessingParameterExpression::typeName()
408 << QgsProcessingParameterProviderConnection::typeName()
409 << QgsProcessingParameterPointCloudLayer::typeName()
410 << QgsProcessingParameterAnnotationLayer::typeName();
411 }
412 QStringList acceptedOutputTypes() const override
413 {
414 return QStringList() << QgsProcessingOutputNumber::typeName()
415 << QgsProcessingOutputMapLayer::typeName()
416 << QgsProcessingOutputFile::typeName()
417 << QgsProcessingOutputRasterLayer::typeName()
418 << QgsProcessingOutputVectorLayer::typeName()
419 << QgsProcessingOutputString::typeName()
420 << QgsProcessingOutputVariant::typeName()
421 << QgsProcessingOutputBoolean::typeName();
422 }
423};
424
432class CORE_EXPORT QgsProcessingParameterTypeExpression : public QgsProcessingParameterType
433{
434 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
435 {
436 return new QgsProcessingParameterExpression( name );
437 }
438
439 QString description() const override
440 {
441 return QCoreApplication::translate( "Processing", "An expression parameter, to add custom expressions based on layer fields." );
442 }
443
444 QString name() const override
445 {
446 return QCoreApplication::translate( "Processing", "Expression" );
447 }
448
449 QString id() const override
450 {
451 return QStringLiteral( "expression" );
452 }
453
454 QString pythonImportString() const override
455 {
456 return QStringLiteral( "from qgis.core import QgsProcessingParameterExpression" );
457 }
458
459 QString className() const override
460 {
461 return QStringLiteral( "QgsProcessingParameterExpression" );
462 }
463
464 QStringList acceptedPythonTypes() const override
465 {
466 return QStringList() << QStringLiteral( "str" )
467 << QStringLiteral( "QgsProperty" );
468 }
469
470 QStringList acceptedStringValues() const override
471 {
472 return QStringList() << QObject::tr( "A valid QGIS expression string, e.g \"road_name\" = 'MAIN RD'" );
473 }
474
475 QStringList acceptedParameterTypes() const override
476 {
477 return QStringList()
478 << QgsProcessingParameterExpression::typeName()
479 << QgsProcessingParameterString::typeName()
480 << QgsProcessingParameterNumber::typeName()
481 << QgsProcessingParameterDistance::typeName()
482 << QgsProcessingParameterArea::typeName()
483 << QgsProcessingParameterVolume::typeName()
484 << QgsProcessingParameterScale::typeName()
485 << QgsProcessingParameterProviderConnection::typeName();
486 }
487
488 QStringList acceptedOutputTypes() const override
489 {
490 return QStringList()
491 << QgsProcessingOutputString::typeName()
492 << QgsProcessingOutputNumber::typeName()
493 << QgsProcessingOutputVariant::typeName();
494 }
495};
496
504class CORE_EXPORT QgsProcessingParameterTypeCrs : public QgsProcessingParameterType
505{
506 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
507 {
508 return new QgsProcessingParameterCrs( name );
509 }
510
511 QString description() const override
512 {
513 return QCoreApplication::translate( "Processing", "A coordinate reference system (CRS) input parameter." );
514 }
515
516 QString name() const override
517 {
518 return QCoreApplication::translate( "Processing", "CRS" );
519 }
520
521 QString id() const override
522 {
523 return QStringLiteral( "crs" );
524 }
525
526 QString pythonImportString() const override
527 {
528 return QStringLiteral( "from qgis.core import QgsProcessingParameterCrs" );
529 }
530
531 QString className() const override
532 {
533 return QStringLiteral( "QgsProcessingParameterCrs" );
534 }
535
536 QStringList acceptedPythonTypes() const override
537 {
538 return QStringList()
539 << QStringLiteral( "str: 'ProjectCrs'" )
540 << QObject::tr( "str: CRS auth ID (e.g. 'EPSG:3111')" )
541 << QObject::tr( "str: CRS PROJ4 (e.g. 'PROJ4:…')" )
542 << QObject::tr( "str: CRS WKT (e.g. 'WKT:…')" )
543 << QObject::tr( "str: layer ID. CRS of layer is used." )
544 << QObject::tr( "str: layer name. CRS of layer is used." )
545 << QObject::tr( "str: layer source. CRS of layer is used." )
546 << QObject::tr( "QgsCoordinateReferenceSystem" )
547 << QObject::tr( "QgsMapLayer: CRS of layer is used" )
548 << QObject::tr( "QgsProcessingFeatureSourceDefinition: CRS of source is used" )
549 << QStringLiteral( "QgsProperty" );
550 }
551
552 QStringList acceptedStringValues() const override
553 {
554 return QStringList() << QObject::tr( "CRS as an auth ID (e.g. 'EPSG:3111')" )
555 << QObject::tr( "CRS as a PROJ4 string (e.g. 'PROJ4:…')" )
556 << QObject::tr( "CRS as a WKT string (e.g. 'WKT:…')" )
557 << QObject::tr( "Path to a layer. The CRS of the layer is used." ) ;
558 }
559
560 QStringList acceptedParameterTypes() const override
561 {
562 return QStringList()
563 << QgsProcessingParameterCrs::typeName()
564 << QgsProcessingParameterExpression::typeName()
565 << QgsProcessingParameterString::typeName()
566 << QgsProcessingParameterRasterLayer::typeName()
567 << QgsProcessingParameterVectorLayer::typeName()
568 << QgsProcessingParameterMeshLayer::typeName()
569 << QgsProcessingParameterFeatureSource::typeName()
570 << QgsProcessingParameterPointCloudLayer::typeName()
571 << QgsProcessingParameterAnnotationLayer::typeName();
572 }
573
574 QStringList acceptedOutputTypes() const override
575 {
576 return QStringList() << QgsProcessingOutputVectorLayer::typeName()
577 << QgsProcessingOutputRasterLayer::typeName()
578 << QgsProcessingOutputMapLayer::typeName()
579 << QgsProcessingOutputString::typeName()
580 << QgsProcessingOutputVariant::typeName();
581 }
582};
583
591class CORE_EXPORT QgsProcessingParameterTypeRange : public QgsProcessingParameterType
592{
593 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
594 {
595 return new QgsProcessingParameterRange( name );
596 }
597
598 QString description() const override
599 {
600 return QCoreApplication::translate( "Processing", "A numeric range parameter for processing algorithms." );
601 }
602
603 QString name() const override
604 {
605 return QCoreApplication::translate( "Processing", "Range" );
606 }
607
608 QString id() const override
609 {
610 return QStringLiteral( "range" );
611 }
612
613 QString pythonImportString() const override
614 {
615 return QStringLiteral( "from qgis.core import QgsProcessingParameterRange" );
616 }
617
618 QString className() const override
619 {
620 return QStringLiteral( "QgsProcessingParameterRange" );
621 }
622
623 QStringList acceptedPythonTypes() const override
624 {
625 return QStringList() << QObject::tr( "list[float]: list of 2 float values" )
626 << QObject::tr( "list[str]: list of strings representing floats" )
627 << QObject::tr( "str: as two comma delimited floats, e.g. '1,10'" )
628 << QStringLiteral( "QgsProperty" );
629 }
630
631 QStringList acceptedStringValues() const override
632 {
633 return QStringList() << QObject::tr( "Two comma separated numeric values, e.g. '1,10'" );
634 }
635
636 QStringList acceptedParameterTypes() const override
637 {
638 return QStringList()
639 << QgsProcessingParameterRange::typeName()
640 << QgsProcessingParameterString::typeName();
641 }
642
643 QStringList acceptedOutputTypes() const override
644 {
645 return QStringList() << QgsProcessingOutputString::typeName()
646 << QgsProcessingOutputVariant::typeName();
647 }
648};
649
657class CORE_EXPORT QgsProcessingParameterTypePoint : public QgsProcessingParameterType
658{
659 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
660 {
661 return new QgsProcessingParameterPoint( name );
662 }
663
664 QString description() const override
665 {
666 return QCoreApplication::translate( "Processing", "A point geometry parameter." );
667 }
668
669 QString name() const override
670 {
671 return QCoreApplication::translate( "Processing", "Point" );
672 }
673
674 QString id() const override
675 {
676 return QStringLiteral( "point" );
677 }
678
679 QString pythonImportString() const override
680 {
681 return QStringLiteral( "from qgis.core import QgsProcessingParameterPoint" );
682 }
683
684 QString className() const override
685 {
686 return QStringLiteral( "QgsProcessingParameterPoint" );
687 }
688
689 QStringList acceptedPythonTypes() const override
690 {
691 return QStringList() << QObject::tr( "str: as an 'x,y' string, e.g. '1.5,10.1'" )
692 << QStringLiteral( "QgsPointXY" )
693 << QStringLiteral( "QgsProperty" )
694 << QStringLiteral( "QgsReferencedPointXY" )
695 << QStringLiteral( "QgsGeometry: centroid of geometry is used" );
696 }
697
698 QStringList acceptedStringValues() const override
699 {
700 return QStringList() << QObject::tr( "Point coordinate as an 'x,y' string, e.g. '1.5,10.1'" );
701 }
702
703 QStringList acceptedParameterTypes() const override
704 {
705 return QStringList()
706 << QgsProcessingParameterPoint::typeName()
707 << QgsProcessingParameterString::typeName();
708 }
709
710 QStringList acceptedOutputTypes() const override
711 {
712 return QStringList()
713 << QgsProcessingOutputString::typeName()
714 << QgsProcessingOutputVariant::typeName();
715 }
716};
717
725class CORE_EXPORT QgsProcessingParameterTypeGeometry : public QgsProcessingParameterType
726{
727 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
728 {
729 return new QgsProcessingParameterGeometry( name );
730 }
731
732 QString description() const override
733 {
734 return QCoreApplication::translate( "Processing", "A geometry parameter." );
735 }
736
737 QString name() const override
738 {
739 return QCoreApplication::translate( "Processing", "Geometry" );
740 }
741
742 QString id() const override
743 {
744 return QStringLiteral( "geometry" );
745 }
746
747 QString pythonImportString() const override
748 {
749 return QStringLiteral( "from qgis.core import QgsProcessingParameterGeometry" );
750 }
751
752 QString className() const override
753 {
754 return QStringLiteral( "QgsProcessingParameterGeometry" );
755 }
756
757 QStringList acceptedPythonTypes() const override
758 {
759 return QStringList() << QObject::tr( "str: as Well-Known Text string (WKT)" )
760 << QStringLiteral( "QgsGeometry" )
761 << QStringLiteral( "QgsProperty" );
762 }
763
764 QStringList acceptedStringValues() const override
765 {
766 return QStringList() << QObject::tr( "Well-Known Text string (WKT)" );
767 }
768
769 QStringList acceptedParameterTypes() const override
770 {
771 return QStringList()
772 << QgsProcessingParameterGeometry::typeName()
773 << QgsProcessingParameterString::typeName()
774 << QgsProcessingParameterPoint::typeName()
775 << QgsProcessingParameterExtent::typeName();
776 }
777
778 QStringList acceptedOutputTypes() const override
779 {
780 return QStringList()
781 << QgsProcessingOutputString::typeName()
782 << QgsProcessingOutputVariant::typeName();
783 }
784};
785
793class CORE_EXPORT QgsProcessingParameterTypeEnum : public QgsProcessingParameterType
794{
795 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
796 {
797 return new QgsProcessingParameterEnum( name );
798 }
799
800 QString description() const override
801 {
802 return QCoreApplication::translate( "Processing", "An enumerated type parameter." );
803 }
804
805 QString name() const override
806 {
807 return QCoreApplication::translate( "Processing", "Enum" );
808 }
809
810 QString id() const override
811 {
812 return QStringLiteral( "enum" );
813 }
814
815 QString pythonImportString() const override
816 {
817 return QStringLiteral( "from qgis.core import QgsProcessingParameterEnum" );
818 }
819
820 QString className() const override
821 {
822 return QStringLiteral( "QgsProcessingParameterEnum" );
823 }
824
825 QStringList acceptedPythonTypes() const override
826 {
827 return QStringList() << QStringLiteral( "int" )
828 << QObject::tr( "str: as string representation of int, e.g. '1'" )
829 << QStringLiteral( "QgsProperty" );
830 }
831
832 QStringList acceptedStringValues() const override
833 {
834 return QStringList() << QObject::tr( "Number of selected option, e.g. '1'" )
835 << QObject::tr( "Comma separated list of options, e.g. '1,3'" );
836 }
837
838 QStringList acceptedParameterTypes() const override
839 {
840 return QStringList()
841 << QgsProcessingParameterEnum::typeName()
842 << QgsProcessingParameterString::typeName()
843 << QgsProcessingParameterNumber::typeName();
844 }
845
846 QStringList acceptedOutputTypes() const override
847 {
848 return QStringList()
849 << QgsProcessingOutputString::typeName()
850 << QgsProcessingOutputVariant::typeName()
851 << QgsProcessingOutputNumber::typeName();
852 }
853};
854
862class CORE_EXPORT QgsProcessingParameterTypeExtent : public QgsProcessingParameterType
863{
864 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
865 {
866 return new QgsProcessingParameterExtent( name );
867 }
868
869 QString description() const override
870 {
871 return QCoreApplication::translate( "Processing", "A map extent parameter." );
872 }
873
874 QString name() const override
875 {
876 return QCoreApplication::translate( "Processing", "Extent" );
877 }
878
879 QString id() const override
880 {
881 return QStringLiteral( "extent" );
882 }
883
884 QString pythonImportString() const override
885 {
886 return QStringLiteral( "from qgis.core import QgsProcessingParameterExtent" );
887 }
888
889 QString className() const override
890 {
891 return QStringLiteral( "QgsProcessingParameterExtent" );
892 }
893
894 QStringList acceptedPythonTypes() const override
895 {
896 return QStringList() << QObject::tr( "str: as comma delimited list of x min, x max, y min, y max. E.g. '4,10,101,105'" )
897 << QObject::tr( "str: layer ID. Extent of layer is used." )
898 << QObject::tr( "str: layer name. Extent of layer is used." )
899 << QObject::tr( "str: layer source. Extent of layer is used." )
900 << QObject::tr( "QgsMapLayer: Extent of layer is used" )
901 << QObject::tr( "QgsProcessingFeatureSourceDefinition: Extent of source is used" )
902 << QStringLiteral( "QgsProperty" )
903 << QStringLiteral( "QgsRectangle" )
904 << QStringLiteral( "QgsReferencedRectangle" )
905 << QStringLiteral( "QgsGeometry: bounding box of geometry is used" );
906 }
907
908 QStringList acceptedStringValues() const override
909 {
910 return QStringList() << QObject::tr( "A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'" )
911 << QObject::tr( "Path to a layer. The extent of the layer is used." ) ;
912 }
913
914 QStringList acceptedParameterTypes() const override
915 {
916 return QStringList()
917 << QgsProcessingParameterExtent::typeName()
918 << QgsProcessingParameterString::typeName()
919 << QgsProcessingParameterMapLayer::typeName()
920 << QgsProcessingParameterFeatureSource::typeName()
921 << QgsProcessingParameterRasterLayer::typeName()
922 << QgsProcessingParameterVectorLayer::typeName()
923 << QgsProcessingParameterMeshLayer::typeName()
924 << QgsProcessingParameterPointCloudLayer::typeName()
925 << QgsProcessingParameterAnnotationLayer::typeName();
926 }
927
928 QStringList acceptedOutputTypes() const override
929 {
930 return QStringList()
931 << QgsProcessingOutputString::typeName()
932 << QgsProcessingOutputRasterLayer::typeName()
933 << QgsProcessingOutputVectorLayer::typeName()
934 << QgsProcessingOutputMapLayer::typeName()
935 << QgsProcessingOutputVariant::typeName();
936 }
937};
938
946class CORE_EXPORT QgsProcessingParameterTypeMatrix : public QgsProcessingParameterType
947{
948 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
949 {
950 return new QgsProcessingParameterMatrix( name );
951 }
952
953 QString description() const override
954 {
955 return QCoreApplication::translate( "Processing", "A table (matrix) parameter for processing algorithms." );
956 }
957
958 QString name() const override
959 {
960 return QCoreApplication::translate( "Processing", "Matrix" );
961 }
962
963 QString id() const override
964 {
965 return QStringLiteral( "matrix" );
966 }
967
968 QString pythonImportString() const override
969 {
970 return QStringLiteral( "from qgis.core import QgsProcessingParameterMatrix" );
971 }
972
973 QString className() const override
974 {
975 return QStringLiteral( "QgsProcessingParameterMatrix" );
976 }
977
978 QStringList acceptedPythonTypes() const override
979 {
980 return QStringList() << QObject::tr( "str: as comma delimited list of values" )
981 << QStringLiteral( "list" )
982 << QStringLiteral( "QgsProperty" );
983 }
984
985 QStringList acceptedStringValues() const override
986 {
987 return QStringList() << QObject::tr( "A comma delimited list of values" );
988 }
989
990 QStringList acceptedParameterTypes() const override
991 {
992 return QStringList()
993 << QgsProcessingParameterMatrix::typeName();
994 }
995
996 QStringList acceptedOutputTypes() const override
997 {
998 return QStringList();
999 }
1000};
1001
1009class CORE_EXPORT QgsProcessingParameterTypeFile : public QgsProcessingParameterType
1010{
1011 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1012 {
1013 return new QgsProcessingParameterFile( name );
1014 }
1015
1016 QString description() const override
1017 {
1018 return QCoreApplication::translate( "Processing", "A file or folder parameter, for use with non-map layer file sources or folders." );
1019 }
1020
1021 QString name() const override
1022 {
1023 return QCoreApplication::translate( "Processing", "File/Folder" );
1024 }
1025
1026 QString id() const override
1027 {
1028 return QStringLiteral( "file" );
1029 }
1030
1031 QString pythonImportString() const override
1032 {
1033 return QStringLiteral( "from qgis.core import QgsProcessingParameterFile" );
1034 }
1035
1036 QString className() const override
1037 {
1038 return QStringLiteral( "QgsProcessingParameterFile" );
1039 }
1040
1041 QStringList acceptedPythonTypes() const override
1042 {
1043 return QStringList() << QStringLiteral( "str" )
1044 << QStringLiteral( "QgsProperty" );
1045 }
1046
1047 QStringList acceptedStringValues() const override
1048 {
1049 return QStringList() << QObject::tr( "Path to a file" );
1050 }
1051
1052 QStringList acceptedParameterTypes() const override
1053 {
1054 return QStringList()
1055 << QgsProcessingParameterString::typeName()
1056 << QgsProcessingParameterFile::typeName();
1057 }
1058
1059 QStringList acceptedOutputTypes() const override
1060 {
1061 return QStringList() << QgsProcessingOutputFile::typeName()
1062 << QgsProcessingOutputFolder::typeName()
1063 << QgsProcessingOutputString::typeName()
1064 << QgsProcessingOutputVariant::typeName()
1065 << QgsProcessingOutputRasterLayer::typeName()
1066 << QgsProcessingOutputVectorLayer::typeName()
1067 << QgsProcessingOutputMapLayer::typeName();
1068 }
1069};
1070
1078class CORE_EXPORT QgsProcessingParameterTypeField : public QgsProcessingParameterType
1079{
1080 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1081 {
1082 return new QgsProcessingParameterField( name );
1083 }
1084
1085 QString description() const override
1086 {
1087 return QCoreApplication::translate( "Processing", "A vector field parameter, for selecting an existing field from a vector source." );
1088 }
1089
1090 QString name() const override
1091 {
1092 return QCoreApplication::translate( "Processing", "Vector Field" );
1093 }
1094
1095 QString id() const override
1096 {
1097 return QStringLiteral( "field" );
1098 }
1099
1100 QString pythonImportString() const override
1101 {
1102 return QStringLiteral( "from qgis.core import QgsProcessingParameterField" );
1103 }
1104
1105 QString className() const override
1106 {
1107 return QStringLiteral( "QgsProcessingParameterField" );
1108 }
1109
1110 QStringList acceptedPythonTypes() const override
1111 {
1112 return QStringList() << QStringLiteral( "str" )
1113 << QStringLiteral( "QgsProperty" );
1114 }
1115
1116 QStringList acceptedStringValues() const override
1117 {
1118 return QStringList() << QObject::tr( "The name of an existing field" )
1119 << QObject::tr( "; delimited list of existing field names" );
1120 }
1121
1122 QStringList acceptedParameterTypes() const override
1123 {
1124 return QStringList()
1125 << QgsProcessingParameterField::typeName()
1126 << QgsProcessingParameterString::typeName();
1127 }
1128
1129 QStringList acceptedOutputTypes() const override
1130 {
1131 return QStringList()
1132 << QgsProcessingOutputString::typeName()
1133 << QgsProcessingOutputVariant::typeName();
1134 }
1135};
1136
1137
1167
1176class CORE_EXPORT QgsProcessingParameterTypeVectorDestination : public QgsProcessingParameterTypeDestination
1177{
1178 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1179 {
1180 return new QgsProcessingParameterVectorDestination( name );
1181 }
1182
1183 QString description() const override
1184 {
1185 return QCoreApplication::translate( "Processing", "A vector layer destination parameter." );
1186 }
1187
1188 QString name() const override
1189 {
1190 return QCoreApplication::translate( "Processing", "Vector Destination" );
1191 }
1192
1193 QString id() const override
1194 {
1195 return QStringLiteral( "vectorDestination" );
1196 }
1197
1198 QString pythonImportString() const override
1199 {
1200 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorDestination" );
1201 }
1202
1203 QString className() const override
1204 {
1205 return QStringLiteral( "QgsProcessingParameterVectorDestination" );
1206 }
1207
1208 Qgis::ProcessingParameterTypeFlags flags() const override
1209 {
1210 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1211 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1212 return flags;
1213 }
1214
1215 QStringList acceptedPythonTypes() const override
1216 {
1217 return QStringList() << QStringLiteral( "str" )
1218 << QStringLiteral( "QgsProperty" )
1219 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1220 }
1221
1222 QStringList acceptedStringValues() const override
1223 {
1224 return QStringList() << QObject::tr( "Path for new vector layer" );
1225 }
1226};
1227
1236class CORE_EXPORT QgsProcessingParameterTypeFileDestination : public QgsProcessingParameterTypeDestination
1237{
1238 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1239 {
1240 return new QgsProcessingParameterFileDestination( name );
1241 }
1242
1243 QString description() const override
1244 {
1245 return QCoreApplication::translate( "Processing", "A generic file based destination parameter." );
1246 }
1247
1248 QString name() const override
1249 {
1250 return QCoreApplication::translate( "Processing", "File Destination" );
1251 }
1252
1253 QString id() const override
1254 {
1255 return QStringLiteral( "fileDestination" );
1256 }
1257
1258 QString pythonImportString() const override
1259 {
1260 return QStringLiteral( "from qgis.core import QgsProcessingParameterFileDestination" );
1261 }
1262
1263 QString className() const override
1264 {
1265 return QStringLiteral( "QgsProcessingParameterFileDestination" );
1266 }
1267
1268 Qgis::ProcessingParameterTypeFlags flags() const override
1269 {
1270 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1271 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1272 return flags;
1273 }
1274
1275 QStringList acceptedPythonTypes() const override
1276 {
1277 return QStringList() << QStringLiteral( "str" )
1278 << QStringLiteral( "QgsProperty" );
1279 }
1280
1281 QStringList acceptedStringValues() const override
1282 {
1283 return QStringList() << QObject::tr( "Path for new file" );
1284 }
1285
1286 QStringList acceptedParameterTypes() const override
1287 {
1288 return QStringList()
1289 << QgsProcessingParameterString::typeName()
1290 << QgsProcessingParameterFile::typeName();
1291 }
1292
1293 QStringList acceptedOutputTypes() const override
1294 {
1295 return QStringList() << QgsProcessingOutputFile::typeName()
1296 << QgsProcessingOutputString::typeName()
1297 << QgsProcessingOutputVariant::typeName()
1298 << QgsProcessingOutputRasterLayer::typeName()
1299 << QgsProcessingOutputVectorLayer::typeName()
1300 << QgsProcessingOutputMapLayer::typeName();
1301 }
1302};
1303
1313class CORE_EXPORT QgsProcessingParameterTypeFolderDestination : public QgsProcessingParameterTypeDestination
1314{
1315 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1316 {
1317 return new QgsProcessingParameterFolderDestination( name );
1318 }
1319
1320 QString description() const override
1321 {
1322 return QCoreApplication::translate( "Processing", "A folder destination parameter." );
1323 }
1324
1325 QString name() const override
1326 {
1327 return QCoreApplication::translate( "Processing", "Folder Destination" );
1328 }
1329
1330 QString id() const override
1331 {
1332 return QStringLiteral( "folderDestination" );
1333 }
1334
1335 QString pythonImportString() const override
1336 {
1337 return QStringLiteral( "from qgis.core import QgsProcessingParameterFolderDestination" );
1338 }
1339
1340 QString className() const override
1341 {
1342 return QStringLiteral( "QgsProcessingParameterFolderDestination" );
1343 }
1344
1345 Qgis::ProcessingParameterTypeFlags flags() const override
1346 {
1347 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1348 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1349 return flags;
1350 }
1351
1352 QStringList acceptedPythonTypes() const override
1353 {
1354 return QStringList() << QStringLiteral( "str" )
1355 << QStringLiteral( "QgsProperty" );
1356 }
1357
1358 QStringList acceptedStringValues() const override
1359 {
1360 return QStringList() << QObject::tr( "Path for an existing or new folder" );
1361 }
1362
1363 QStringList acceptedParameterTypes() const override
1364 {
1365 return QStringList()
1366 << QgsProcessingParameterString::typeName()
1367 << QgsProcessingParameterFile::typeName();
1368 }
1369
1370 QStringList acceptedOutputTypes() const override
1371 {
1372 return QStringList() << QgsProcessingOutputFile::typeName()
1373 << QgsProcessingOutputFolder::typeName()
1374 << QgsProcessingOutputString::typeName()
1375 << QgsProcessingOutputVariant::typeName();
1376 }
1377};
1378
1387class CORE_EXPORT QgsProcessingParameterTypeRasterDestination : public QgsProcessingParameterTypeDestination
1388{
1389 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1390 {
1391 return new QgsProcessingParameterRasterDestination( name );
1392 }
1393
1394 QString description() const override
1395 {
1396 return QCoreApplication::translate( "Processing", "A raster layer destination parameter." );
1397 }
1398
1399 QString name() const override
1400 {
1401 return QCoreApplication::translate( "Processing", "Raster Destination" );
1402 }
1403
1404 QString id() const override
1405 {
1406 return QStringLiteral( "rasterDestination" );
1407 }
1408
1409 QString pythonImportString() const override
1410 {
1411 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterDestination" );
1412 }
1413
1414 QString className() const override
1415 {
1416 return QStringLiteral( "QgsProcessingParameterRasterDestination" );
1417 }
1418
1419 Qgis::ProcessingParameterTypeFlags flags() const override
1420 {
1421 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1422 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1423 return flags;
1424 }
1425
1426 QStringList acceptedPythonTypes() const override
1427 {
1428 return QStringList() << QStringLiteral( "str" )
1429 << QStringLiteral( "QgsProperty" )
1430 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1431 }
1432
1433 QStringList acceptedStringValues() const override
1434 {
1435 return QStringList() << QObject::tr( "Path for new raster layer" );
1436 }
1437};
1438
1446class CORE_EXPORT QgsProcessingParameterTypeString : public QgsProcessingParameterType
1447{
1448 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1449 {
1450 return new QgsProcessingParameterString( name );
1451 }
1452
1453 QString description() const override
1454 {
1455 return QCoreApplication::translate( "Processing", "A freeform string parameter." );
1456 }
1457
1458 QString name() const override
1459 {
1460 return QCoreApplication::translate( "Processing", "String" );
1461 }
1462
1463 QString id() const override
1464 {
1465 return QStringLiteral( "string" );
1466 }
1467
1468 QString pythonImportString() const override
1469 {
1470 return QStringLiteral( "from qgis.core import QgsProcessingParameterString" );
1471 }
1472
1473 QString className() const override
1474 {
1475 return QStringLiteral( "QgsProcessingParameterString" );
1476 }
1477
1478 QStringList acceptedPythonTypes() const override
1479 {
1480 return QStringList() << QStringLiteral( "str" )
1481 << QStringLiteral( "QgsProperty" );
1482 }
1483
1484 QStringList acceptedStringValues() const override
1485 {
1486 return QStringList() << QObject::tr( "String value" )
1487 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1488 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1489 }
1490
1491 QStringList acceptedParameterTypes() const override
1492 {
1493 return QStringList()
1494 << QgsProcessingParameterString::typeName()
1495 << QgsProcessingParameterAuthConfig::typeName()
1496 << QgsProcessingParameterNumber::typeName()
1497 << QgsProcessingParameterDistance::typeName()
1498 << QgsProcessingParameterArea::typeName()
1499 << QgsProcessingParameterVolume::typeName()
1500 << QgsProcessingParameterDuration::typeName()
1501 << QgsProcessingParameterScale::typeName()
1502 << QgsProcessingParameterFile::typeName()
1503 << QgsProcessingParameterField::typeName()
1504 << QgsProcessingParameterExpression::typeName()
1505 << QgsProcessingParameterCoordinateOperation::typeName()
1506 << QgsProcessingParameterProviderConnection::typeName();
1507 }
1508
1509 QStringList acceptedOutputTypes() const override
1510 {
1511 return QStringList() << QgsProcessingOutputNumber::typeName()
1512 << QgsProcessingOutputVariant::typeName()
1513 << QgsProcessingOutputFile::typeName()
1514 << QgsProcessingOutputFolder::typeName()
1515 << QgsProcessingOutputString::typeName();
1516 }
1517};
1518
1526class CORE_EXPORT QgsProcessingParameterTypeAuthConfig : public QgsProcessingParameterType
1527{
1528 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1529 {
1530 return new QgsProcessingParameterAuthConfig( name );
1531 }
1532
1533 QString description() const override
1534 {
1535 return QCoreApplication::translate( "Processing", "An authentication configuration parameter." );
1536 }
1537
1538 QString name() const override
1539 {
1540 return QCoreApplication::translate( "Processing", "Authentication Configuration" );
1541 }
1542
1543 QString id() const override
1544 {
1545 return QStringLiteral( "authcfg" );
1546 }
1547
1548 QString pythonImportString() const override
1549 {
1550 return QStringLiteral( "from qgis.core import QgsProcessingParameterAuthConfig" );
1551 }
1552
1553 QString className() const override
1554 {
1555 return QStringLiteral( "QgsProcessingParameterAuthConfig" );
1556 }
1557
1558 QStringList acceptedPythonTypes() const override
1559 {
1560 return QStringList() << QStringLiteral( "str" );
1561 }
1562
1563 QStringList acceptedStringValues() const override
1564 {
1565 return QStringList() << QObject::tr( "An existing QGIS authentication ID string" );
1566 }
1567
1568 QStringList acceptedParameterTypes() const override
1569 {
1570 return QStringList()
1571 << QgsProcessingParameterAuthConfig::typeName()
1572 << QgsProcessingParameterString::typeName()
1573 << QgsProcessingParameterExpression::typeName();
1574 }
1575
1576 QStringList acceptedOutputTypes() const override
1577 {
1578 return QStringList() << QgsProcessingOutputString::typeName()
1579 << QgsProcessingOutputVariant::typeName();
1580 }
1581};
1582
1590class CORE_EXPORT QgsProcessingParameterTypeMultipleLayers : public QgsProcessingParameterType
1591{
1592 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1593 {
1594 return new QgsProcessingParameterMultipleLayers( name );
1595 }
1596
1597 QString description() const override
1598 {
1599 return QCoreApplication::translate( "Processing", "An input allowing selection of multiple sources, including multiple map layers or file sources." );
1600 }
1601
1602 QString name() const override
1603 {
1604 return QCoreApplication::translate( "Processing", "Multiple Input" );
1605 }
1606
1607 QString id() const override
1608 {
1609 return QStringLiteral( "multilayer" );
1610 }
1611
1612 QString pythonImportString() const override
1613 {
1614 return QStringLiteral( "from qgis.core import QgsProcessingParameterMultipleLayers" );
1615 }
1616
1617 QString className() const override
1618 {
1619 return QStringLiteral( "QgsProcessingParameterMultipleLayers" );
1620 }
1621
1622 QStringList acceptedPythonTypes() const override
1623 {
1624 return QStringList() << QObject::tr( "list[str]: list of layer IDs" )
1625 << QObject::tr( "list[str]: list of layer names" )
1626 << QObject::tr( "list[str]: list of layer sources" )
1627 << QStringLiteral( "list[QgsMapLayer]" )
1628 << QStringLiteral( "QgsProperty" );
1629 }
1630
1631 QStringList acceptedParameterTypes() const override
1632 {
1633 return QStringList()
1634 << QgsProcessingParameterMultipleLayers::typeName()
1635 << QgsProcessingParameterMapLayer::typeName()
1636 << QgsProcessingParameterVectorLayer::typeName()
1637 << QgsProcessingParameterMeshLayer::typeName()
1638 << QgsProcessingParameterFeatureSource::typeName()
1639 << QgsProcessingParameterRasterLayer::typeName()
1640 << QgsProcessingParameterFile::typeName()
1641 << QgsProcessingParameterString::typeName();
1642 }
1643 QStringList acceptedOutputTypes() const override
1644 {
1645 return QStringList()
1646 << QgsProcessingOutputMapLayer::typeName()
1647 << QgsProcessingOutputRasterLayer::typeName()
1648 << QgsProcessingOutputVectorLayer::typeName()
1649 << QgsProcessingOutputMultipleLayers::typeName()
1650 << QgsProcessingOutputFile::typeName()
1651 << QgsProcessingOutputString::typeName()
1652 << QgsProcessingOutputVariant::typeName();
1653 }
1654};
1655
1663class CORE_EXPORT QgsProcessingParameterTypeFeatureSource : public QgsProcessingParameterType
1664{
1665 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1666 {
1667 return new QgsProcessingParameterFeatureSource( name );
1668 }
1669
1670 QString description() const override
1671 {
1672 return QCoreApplication::translate( "Processing", "A vector feature parameter, e.g. for algorithms which operate on the features within a layer." );
1673 }
1674
1675 QString name() const override
1676 {
1677 return QCoreApplication::translate( "Processing", "Vector Features" );
1678 }
1679
1680 QString id() const override
1681 {
1682 return QStringLiteral( "source" );
1683 }
1684
1685 QString pythonImportString() const override
1686 {
1687 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSource" );
1688 }
1689
1690 QString className() const override
1691 {
1692 return QStringLiteral( "QgsProcessingParameterFeatureSource" );
1693 }
1694
1695 QStringList acceptedPythonTypes() const override
1696 {
1697 return QStringList() << QObject::tr( "str: layer ID" )
1698 << QObject::tr( "str: layer name" )
1699 << QObject::tr( "str: layer source" )
1700 << QStringLiteral( "QgsProcessingFeatureSourceDefinition" )
1701 << QStringLiteral( "QgsProperty" )
1702 << QStringLiteral( "QgsVectorLayer" );
1703 }
1704
1705 QStringList acceptedStringValues() const override
1706 {
1707 return QStringList() << QObject::tr( "Path to a vector layer" );
1708 }
1709
1710 QStringList acceptedParameterTypes() const override
1711 {
1712 return QStringList()
1713 << QgsProcessingParameterFeatureSource::typeName()
1714 << QgsProcessingParameterVectorLayer::typeName()
1715 << QgsProcessingParameterMapLayer::typeName()
1716 << QgsProcessingParameterString::typeName()
1717 << QgsProcessingParameterExpression::typeName();
1718 }
1719
1720 QStringList acceptedOutputTypes() const override
1721 {
1722 return QStringList()
1723 << QgsProcessingOutputString::typeName()
1724 << QgsProcessingOutputVectorLayer::typeName()
1725 << QgsProcessingOutputMapLayer::typeName()
1726 << QgsProcessingOutputFile::typeName()
1727 << QgsProcessingOutputFolder::typeName();
1728 }
1729
1730 QList<int> acceptedDataTypes( const QgsProcessingParameterDefinition *parameter ) const override
1731 {
1732 if ( const QgsProcessingParameterFeatureSource *param = dynamic_cast<const QgsProcessingParameterFeatureSource *>( parameter ) )
1733 return param->dataTypes();
1734 else
1735 return QList<int>();
1736 }
1737};
1738
1746class CORE_EXPORT QgsProcessingParameterTypeNumber : public QgsProcessingParameterType
1747{
1748 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1749 {
1750 return new QgsProcessingParameterNumber( name );
1751 }
1752
1753 QString description() const override
1754 {
1755 return QCoreApplication::translate( "Processing", "A numeric parameter, including float or integer values." );
1756 }
1757
1758 QString name() const override
1759 {
1760 return QCoreApplication::translate( "Processing", "Number" );
1761 }
1762
1763 QString id() const override
1764 {
1765 return QStringLiteral( "number" );
1766 }
1767
1768 QString pythonImportString() const override
1769 {
1770 return QStringLiteral( "from qgis.core import QgsProcessingParameterNumber" );
1771 }
1772
1773 QString className() const override
1774 {
1775 return QStringLiteral( "QgsProcessingParameterNumber" );
1776 }
1777
1778 QStringList acceptedPythonTypes() const override
1779 {
1780 return QStringList() << QStringLiteral( "int" )
1781 << QStringLiteral( "float" )
1782 << QStringLiteral( "QgsProperty" );
1783 }
1784
1785 QStringList acceptedStringValues() const override
1786 {
1787 return QStringList() << QObject::tr( "A numeric value" )
1788 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1789 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1790 }
1791
1792 QStringList acceptedParameterTypes() const override
1793 {
1794 return QStringList()
1795 << QgsProcessingParameterString::typeName()
1796 << QgsProcessingParameterNumber::typeName()
1797 << QgsProcessingParameterDistance::typeName()
1798 << QgsProcessingParameterVolume::typeName()
1799 << QgsProcessingParameterDuration::typeName()
1800 << QgsProcessingParameterScale::typeName();
1801 }
1802
1803 QStringList acceptedOutputTypes() const override
1804 {
1805 return QStringList() << QgsProcessingOutputNumber::typeName()
1806 << QgsProcessingOutputVariant::typeName()
1807 << QgsProcessingOutputString::typeName();
1808 }
1809};
1810
1818class CORE_EXPORT QgsProcessingParameterTypeDistance : public QgsProcessingParameterTypeNumber
1819{
1820 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1821 {
1822 return new QgsProcessingParameterDistance( name );
1823 }
1824
1825 QString description() const override
1826 {
1827 return QCoreApplication::translate( "Processing", "A numeric parameter representing a distance measure." );
1828 }
1829
1830 QString name() const override
1831 {
1832 return QCoreApplication::translate( "Processing", "Distance" );
1833 }
1834
1835 QString id() const override
1836 {
1837 return QStringLiteral( "distance" );
1838 }
1839
1840 QString pythonImportString() const override
1841 {
1842 return QStringLiteral( "from qgis.core import QgsProcessingParameterDistance" );
1843 }
1844
1845 QString className() const override
1846 {
1847 return QStringLiteral( "QgsProcessingParameterDistance" );
1848 }
1849
1850 QStringList acceptedPythonTypes() const override
1851 {
1852 return QStringList() << QStringLiteral( "int" )
1853 << QStringLiteral( "float" )
1854 << QStringLiteral( "QgsProperty" );
1855 }
1856
1857 QStringList acceptedStringValues() const override
1858 {
1859 return QStringList() << QObject::tr( "A numeric value" )
1860 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1861 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1862 }
1863};
1864
1865
1873class CORE_EXPORT QgsProcessingParameterTypeArea : public QgsProcessingParameterTypeNumber
1874{
1875 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1876 {
1877 return new QgsProcessingParameterArea( name );
1878 }
1879
1880 QString description() const override
1881 {
1882 return QCoreApplication::translate( "Processing", "A numeric parameter representing an area measure." );
1883 }
1884
1885 QString name() const override
1886 {
1887 return QCoreApplication::translate( "Processing", "Area" );
1888 }
1889
1890 QString id() const override
1891 {
1892 return QStringLiteral( "area" );
1893 }
1894
1895 QString pythonImportString() const override
1896 {
1897 return QStringLiteral( "from qgis.core import QgsProcessingParameterArea" );
1898 }
1899
1900 QString className() const override
1901 {
1902 return QStringLiteral( "QgsProcessingParameterArea" );
1903 }
1904
1905 QStringList acceptedPythonTypes() const override
1906 {
1907 return QStringList() << QStringLiteral( "int" )
1908 << QStringLiteral( "float" )
1909 << QStringLiteral( "QgsProperty" );
1910 }
1911
1912 QStringList acceptedStringValues() const override
1913 {
1914 return QStringList() << QObject::tr( "A numeric value" )
1915 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1916 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1917 }
1918};
1919
1920
1928class CORE_EXPORT QgsProcessingParameterTypeVolume : public QgsProcessingParameterTypeNumber
1929{
1930 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1931 {
1932 return new QgsProcessingParameterVolume( name );
1933 }
1934
1935 QString description() const override
1936 {
1937 return QCoreApplication::translate( "Processing", "A numeric parameter representing a volume measure." );
1938 }
1939
1940 QString name() const override
1941 {
1942 return QCoreApplication::translate( "Processing", "Volume" );
1943 }
1944
1945 QString id() const override
1946 {
1947 return QStringLiteral( "volume" );
1948 }
1949
1950 QString pythonImportString() const override
1951 {
1952 return QStringLiteral( "from qgis.core import QgsProcessingParameterVolume" );
1953 }
1954
1955 QString className() const override
1956 {
1957 return QStringLiteral( "QgsProcessingParameterVolume" );
1958 }
1959
1960 QStringList acceptedPythonTypes() const override
1961 {
1962 return QStringList() << QStringLiteral( "int" )
1963 << QStringLiteral( "float" )
1964 << QStringLiteral( "QgsProperty" );
1965 }
1966
1967 QStringList acceptedStringValues() const override
1968 {
1969 return QStringList() << QObject::tr( "A numeric value" )
1970 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1971 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1972 }
1973};
1974
1975
1976
1984class CORE_EXPORT QgsProcessingParameterTypeDuration : public QgsProcessingParameterTypeNumber
1985{
1986 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1987 {
1988 return new QgsProcessingParameterDuration( name );
1989 }
1990
1991 QString description() const override
1992 {
1993 return QCoreApplication::translate( "Processing", "A numeric parameter representing a duration measure." );
1994 }
1995
1996 QString name() const override
1997 {
1998 return QCoreApplication::translate( "Processing", "Duration" );
1999 }
2000
2001 QString id() const override
2002 {
2003 return QStringLiteral( "duration" );
2004 }
2005
2006 QString pythonImportString() const override
2007 {
2008 return QStringLiteral( "from qgis.core import QgsProcessingParameterDuration" );
2009 }
2010
2011 QString className() const override
2012 {
2013 return QStringLiteral( "QgsProcessingParameterDuration" );
2014 }
2015
2016 QStringList acceptedPythonTypes() const override
2017 {
2018 return QStringList() << QStringLiteral( "int" )
2019 << QStringLiteral( "float" )
2020 << QStringLiteral( "QgsProperty" );
2021 }
2022
2023 QStringList acceptedStringValues() const override
2024 {
2025 return QStringList() << QObject::tr( "A numeric value (unit type set by algorithms)" )
2026 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2027 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2028 }
2029};
2030
2038class CORE_EXPORT QgsProcessingParameterTypeScale : public QgsProcessingParameterTypeNumber
2039{
2040 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2041 {
2042 return new QgsProcessingParameterScale( name );
2043 }
2044
2045 QString description() const override
2046 {
2047 return QCoreApplication::translate( "Processing", "A numeric parameter representing a map scale." );
2048 }
2049
2050 QString name() const override
2051 {
2052 return QCoreApplication::translate( "Processing", "Scale" );
2053 }
2054
2055 QString id() const override
2056 {
2057 return QStringLiteral( "scale" );
2058 }
2059
2060 QString pythonImportString() const override
2061 {
2062 return QStringLiteral( "from qgis.core import QgsProcessingParameterScale" );
2063 }
2064
2065 QString className() const override
2066 {
2067 return QStringLiteral( "QgsProcessingParameterScale" );
2068 }
2069
2070 QStringList acceptedPythonTypes() const override
2071 {
2072 return QStringList() << QStringLiteral( "int: scale denominator" )
2073 << QStringLiteral( "float: scale denominator" )
2074 << QStringLiteral( "QgsProperty" );
2075 }
2076
2077 QStringList acceptedStringValues() const override
2078 {
2079 return QStringList() << QObject::tr( "A numeric value representing the scale denominator" );
2080 }
2081};
2082
2090class CORE_EXPORT QgsProcessingParameterTypeBand : public QgsProcessingParameterType
2091{
2092 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2093 {
2094 return new QgsProcessingParameterBand( name );
2095 }
2096
2097 QString description() const override
2098 {
2099 return QCoreApplication::translate( "Processing", "A raster band parameter, for selecting an existing band from a raster source." );
2100 }
2101
2102 QString name() const override
2103 {
2104 return QCoreApplication::translate( "Processing", "Raster Band" );
2105 }
2106
2107 QString id() const override
2108 {
2109 return QStringLiteral( "band" );
2110 }
2111
2112 QString pythonImportString() const override
2113 {
2114 return QStringLiteral( "from qgis.core import QgsProcessingParameterBand" );
2115 }
2116
2117 QString className() const override
2118 {
2119 return QStringLiteral( "QgsProcessingParameterBand" );
2120 }
2121
2122 QStringList acceptedPythonTypes() const override
2123 {
2124 return QStringList() << QStringLiteral( "int" )
2125 << QStringLiteral( "QgsProperty" );
2126 }
2127
2128 QStringList acceptedStringValues() const override
2129 {
2130 return QStringList() << QObject::tr( "Integer value representing an existing raster band number" );
2131 }
2132
2133 QStringList acceptedParameterTypes() const override
2134 {
2135 return QStringList()
2136 << QgsProcessingParameterBand::typeName()
2137 << QgsProcessingParameterNumber::typeName();
2138 }
2139
2140 QStringList acceptedOutputTypes() const override
2141 {
2142 return QStringList()
2143 << QgsProcessingOutputNumber::typeName()
2144 << QgsProcessingOutputVariant::typeName();
2145 }
2146};
2147
2155class CORE_EXPORT QgsProcessingParameterTypeFeatureSink : public QgsProcessingParameterTypeDestination
2156{
2157 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2158 {
2159 return new QgsProcessingParameterFeatureSink( name );
2160 }
2161
2162 Qgis::ProcessingParameterTypeFlags flags() const override
2163 {
2164 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
2165 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
2166 return flags;
2167 }
2168
2169 QString description() const override
2170 {
2171 return QCoreApplication::translate( "Processing", "A feature sink destination parameter." );
2172 }
2173
2174 QString name() const override
2175 {
2176 return QCoreApplication::translate( "Processing", "Feature Sink" );
2177 }
2178
2179 QString id() const override
2180 {
2181 return QStringLiteral( "sink" );
2182 }
2183
2184 QString pythonImportString() const override
2185 {
2186 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSink" );
2187 }
2188
2189 QString className() const override
2190 {
2191 return QStringLiteral( "QgsProcessingParameterFeatureSink" );
2192 }
2193
2194 QStringList acceptedPythonTypes() const override
2195 {
2196 return QStringList() << QObject::tr( "str: destination vector file, e.g. 'd:/test.shp'" )
2197 << QObject::tr( "str: 'memory:' to store result in temporary memory layer" )
2198 << QObject::tr( "str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table" )
2199 << QStringLiteral( "QgsProcessingOutputLayerDefinition" )
2200 << QStringLiteral( "QgsProperty" );
2201 }
2202
2203 QStringList acceptedStringValues() const override
2204 {
2205 return QStringList() << QObject::tr( "Path for new vector layer" );
2206 }
2207};
2208
2216class CORE_EXPORT QgsProcessingParameterTypeLayout : public QgsProcessingParameterType
2217{
2218 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2219 {
2220 return new QgsProcessingParameterLayout( name );
2221 }
2222
2223 QString description() const override
2224 {
2225 return QCoreApplication::translate( "Processing", "A print layout parameter." );
2226 }
2227
2228 QString name() const override
2229 {
2230 return QCoreApplication::translate( "Processing", "Print Layout" );
2231 }
2232
2233 QString id() const override
2234 {
2235 return QStringLiteral( "layout" );
2236 }
2237
2238 QString pythonImportString() const override
2239 {
2240 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayout" );
2241 }
2242
2243 QString className() const override
2244 {
2245 return QStringLiteral( "QgsProcessingParameterLayout" );
2246 }
2247
2248 QStringList acceptedPythonTypes() const override
2249 {
2250 return QStringList() << QObject::tr( "str: name of print layout in current project" )
2251 << QStringLiteral( "QgsProperty" );
2252 }
2253
2254 QStringList acceptedStringValues() const override
2255 {
2256 return QStringList() << QObject::tr( "Name of print layout in current project" );
2257 }
2258
2259 QStringList acceptedParameterTypes() const override
2260 {
2261 return QStringList()
2262 << QgsProcessingParameterLayout::typeName()
2263 << QgsProcessingParameterString::typeName();
2264 }
2265
2266 QStringList acceptedOutputTypes() const override
2267 {
2268 return QStringList()
2269 << QgsProcessingOutputString::typeName()
2270 << QgsProcessingOutputVariant::typeName();
2271 }
2272};
2273
2281class CORE_EXPORT QgsProcessingParameterTypeLayoutItem : public QgsProcessingParameterType
2282{
2283 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2284 {
2285 return new QgsProcessingParameterLayoutItem( name );
2286 }
2287
2288 QString description() const override
2289 {
2290 return QCoreApplication::translate( "Processing", "A print layout item parameter." );
2291 }
2292
2293 QString name() const override
2294 {
2295 return QCoreApplication::translate( "Processing", "Print Layout Item" );
2296 }
2297
2298 QString id() const override
2299 {
2300 return QStringLiteral( "layoutitem" );
2301 }
2302
2303 QString pythonImportString() const override
2304 {
2305 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayoutItem" );
2306 }
2307
2308 QString className() const override
2309 {
2310 return QStringLiteral( "QgsProcessingParameterLayoutItem" );
2311 }
2312
2313 QStringList acceptedPythonTypes() const override
2314 {
2315 return QStringList() << QObject::tr( "str: UUID of print layout item" )
2316 << QObject::tr( "str: id of print layout item" )
2317 << QStringLiteral( "QgsProperty" );
2318 }
2319
2320 QStringList acceptedStringValues() const override
2321 {
2322 return QStringList() << QObject::tr( "UUID or item id of layout item" );
2323 }
2324
2325 QStringList acceptedParameterTypes() const override
2326 {
2327 return QStringList()
2328 << QgsProcessingParameterLayoutItem::typeName()
2329 << QgsProcessingParameterString::typeName();
2330 }
2331
2332 QStringList acceptedOutputTypes() const override
2333 {
2334 return QStringList()
2335 << QgsProcessingOutputString::typeName()
2336 << QgsProcessingOutputVariant::typeName();
2337 }
2338};
2339
2347class CORE_EXPORT QgsProcessingParameterTypeColor : public QgsProcessingParameterType
2348{
2349 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2350 {
2351 return new QgsProcessingParameterColor( name );
2352 }
2353
2354 QString description() const override
2355 {
2356 return QCoreApplication::translate( "Processing", "A color parameter." );
2357 }
2358
2359 QString name() const override
2360 {
2361 return QCoreApplication::translate( "Processing", "Color" );
2362 }
2363
2364 QString id() const override
2365 {
2366 return QStringLiteral( "color" );
2367 }
2368
2369 QString pythonImportString() const override
2370 {
2371 return QStringLiteral( "from qgis.core import QgsProcessingParameterColor" );
2372 }
2373
2374 QString className() const override
2375 {
2376 return QStringLiteral( "QgsProcessingParameterColor" );
2377 }
2378
2379 QStringList acceptedPythonTypes() const override
2380 {
2381 return QStringList() << QObject::tr( "str: string representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
2382 << QStringLiteral( "QColor" )
2383 << QStringLiteral( "QgsProperty" );
2384 }
2385
2386 QStringList acceptedStringValues() const override
2387 {
2388 return QStringList() << QObject::tr( "String representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
2389 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2390 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2391 }
2392
2393 QStringList acceptedParameterTypes() const override
2394 {
2395 return QStringList()
2396 << QgsProcessingParameterColor::typeName()
2397 << QgsProcessingParameterString::typeName();
2398 }
2399
2400 QStringList acceptedOutputTypes() const override
2401 {
2402 return QStringList()
2403 << QgsProcessingOutputString::typeName()
2404 << QgsProcessingOutputVariant::typeName();
2405 }
2406};
2407
2415class CORE_EXPORT QgsProcessingParameterTypeCoordinateOperation : public QgsProcessingParameterType
2416{
2417 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2418 {
2419 return new QgsProcessingParameterCoordinateOperation( name );
2420 }
2421
2422 QString description() const override
2423 {
2424 return QCoreApplication::translate( "Processing", "A coordinate operation parameter." );
2425 }
2426
2427 QString name() const override
2428 {
2429 return QCoreApplication::translate( "Processing", "Coordinate Operation" );
2430 }
2431
2432 QString id() const override
2433 {
2434 return QStringLiteral( "coordinateoperation" );
2435 }
2436
2437 QString pythonImportString() const override
2438 {
2439 return QStringLiteral( "from qgis.core import QgsProcessingParameterCoordinateOperation" );
2440 }
2441
2442 QString className() const override
2443 {
2444 return QStringLiteral( "QgsProcessingParameterCoordinateOperation" );
2445 }
2446
2447 QStringList acceptedPythonTypes() const override
2448 {
2449 return QStringList() << QObject::tr( "str: string representation of a Proj coordinate operation" );
2450 }
2451
2452 QStringList acceptedStringValues() const override
2453 {
2454 return QStringList() << QObject::tr( "String representation of Proj coordinate operation" );
2455 }
2456
2457 QStringList acceptedParameterTypes() const override
2458 {
2459 return QStringList()
2460 << QgsProcessingParameterCoordinateOperation::typeName()
2461 << QgsProcessingParameterString::typeName();
2462 }
2463
2464 QStringList acceptedOutputTypes() const override
2465 {
2466 return QStringList()
2467 << QgsProcessingOutputString::typeName()
2468 << QgsProcessingOutputVariant::typeName();
2469 }
2470};
2471
2479class CORE_EXPORT QgsProcessingParameterTypeMapTheme: public QgsProcessingParameterType
2480{
2481 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2482 {
2483 return new QgsProcessingParameterMapTheme( name );
2484 }
2485
2486 QString description() const override
2487 {
2488 return QCoreApplication::translate( "Processing", "A map theme parameter." );
2489 }
2490
2491 QString name() const override
2492 {
2493 return QCoreApplication::translate( "Processing", "Map Theme" );
2494 }
2495
2496 QString id() const override
2497 {
2498 return QStringLiteral( "maptheme" );
2499 }
2500
2501 QString pythonImportString() const override
2502 {
2503 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapTheme" );
2504 }
2505
2506 QString className() const override
2507 {
2508 return QStringLiteral( "QgsProcessingParameterMapTheme" );
2509 }
2510
2511 QStringList acceptedPythonTypes() const override
2512 {
2513 return QStringList() << QObject::tr( "str: name of an existing map theme" )
2514 << QStringLiteral( "QgsProperty" );
2515 }
2516
2517 QStringList acceptedStringValues() const override
2518 {
2519 return QStringList() << QObject::tr( "Name of an existing map theme" );
2520 }
2521
2522 QStringList acceptedParameterTypes() const override
2523 {
2524 return QStringList()
2525 << QgsProcessingParameterString::typeName()
2526 << QgsProcessingParameterExpression::typeName();
2527 }
2528
2529 QStringList acceptedOutputTypes() const override
2530 {
2531 return QStringList()
2532 << QgsProcessingOutputString::typeName()
2533 << QgsProcessingOutputVariant::typeName();
2534 }
2535};
2536
2544class CORE_EXPORT QgsProcessingParameterTypeDateTime : public QgsProcessingParameterType
2545{
2546 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2547 {
2548 return new QgsProcessingParameterDateTime( name );
2549 }
2550
2551 QString description() const override
2552 {
2553 return QCoreApplication::translate( "Processing", "A datetime parameter, including datetime, date or time values." );
2554 }
2555
2556 QString name() const override
2557 {
2558 return QCoreApplication::translate( "Processing", "Datetime" );
2559 }
2560
2561 QString id() const override
2562 {
2563 return QStringLiteral( "datetime" );
2564 }
2565
2566 QString pythonImportString() const override
2567 {
2568 return QStringLiteral( "from qgis.core import QgsProcessingParameterDateTime" );
2569 }
2570
2571 QString className() const override
2572 {
2573 return QStringLiteral( "QgsProcessingParameterDateTime" );
2574 }
2575
2576 QStringList acceptedPythonTypes() const override
2577 {
2578 return QStringList() << QStringLiteral( "str" )
2579 << QStringLiteral( "QDateTime" )
2580 << QStringLiteral( "QDate" )
2581 << QStringLiteral( "QTime" )
2582 << QStringLiteral( "QgsProperty" );
2583 }
2584
2585 QStringList acceptedStringValues() const override
2586 {
2587 return QStringList() << QObject::tr( "A datetime value in ISO format" )
2588 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2589 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2590 }
2591
2592 QStringList acceptedParameterTypes() const override
2593 {
2594 return QStringList()
2595 << QgsProcessingParameterDateTime::typeName()
2596 << QgsProcessingParameterString::typeName();
2597 }
2598
2599 QStringList acceptedOutputTypes() const override
2600 {
2601 return QStringList()
2602 << QgsProcessingOutputString::typeName()
2603 << QgsProcessingOutputVariant::typeName();
2604 }
2605};
2606
2614class CORE_EXPORT QgsProcessingParameterTypeProviderConnection : public QgsProcessingParameterType
2615{
2616 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2617 {
2618 return new QgsProcessingParameterProviderConnection( name, QString(), QString() );
2619 }
2620
2621 QString description() const override
2622 {
2623 return QCoreApplication::translate( "Processing", "A connection name parameter, for registered database connections." );
2624 }
2625
2626 QString name() const override
2627 {
2628 return QCoreApplication::translate( "Processing", "Connection Name" );
2629 }
2630
2631 QString id() const override
2632 {
2633 return QStringLiteral( "providerconnection" );
2634 }
2635
2636 QString pythonImportString() const override
2637 {
2638 return QStringLiteral( "from qgis.core import QgsProcessingParameterProviderConnection" );
2639 }
2640
2641 QString className() const override
2642 {
2643 return QStringLiteral( "QgsProcessingParameterProviderConnection" );
2644 }
2645
2646 QStringList acceptedPythonTypes() const override
2647 {
2648 return QStringList() << QStringLiteral( "str" )
2649 << QStringLiteral( "QgsProperty" );
2650 }
2651
2652 QStringList acceptedStringValues() const override
2653 {
2654 return QStringList() << QObject::tr( "Name of registered database connection" );
2655 }
2656
2657 QStringList acceptedParameterTypes() const override
2658 {
2659 return QStringList()
2660 << QgsProcessingParameterProviderConnection::typeName()
2661 << QgsProcessingParameterString::typeName()
2662 << QgsProcessingParameterExpression::typeName();
2663 }
2664
2665 QStringList acceptedOutputTypes() const override
2666 {
2667 return QStringList()
2668 << QgsProcessingOutputString::typeName()
2669 << QgsProcessingOutputVariant::typeName();
2670 }
2671};
2672
2680class CORE_EXPORT QgsProcessingParameterTypeDatabaseSchema : public QgsProcessingParameterType
2681{
2682 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2683 {
2684 return new QgsProcessingParameterDatabaseSchema( name, QString(), QString() );
2685 }
2686
2687 QString description() const override
2688 {
2689 return QCoreApplication::translate( "Processing", "A database schema parameter." );
2690 }
2691
2692 QString name() const override
2693 {
2694 return QCoreApplication::translate( "Processing", "Database Schema" );
2695 }
2696
2697 QString id() const override
2698 {
2699 return QStringLiteral( "databaseschema" );
2700 }
2701
2702 QString pythonImportString() const override
2703 {
2704 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseSchema" );
2705 }
2706
2707 QString className() const override
2708 {
2709 return QStringLiteral( "QgsProcessingParameterDatabaseSchema" );
2710 }
2711
2712 QStringList acceptedPythonTypes() const override
2713 {
2714 return QStringList() << QStringLiteral( "str" )
2715 << QStringLiteral( "QgsProperty" );
2716 }
2717
2718 QStringList acceptedStringValues() const override
2719 {
2720 return QStringList() << QObject::tr( "Name of existing database schema" );
2721 }
2722
2723 QStringList acceptedParameterTypes() const override
2724 {
2725 return QStringList()
2726 << QgsProcessingParameterDatabaseSchema::typeName()
2727 << QgsProcessingParameterString::typeName()
2728 << QgsProcessingParameterExpression::typeName();
2729 }
2730
2731 QStringList acceptedOutputTypes() const override
2732 {
2733 return QStringList()
2734 << QgsProcessingOutputString::typeName()
2735 << QgsProcessingOutputVariant::typeName();
2736 }
2737};
2738
2746class CORE_EXPORT QgsProcessingParameterTypeDatabaseTable: public QgsProcessingParameterType
2747{
2748 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2749 {
2750 return new QgsProcessingParameterDatabaseTable( name, QString(), QString(), QString() );
2751 }
2752
2753 QString description() const override
2754 {
2755 return QCoreApplication::translate( "Processing", "A database table parameter." );
2756 }
2757
2758 QString name() const override
2759 {
2760 return QCoreApplication::translate( "Processing", "Database Table" );
2761 }
2762
2763 QString id() const override
2764 {
2765 return QStringLiteral( "databasetable" );
2766 }
2767
2768 QString pythonImportString() const override
2769 {
2770 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseTable" );
2771 }
2772
2773 QString className() const override
2774 {
2775 return QStringLiteral( "QgsProcessingParameterDatabaseTable" );
2776 }
2777
2778 QStringList acceptedPythonTypes() const override
2779 {
2780 return QStringList() << QStringLiteral( "str" )
2781 << QStringLiteral( "QgsProperty" );
2782 }
2783
2784 QStringList acceptedStringValues() const override
2785 {
2786 return QStringList() << QObject::tr( "Name of existing database table" );
2787 }
2788
2789 QStringList acceptedParameterTypes() const override
2790 {
2791 return QStringList()
2792 << QgsProcessingParameterDatabaseTable::typeName()
2793 << QgsProcessingParameterString::typeName()
2794 << QgsProcessingParameterExpression::typeName();
2795 }
2796
2797 QStringList acceptedOutputTypes() const override
2798 {
2799 return QStringList()
2800 << QgsProcessingOutputString::typeName()
2801 << QgsProcessingOutputVariant::typeName();
2802 }
2803};
2804
2812class CORE_EXPORT QgsProcessingParameterTypePointCloudLayer : public QgsProcessingParameterType
2813{
2814 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2815 {
2816 return new QgsProcessingParameterPointCloudLayer( name );
2817 }
2818
2819 QString description() const override
2820 {
2821 return QCoreApplication::translate( "Processing", "A point cloud layer parameter." );
2822 }
2823
2824 QString name() const override
2825 {
2826 return QCoreApplication::translate( "Processing", "Point Cloud Layer" );
2827 }
2828
2829 QString pythonImportString() const override
2830 {
2831 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudLayer" );
2832 }
2833
2834 QString className() const override
2835 {
2836 return QStringLiteral( "QgsProcessingParameterPointCloudLayer" );
2837 }
2838
2839 QString id() const override
2840 {
2841 return QStringLiteral( "pointcloud" );
2842 }
2843
2844 QStringList acceptedPythonTypes() const override
2845 {
2846 return QStringList() << QObject::tr( "str: layer ID" )
2847 << QObject::tr( "str: layer name" )
2848 << QObject::tr( "str: layer source" )
2849 << QStringLiteral( "QgsPointCloudLayer" );
2850 }
2851
2852 QStringList acceptedStringValues() const override
2853 {
2854 return QStringList() << QObject::tr( "Path to a point cloud layer" );
2855 }
2856
2857 QStringList acceptedParameterTypes() const override
2858 {
2859 return QStringList()
2860 << QgsProcessingParameterPointCloudLayer::typeName()
2861 << QgsProcessingParameterMapLayer::typeName()
2862 << QgsProcessingParameterString::typeName()
2863 << QgsProcessingParameterExpression::typeName();
2864 }
2865
2866 QStringList acceptedOutputTypes() const override
2867 {
2868 return QStringList()
2869 << QgsProcessingOutputString::typeName()
2870 << QgsProcessingOutputPointCloudLayer::typeName()
2871 << QgsProcessingOutputMapLayer::typeName()
2872 << QgsProcessingOutputFile::typeName()
2873 << QgsProcessingOutputFolder::typeName();
2874 }
2875};
2876
2884class CORE_EXPORT QgsProcessingParameterTypeAnnotationLayer : public QgsProcessingParameterType
2885{
2886 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2887 {
2888 return new QgsProcessingParameterAnnotationLayer( name );
2889 }
2890
2891 QString description() const override
2892 {
2893 return QCoreApplication::translate( "Processing", "An annotation layer parameter." );
2894 }
2895
2896 QString name() const override
2897 {
2898 return QCoreApplication::translate( "Processing", "Annotation Layer" );
2899 }
2900
2901 QString pythonImportString() const override
2902 {
2903 return QStringLiteral( "from qgis.core import QgsProcessingParameterAnnotationLayer" );
2904 }
2905
2906 QString className() const override
2907 {
2908 return QStringLiteral( "QgsProcessingParameterAnnotationLayer" );
2909 }
2910
2911 QString id() const override
2912 {
2913 return QStringLiteral( "annotation" );
2914 }
2915
2916 QStringList acceptedPythonTypes() const override
2917 {
2918 return QStringList() << QObject::tr( "str: layer ID" )
2919 << QObject::tr( "str: layer name" )
2920 << QObject::tr( "\"main\": main annotation layer for a project" )
2921 << QStringLiteral( "QgsAnnotationLayer" );
2922 }
2923
2924 QStringList acceptedStringValues() const override
2925 {
2926 return QStringList() << QObject::tr( "Layer ID for an annotation layer, or \"main\" for the main annotation layer in a project." );
2927 }
2928
2929 QStringList acceptedParameterTypes() const override
2930 {
2931 return QStringList()
2932 << QgsProcessingParameterAnnotationLayer::typeName()
2933 << QgsProcessingParameterMapLayer::typeName()
2934 << QgsProcessingParameterString::typeName()
2935 << QgsProcessingParameterExpression::typeName();
2936 }
2937
2938 QStringList acceptedOutputTypes() const override
2939 {
2940 return QStringList()
2941 << QgsProcessingOutputString::typeName()
2942 << QgsProcessingOutputMapLayer::typeName()
2943 << QgsProcessingOutputVariant::typeName();
2944 }
2945};
2946
2955class CORE_EXPORT QgsProcessingParameterTypePointCloudDestination : public QgsProcessingParameterTypeDestination
2956{
2957 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2958 {
2959 return new QgsProcessingParameterPointCloudDestination( name );
2960 }
2961
2962 QString description() const override
2963 {
2964 return QCoreApplication::translate( "Processing", "A point cloud layer destination parameter." );
2965 }
2966
2967 QString name() const override
2968 {
2969 return QCoreApplication::translate( "Processing", "Point Cloud Destination" );
2970 }
2971
2972 QString id() const override
2973 {
2974 return QStringLiteral( "pointCloudDestination" );
2975 }
2976
2977 QString pythonImportString() const override
2978 {
2979 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudDestination" );
2980 }
2981
2982 QString className() const override
2983 {
2984 return QStringLiteral( "QgsProcessingParameterPointCloudDestination" );
2985 }
2986
2987 Qgis::ProcessingParameterTypeFlags flags() const override
2988 {
2989 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
2990 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
2991 return flags;
2992 }
2993
2994 QStringList acceptedPythonTypes() const override
2995 {
2996 return QStringList() << QStringLiteral( "str" )
2997 << QStringLiteral( "QgsProperty" )
2998 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
2999 }
3000
3001 QStringList acceptedStringValues() const override
3002 {
3003 return QStringList() << QObject::tr( "Path for new point cloud layer" );
3004 }
3005};
3006
3014class CORE_EXPORT QgsProcessingParameterTypePointCloudAttribute : public QgsProcessingParameterType
3015{
3016 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
3017 {
3018 return new QgsProcessingParameterPointCloudAttribute( name );
3019 }
3020
3021 QString description() const override
3022 {
3023 return QCoreApplication::translate( "Processing", "A point cloud attribute parameter, for selecting an attribute from a point cloud source." );
3024 }
3025
3026 QString name() const override
3027 {
3028 return QCoreApplication::translate( "Processing", "Point Cloud Attribute" );
3029 }
3030
3031 QString id() const override
3032 {
3033 return QStringLiteral( "attribute" );
3034 }
3035
3036 QString pythonImportString() const override
3037 {
3038 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudAttribute" );
3039 }
3040
3041 QString className() const override
3042 {
3043 return QStringLiteral( "QgsProcessingParameterPointCloudAttribute" );
3044 }
3045
3046 QStringList acceptedPythonTypes() const override
3047 {
3048 return QStringList() << QStringLiteral( "str" )
3049 << QStringLiteral( "QgsProperty" );
3050 }
3051
3052 QStringList acceptedStringValues() const override
3053 {
3054 return QStringList() << QObject::tr( "The name of an attribute" )
3055 << QObject::tr( "; delimited list of attribute names" );
3056 }
3057
3058 QStringList acceptedParameterTypes() const override
3059 {
3060 return QStringList()
3061 << QgsProcessingParameterPointCloudAttribute::typeName()
3062 << QgsProcessingParameterString::typeName();
3063 }
3064
3065 QStringList acceptedOutputTypes() const override
3066 {
3067 return QStringList()
3068 << QgsProcessingOutputString::typeName()
3069 << QgsProcessingOutputVariant::typeName();
3070 }
3071};
3072
3081class CORE_EXPORT QgsProcessingParameterTypeVectorTileDestination : public QgsProcessingParameterTypeDestination
3082{
3083 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
3084 {
3085 return new QgsProcessingParameterVectorTileDestination( name );
3086 }
3087
3088 QString description() const override
3089 {
3090 return QCoreApplication::translate( "Processing", "A vector tiles layer destination parameter." );
3091 }
3092
3093 QString name() const override
3094 {
3095 return QCoreApplication::translate( "Processing", "Vector Tile Destination" );
3096 }
3097
3098 QString id() const override
3099 {
3100 return QStringLiteral( "vectorTileDestination" );
3101 }
3102
3103 QString pythonImportString() const override
3104 {
3105 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorTileDestination" );
3106 }
3107
3108 QString className() const override
3109 {
3110 return QStringLiteral( "QgsProcessingParameterVectorTileDestination" );
3111 }
3112
3113 Qgis::ProcessingParameterTypeFlags flags() const override
3114 {
3115 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
3116 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
3117 return flags;
3118 }
3119
3120 QStringList acceptedPythonTypes() const override
3121 {
3122 return QStringList() << QStringLiteral( "str" )
3123 << QStringLiteral( "QgsProperty" )
3124 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
3125 }
3126
3127 QStringList acceptedStringValues() const override
3128 {
3129 return QStringList() << QObject::tr( "Path for new vector tile layer" );
3130 }
3131};
3132
3133#endif // QGSPROCESSINGPARAMETERTYPEIMPL_H
Qgis::ProcessingParameterTypeFlag::ExposeToModeler
@ ExposeToModeler
Is this parameter available in the modeler. Is set to on by default.
Qgis::ProcessingParameterTypeFlags
QFlags< ProcessingParameterTypeFlag > ProcessingParameterTypeFlags
Flags which dictate the behavior of Processing parameter types.
Definition qgis.h:3617
QgsProcessingOutputBoolean::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:426
QgsProcessingOutputFile::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:472
QgsProcessingOutputFolder::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:449
QgsProcessingOutputMapLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:201
QgsProcessingOutputMultipleLayers::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:311
QgsProcessingOutputNumber::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:381
QgsProcessingOutputPointCloudLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:283
QgsProcessingOutputRasterLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:261
QgsProcessingOutputString::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:404
QgsProcessingOutputVariant::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:358
QgsProcessingOutputVectorLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:224
QgsProcessingParameterAnnotationLayer
An annotation layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:4542
QgsProcessingParameterAnnotationLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4554
QgsProcessingParameterArea
A double numeric parameter for area values.
Definition qgsprocessingparameters.h:2430
QgsProcessingParameterArea::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2446
QgsProcessingParameterAuthConfig
A string parameter for authentication configuration ID values.
Definition qgsprocessingparameters.h:2936
QgsProcessingParameterAuthConfig::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2948
QgsProcessingParameterBand
A raster band parameter for Processing algorithms.
Definition qgsprocessingparameters.h:3780
QgsProcessingParameterBand::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3794
QgsProcessingParameterBoolean
A boolean parameter for processing algorithms.
Definition qgsprocessingparameters.h:1776
QgsProcessingParameterBoolean::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1788
QgsProcessingParameterColor
A color parameter for processing algorithms.
Definition qgsprocessingparameters.h:3967
QgsProcessingParameterColor::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3982
QgsProcessingParameterCoordinateOperation
A coordinate operation parameter for processing algorithms.
Definition qgsprocessingparameters.h:4033
QgsProcessingParameterCoordinateOperation::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4047
QgsProcessingParameterCrs
A coordinate reference system parameter for processing algorithms.
Definition qgsprocessingparameters.h:1806
QgsProcessingParameterCrs::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1818
QgsProcessingParameterDatabaseSchema
A database schema parameter for processing algorithms, allowing users to select from existing schemas...
Definition qgsprocessingparameters.h:4350
QgsProcessingParameterDatabaseSchema::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4367
QgsProcessingParameterDatabaseTable
A database table name parameter for processing algorithms.
Definition qgsprocessingparameters.h:4414
QgsProcessingParameterDatabaseTable::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4436
QgsProcessingParameterDateTime
A datetime (or pure date or time) parameter for processing algorithms.
Definition qgsprocessingparameters.h:4183
QgsProcessingParameterDateTime::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4200
QgsProcessingParameterDefinition
Base class for the definition of processing parameters.
Definition qgsprocessingparameters.h:334
QgsProcessingParameterDistance
A double numeric parameter for distance values.
Definition qgsprocessingparameters.h:2345
QgsProcessingParameterDistance::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2361
QgsProcessingParameterDuration
A double numeric parameter for duration values.
Definition qgsprocessingparameters.h:2583
QgsProcessingParameterDuration::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2598
QgsProcessingParameterEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values.
Definition qgsprocessingparameters.h:2770
QgsProcessingParameterEnum::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2785
QgsProcessingParameterExpression
An expression parameter for processing algorithms.
Definition qgsprocessingparameters.h:2967
QgsProcessingParameterExpression::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2980
QgsProcessingParameterExtent
A rectangular map extent parameter for processing algorithms.
Definition qgsprocessingparameters.h:1839
QgsProcessingParameterExtent::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1851
QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition qgsprocessingparameters.h:3456
QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3294
QgsProcessingParameterFeatureSource::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3307
QgsProcessingParameterField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparameters.h:3187
QgsProcessingParameterField::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3203
QgsProcessingParameterFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition qgsprocessingparameters.h:3685
QgsProcessingParameterFile
An input file or folder parameter for processing algorithms.
Definition qgsprocessingparameters.h:1983
QgsProcessingParameterFile::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1999
QgsProcessingParameterFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition qgsprocessingparameters.h:3746
QgsProcessingParameterGeometry
A geometry parameter for processing algorithms.
Definition qgsprocessingparameters.h:1914
QgsProcessingParameterGeometry::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1929
QgsProcessingParameterLayoutItem
A print layout item parameter, allowing users to select a particular item from a print layout.
Definition qgsprocessingparameters.h:3893
QgsProcessingParameterLayoutItem::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3907
QgsProcessingParameterLayout
A print layout parameter, allowing users to select a print layout.
Definition qgsprocessingparameters.h:3855
QgsProcessingParameterLayout::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3867
QgsProcessingParameterMapLayer
A map layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:3147
QgsProcessingParameterMapLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3160
QgsProcessingParameterMapTheme
A map theme parameter for processing algorithms, allowing users to select an existing map theme from ...
Definition qgsprocessingparameters.h:4140
QgsProcessingParameterMatrix
A table (matrix) parameter for processing algorithms.
Definition qgsprocessingparameters.h:2079
QgsProcessingParameterMatrix::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2093
QgsProcessingParameterMeshLayer
A mesh layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:3112
QgsProcessingParameterMeshLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3126
QgsProcessingParameterMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition qgsprocessingparameters.h:2164
QgsProcessingParameterMultipleLayers::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2177
QgsProcessingParameterNumber
A numeric parameter for processing algorithms.
Definition qgsprocessingparameters.h:2247
QgsProcessingParameterNumber::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2264
QgsProcessingParameterPointCloudAttribute
A point cloud layer attribute parameter for Processing algorithms.
Definition qgsprocessingparameters.h:4621
QgsProcessingParameterPointCloudAttribute::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4636
QgsProcessingParameterPointCloudDestination
A point cloud layer destination parameter, for specifying the destination path for a point cloud laye...
Definition qgsprocessingparameters.h:4576
QgsProcessingParameterPointCloudLayer
A point cloud layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:4507
QgsProcessingParameterPointCloudLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4519
QgsProcessingParameterPoint
A point parameter for processing algorithms.
Definition qgsprocessingparameters.h:1882
QgsProcessingParameterPoint::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1894
QgsProcessingParameterProviderConnection
A data provider connection parameter for processing algorithms, allowing users to select from availab...
Definition qgsprocessingparameters.h:4291
QgsProcessingParameterProviderConnection::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4306
QgsProcessingParameterRange
A numeric range parameter for processing algorithms.
Definition qgsprocessingparameters.h:2672
QgsProcessingParameterRange::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2686
QgsProcessingParameterRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition qgsprocessingparameters.h:3625
QgsProcessingParameterRasterLayer
A raster layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:2724
QgsProcessingParameterRasterLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2736
QgsProcessingParameterScale
A double numeric parameter for map scale values.
Definition qgsprocessingparameters.h:2639
QgsProcessingParameterScale::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2652
QgsProcessingParameterString
A string parameter for processing algorithms.
Definition qgsprocessingparameters.h:2876
QgsProcessingParameterString::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2889
QgsProcessingParameterTypeAnnotationLayer
An annotation layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2885
QgsProcessingParameterTypeArea
An area parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1874
QgsProcessingParameterTypeAuthConfig
An authentication configuration parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1527
QgsProcessingParameterTypeBand
A raster band parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2091
QgsProcessingParameterTypeBoolean
A boolean parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:342
QgsProcessingParameterTypeColor
A color parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2348
QgsProcessingParameterTypeCoordinateOperation
A coordinate operation parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2416
QgsProcessingParameterTypeCrs
A crs parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:505
QgsProcessingParameterTypeDatabaseSchema
A database schema name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2681
QgsProcessingParameterTypeDatabaseTable
A database table name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2747
QgsProcessingParameterTypeDateTime
A datetime parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2545
QgsProcessingParameterTypeDestination
A common generic type for destination parameter, for specifying the destination path for a vector lay...
Definition qgsprocessingparametertypeimpl.h:1146
QgsProcessingParameterTypeDistance
A distance parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1819
QgsProcessingParameterTypeDuration
A duration parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1985
QgsProcessingParameterTypeEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values.
Definition qgsprocessingparametertypeimpl.h:794
QgsProcessingParameterTypeExpression
An expression parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:433
QgsProcessingParameterTypeExtent
A rectangular map extent parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:863
QgsProcessingParameterTypeFeatureSink
A feature sink parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2156
QgsProcessingParameterTypeFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1664
QgsProcessingParameterTypeField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1079
QgsProcessingParameterTypeFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition qgsprocessingparametertypeimpl.h:1237
QgsProcessingParameterTypeFile
An input file or folder parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1010
QgsProcessingParameterTypeFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition qgsprocessingparametertypeimpl.h:1314
QgsProcessingParameterTypeGeometry
A geometry parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:726
QgsProcessingParameterTypeLayoutItem
A print layout item parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2282
QgsProcessingParameterTypeLayout
A print layout parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2217
QgsProcessingParameterTypeMapLayer
A generic map layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:262
QgsProcessingParameterTypeMapTheme
A map theme parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2480
QgsProcessingParameterTypeMatrix
A table (matrix) parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:947
QgsProcessingParameterTypeMeshLayer
A mesh layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:109
QgsProcessingParameterTypeMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition qgsprocessingparametertypeimpl.h:1591
QgsProcessingParameterTypeNumber
A numeric parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1747
QgsProcessingParameterTypePointCloudAttribute
A point cloud layer attribute parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:3015
QgsProcessingParameterTypePointCloudDestination
A pointcloud layer destination parameter, for specifying the destination path for a point cloud layer...
Definition qgsprocessingparametertypeimpl.h:2956
QgsProcessingParameterTypePointCloudLayer
A point cloud layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2813
QgsProcessingParameterTypePoint
A point parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:658
QgsProcessingParameterTypeProviderConnection
A provider connection name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2615
QgsProcessingParameterTypeRange
A numeric range parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:592
QgsProcessingParameterTypeRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition qgsprocessingparametertypeimpl.h:1388
QgsProcessingParameterTypeRasterLayer
A raster layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:36
QgsProcessingParameterTypeScale
A scale parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2039
QgsProcessingParameterTypeString
A string parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1447
QgsProcessingParameterTypeVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition qgsprocessingparametertypeimpl.h:1177
QgsProcessingParameterTypeVectorLayer
A vector layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:181
QgsProcessingParameterTypeVectorTileDestination
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
Definition qgsprocessingparametertypeimpl.h:3082
QgsProcessingParameterTypeVolume
A volume parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1929
QgsProcessingParameterType
Makes metadata of processing parameters available.
Definition qgsprocessingparametertype.h:34
QgsProcessingParameterType::name
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
QgsProcessingParameterType::acceptedPythonTypes
virtual QStringList acceptedPythonTypes() const
Returns a list of the Python data types accepted as values for the parameter.
Definition qgsprocessingparametertype.cpp:30
QgsProcessingParameterType::create
virtual QgsProcessingParameterDefinition * create(const QString &name) const =0
Creates a new parameter of this type.
QgsProcessingParameterType::description
virtual QString description() const =0
A human readable and translatable description for this parameter type.
QgsProcessingParameterType::acceptedOutputTypes
virtual QStringList acceptedOutputTypes() const =0
Returns a list of compatible Processing output types for inputs for this parameter type.
Definition qgsprocessingparametertype.cpp:45
QgsProcessingParameterType::id
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
QgsProcessingParameterType::className
virtual QString className() const
Returns the corresponding class name for the parameter type.
Definition qgsprocessingparametertype.h:76
QgsProcessingParameterType::acceptedDataTypes
virtual QList< int > acceptedDataTypes(const QgsProcessingParameterDefinition *parameter) const
Returns a list of compatible Processing data types for inputs for this parameter type for the specifi...
Definition qgsprocessingparametertype.cpp:50
QgsProcessingParameterType::acceptedParameterTypes
virtual QStringList acceptedParameterTypes() const =0
Returns a list of compatible Processing parameter types for inputs for this parameter type.
Definition qgsprocessingparametertype.cpp:40
QgsProcessingParameterType::flags
virtual Qgis::ProcessingParameterTypeFlags flags() const
Determines if this parameter is available in the modeler.
Definition qgsprocessingparametertype.cpp:20
QgsProcessingParameterType::acceptedStringValues
virtual QStringList acceptedStringValues() const
Returns a descriptive list of the possible string values acceptable for the parameter.
Definition qgsprocessingparametertype.cpp:35
QgsProcessingParameterType::pythonImportString
virtual QString pythonImportString() const
Returns a valid Python import string for importing the corresponding parameter type,...
Definition qgsprocessingparametertype.h:66
QgsProcessingParameterVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition qgsprocessingparameters.h:3553
QgsProcessingParameterVectorLayer
A vector layer (with or without geometry) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3070
QgsProcessingParameterVectorLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3085
QgsProcessingParameterVectorTileDestination
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
Definition qgsprocessingparameters.h:4712
QgsProcessingParameterVolume
A double numeric parameter for volume values.
Definition qgsprocessingparameters.h:2513
QgsProcessingParameterVolume::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2529
qgis_sip.h
SIP_FACTORY
#define SIP_FACTORY
Definition qgis_sip.h:76
Generated on Fri May 2 2025 15:54:00 for QGIS API Documentation by doxygen 1.9.8