QGIS API Documentation 3.99.0-Master (2fe06baccd8)
Loading...
Searching...
No Matches
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 : [email protected]
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
25#include <QCoreApplication>
26
27#define SIP_NO_FILE
28
36class CORE_EXPORT QgsProcessingParameterTypeRasterLayer : public QgsProcessingParameterType
37{
38 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
39 {
40 return new QgsProcessingParameterRasterLayer( name );
41 }
42
43 QString description() const override
44 {
45 return QCoreApplication::translate( "Processing", "A raster layer parameter." );
46 }
47
48 QString name() const override
49 {
50 return QCoreApplication::translate( "Processing", "Raster Layer" );
51 }
52
53 QString pythonImportString() const override
54 {
55 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterLayer" );
56 }
57
58 QString className() const override
59 {
60 return QStringLiteral( "QgsProcessingParameterRasterLayer" );
61 }
62
63 QString id() const override
64 {
65 return QStringLiteral( "raster" );
66 }
67
68 QStringList acceptedPythonTypes() const override
69 {
70 return QStringList() << QObject::tr( "str: layer ID" )
71 << QObject::tr( "str: layer name" )
72 << QObject::tr( "str: layer source" )
73 << QStringLiteral( "QgsProcessingRasterLayerDefinition" )
74 << QStringLiteral( "QgsProperty" )
75 << QStringLiteral( "QgsRasterLayer" );
76 }
77
78 QStringList acceptedStringValues() const override
79 {
80 return QStringList() << QObject::tr( "Path to a raster layer" );
81 }
82
83 QStringList acceptedParameterTypes() const override
84 {
85 return QStringList()
86 << QgsProcessingParameterRasterLayer::typeName()
87 << QgsProcessingParameterMapLayer::typeName()
88 << QgsProcessingParameterString::typeName()
89 << QgsProcessingParameterExpression::typeName();
90 }
91
92 QStringList acceptedOutputTypes() const override
93 {
94 return QStringList()
95 << QgsProcessingOutputString::typeName()
96 << QgsProcessingOutputRasterLayer::typeName()
97 << QgsProcessingOutputMapLayer::typeName()
98 << QgsProcessingOutputFile::typeName()
99 << QgsProcessingOutputFolder::typeName();
100 }
101
102 QColor modelColor() const override { return QColor( 0, 180, 180 ); /* turquoise */ };
103};
104
112class CORE_EXPORT QgsProcessingParameterTypeMeshLayer : public QgsProcessingParameterType
113{
114 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
115 {
116 return new QgsProcessingParameterMeshLayer( name );
117 }
118
119 QString description() const override
120 {
121 return QCoreApplication::translate( "Processing", "A mesh layer parameter." );
122 }
123
124 QString name() const override
125 {
126 return QCoreApplication::translate( "Processing", "Mesh Layer" );
127 }
128
129 QString pythonImportString() const override
130 {
131 return QStringLiteral( "from qgis.core import QgsProcessingParameterMeshLayer" );
132 }
133
134 QString className() const override
135 {
136 return QStringLiteral( "QgsProcessingParameterMeshLayer" );
137 }
138
139 QString id() const override
140 {
141 return QStringLiteral( "mesh" );
142 }
143
144 QStringList acceptedPythonTypes() const override
145 {
146 return QStringList() << QObject::tr( "str: layer ID" )
147 << QObject::tr( "str: layer name" )
148 << QObject::tr( "str: layer source" )
149 << QStringLiteral( "QgsMeshLayer" );
150 }
151
152 QStringList acceptedStringValues() const override
153 {
154 return QStringList() << QObject::tr( "Path to a mesh layer" );
155 }
156
157 QStringList acceptedParameterTypes() const override
158 {
159 return QStringList()
160 << QgsProcessingParameterMeshLayer::typeName()
161 << QgsProcessingParameterMapLayer::typeName()
162 << QgsProcessingParameterString::typeName()
163 << QgsProcessingParameterExpression::typeName();
164 }
165
166 QStringList acceptedOutputTypes() const override
167 {
168 return QStringList()
169 << QgsProcessingOutputString::typeName()
170 // TODO << QgsProcessingOutputMeshLayer::typeName()
171 << QgsProcessingOutputMapLayer::typeName()
172 << QgsProcessingOutputFile::typeName()
173 << QgsProcessingOutputFolder::typeName();
174 }
175
176 QColor modelColor() const override { return QColor( 137, 150, 171 ); /* cold gray */ };
177};
178
186class CORE_EXPORT QgsProcessingParameterTypeVectorLayer : public QgsProcessingParameterType
187{
188 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
189 {
190 return new QgsProcessingParameterVectorLayer( name );
191 }
192
193 QString description() const override
194 {
195 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." );
196 }
197
198 QString name() const override
199 {
200 return QCoreApplication::translate( "Processing", "Vector Layer" );
201 }
202
203 QString pythonImportString() const override
204 {
205 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorLayer" );
206 }
207
208 QString className() const override
209 {
210 return QStringLiteral( "QgsProcessingParameterVectorLayer" );
211 }
212
213 QString id() const override
214 {
215 return QStringLiteral( "vector" );
216 }
217
218 QStringList acceptedPythonTypes() const override
219 {
220 return QStringList() << QObject::tr( "str: layer ID" )
221 << QObject::tr( "str: layer name" )
222 << QObject::tr( "str: layer source" )
223 << QStringLiteral( "QgsProperty" )
224 << QStringLiteral( "QgsVectorLayer" );
225 }
226
227 QStringList acceptedStringValues() const override
228 {
229 return QStringList() << QObject::tr( "Path to a vector layer" );
230 }
231
232 QStringList acceptedParameterTypes() const override
233 {
234 return QStringList()
235 << QgsProcessingParameterVectorLayer::typeName()
236 << QgsProcessingParameterMapLayer::typeName()
237 << QgsProcessingParameterString::typeName()
238 << QgsProcessingParameterExpression::typeName();
239 }
240
241 QStringList acceptedOutputTypes() const override
242 {
243 return QStringList()
244 << QgsProcessingOutputString::typeName()
245 << QgsProcessingOutputVectorLayer::typeName()
246 << QgsProcessingOutputMapLayer::typeName()
247 << QgsProcessingOutputFile::typeName()
248 << QgsProcessingOutputFolder::typeName();
249 }
250
251 QList<int> acceptedDataTypes( const QgsProcessingParameterDefinition *parameter ) const override
252 {
253 if ( const QgsProcessingParameterVectorLayer *param = dynamic_cast<const QgsProcessingParameterVectorLayer *>( parameter ) )
254 return param->dataTypes();
255 else
256 return QList<int>();
257 }
258
259 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
260};
261
269class CORE_EXPORT QgsProcessingParameterTypeMapLayer : public QgsProcessingParameterType
270{
271 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
272 {
273 return new QgsProcessingParameterMapLayer( name );
274 }
275
276 QString description() const override
277 {
278 return QCoreApplication::translate( "Processing", "A generic map layer parameter, which accepts either vector or raster layers." );
279 }
280
281 QString name() const override
282 {
283 return QCoreApplication::translate( "Processing", "Map Layer" );
284 }
285
286 QString id() const override
287 {
288 return QStringLiteral( "layer" );
289 }
290
291 QString pythonImportString() const override
292 {
293 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapLayer" );
294 }
295
296 QString className() const override
297 {
298 return QStringLiteral( "QgsProcessingParameterMapLayer" );
299 }
300
301 QStringList acceptedPythonTypes() const override
302 {
303 return QStringList() << QObject::tr( "str: layer ID" )
304 << QObject::tr( "str: layer name" )
305 << QObject::tr( "str: layer source" )
306 << QStringLiteral( "QgsMapLayer" )
307 << QStringLiteral( "QgsProperty" )
308 << QStringLiteral( "QgsRasterLayer" )
309 << QStringLiteral( "QgsVectorLayer" );
310 }
311
312 QStringList acceptedStringValues() const override
313 {
314 return QStringList() << QObject::tr( "Path to a vector, raster or mesh layer" );
315 }
316
317 QStringList acceptedParameterTypes() const override
318 {
319 return QStringList()
320 << QgsProcessingParameterRasterLayer::typeName()
321 << QgsProcessingParameterMeshLayer::typeName()
322 << QgsProcessingParameterVectorLayer::typeName()
323 << QgsProcessingParameterMapLayer::typeName()
324 << QgsProcessingParameterPointCloudLayer::typeName()
325 << QgsProcessingParameterAnnotationLayer::typeName()
326 << QgsProcessingParameterString::typeName()
327 << QgsProcessingParameterExpression::typeName();
328 }
329
330 QStringList acceptedOutputTypes() const override
331 {
332 return QStringList()
333 << QgsProcessingOutputString::typeName()
334 << QgsProcessingOutputRasterLayer::typeName()
335 << QgsProcessingOutputVectorLayer::typeName()
336 << QgsProcessingOutputMapLayer::typeName()
337 << QgsProcessingOutputFile::typeName()
338 << QgsProcessingOutputVariant::typeName();
339 }
340
341 QColor modelColor() const override { return QColor( 137, 150, 171 ); /* cold gray */ };
342};
343
351class CORE_EXPORT QgsProcessingParameterTypeBoolean : public QgsProcessingParameterType
352{
353 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
354 {
355 return new QgsProcessingParameterBoolean( name );
356 }
357
358 QString description() const override
359 {
360 return QCoreApplication::translate( "Processing", "A boolean parameter, for true/false values." );
361 }
362
363 QString name() const override
364 {
365 return QCoreApplication::translate( "Processing", "Boolean" );
366 }
367
368 QString id() const override
369 {
370 return QStringLiteral( "boolean" );
371 }
372
373 QString pythonImportString() const override
374 {
375 return QStringLiteral( "from qgis.core import QgsProcessingParameterBoolean" );
376 }
377
378 QString className() const override
379 {
380 return QStringLiteral( "QgsProcessingParameterBoolean" );
381 }
382
383 QStringList acceptedPythonTypes() const override
384 {
385 return QStringList() << QStringLiteral( "bool" )
386 << QStringLiteral( "int" )
387 << QStringLiteral( "str" )
388 << QStringLiteral( "QgsProperty" );
389 }
390
391 QStringList acceptedStringValues() const override
392 {
393 return QStringList() << QObject::tr( "1 for true/yes" )
394 << QObject::tr( "0 for false/no" )
395 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
396 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
397 }
398
399 QStringList acceptedParameterTypes() const override
400 {
401 //pretty much everything is compatible here and can be converted to a bool!
402 return QStringList() << QgsProcessingParameterBoolean::typeName()
403 << QgsProcessingParameterString::typeName()
404 << QgsProcessingParameterNumber::typeName()
405 << QgsProcessingParameterDistance::typeName()
406 << QgsProcessingParameterArea::typeName()
407 << QgsProcessingParameterVolume::typeName()
408 << QgsProcessingParameterDuration::typeName()
409 << QgsProcessingParameterScale::typeName()
410 << QgsProcessingParameterFile::typeName()
411 << QgsProcessingParameterField::typeName()
412 << QgsProcessingParameterFeatureSource::typeName()
413 << QgsProcessingParameterMapLayer::typeName()
414 << QgsProcessingParameterRasterLayer::typeName()
415 << QgsProcessingParameterVectorLayer::typeName()
416 << QgsProcessingParameterMeshLayer::typeName()
417 << QgsProcessingParameterExpression::typeName()
418 << QgsProcessingParameterProviderConnection::typeName()
419 << QgsProcessingParameterPointCloudLayer::typeName()
420 << QgsProcessingParameterAnnotationLayer::typeName();
421 }
422 QStringList acceptedOutputTypes() const override
423 {
424 return QStringList() << QgsProcessingOutputNumber::typeName()
425 << QgsProcessingOutputMapLayer::typeName()
426 << QgsProcessingOutputFile::typeName()
427 << QgsProcessingOutputRasterLayer::typeName()
428 << QgsProcessingOutputVectorLayer::typeName()
429 << QgsProcessingOutputString::typeName()
430 << QgsProcessingOutputVariant::typeName()
431 << QgsProcessingOutputBoolean::typeName();
432 }
433
434 QColor modelColor() const override { return QColor( 51, 201, 28 ); /* green */ };
435};
436
444class CORE_EXPORT QgsProcessingParameterTypeExpression : public QgsProcessingParameterType
445{
446 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
447 {
448 return new QgsProcessingParameterExpression( name );
449 }
450
451 QString description() const override
452 {
453 return QCoreApplication::translate( "Processing", "An expression parameter, to add custom expressions based on layer fields." );
454 }
455
456 QString name() const override
457 {
458 return QCoreApplication::translate( "Processing", "Expression" );
459 }
460
461 QString id() const override
462 {
463 return QStringLiteral( "expression" );
464 }
465
466 QString pythonImportString() const override
467 {
468 return QStringLiteral( "from qgis.core import QgsProcessingParameterExpression" );
469 }
470
471 QString className() const override
472 {
473 return QStringLiteral( "QgsProcessingParameterExpression" );
474 }
475
476 QStringList acceptedPythonTypes() const override
477 {
478 return QStringList() << QStringLiteral( "str" )
479 << QStringLiteral( "QgsProperty" );
480 }
481
482 QStringList acceptedStringValues() const override
483 {
484 return QStringList() << QObject::tr( "A valid QGIS expression string, e.g \"road_name\" = 'MAIN RD'" );
485 }
486
487 QStringList acceptedParameterTypes() const override
488 {
489 return QStringList()
490 << QgsProcessingParameterExpression::typeName()
491 << QgsProcessingParameterString::typeName()
492 << QgsProcessingParameterNumber::typeName()
493 << QgsProcessingParameterDistance::typeName()
494 << QgsProcessingParameterArea::typeName()
495 << QgsProcessingParameterVolume::typeName()
496 << QgsProcessingParameterScale::typeName()
497 << QgsProcessingParameterProviderConnection::typeName();
498 }
499
500 QStringList acceptedOutputTypes() const override
501 {
502 return QStringList()
503 << QgsProcessingOutputString::typeName()
504 << QgsProcessingOutputNumber::typeName()
505 << QgsProcessingOutputVariant::typeName();
506 }
507
508 QColor modelColor() const override { return QColor( 255, 131, 23 ); /* orange */ };
509};
510
518class CORE_EXPORT QgsProcessingParameterTypeCrs : public QgsProcessingParameterType
519{
520 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
521 {
522 return new QgsProcessingParameterCrs( name );
523 }
524
525 QString description() const override
526 {
527 return QCoreApplication::translate( "Processing", "A coordinate reference system (CRS) input parameter." );
528 }
529
530 QString name() const override
531 {
532 return QCoreApplication::translate( "Processing", "CRS" );
533 }
534
535 QString id() const override
536 {
537 return QStringLiteral( "crs" );
538 }
539
540 QString pythonImportString() const override
541 {
542 return QStringLiteral( "from qgis.core import QgsProcessingParameterCrs" );
543 }
544
545 QString className() const override
546 {
547 return QStringLiteral( "QgsProcessingParameterCrs" );
548 }
549
550 QStringList acceptedPythonTypes() const override
551 {
552 return QStringList()
553 << QStringLiteral( "str: 'ProjectCrs'" )
554 << QObject::tr( "str: CRS auth ID (e.g. 'EPSG:3111')" )
555 << QObject::tr( "str: CRS PROJ4 (e.g. 'PROJ4:…')" )
556 << QObject::tr( "str: CRS WKT (e.g. 'WKT:…')" )
557 << QObject::tr( "str: layer ID. CRS of layer is used." )
558 << QObject::tr( "str: layer name. CRS of layer is used." )
559 << QObject::tr( "str: layer source. CRS of layer is used." )
560 << QObject::tr( "QgsCoordinateReferenceSystem" )
561 << QObject::tr( "QgsMapLayer: CRS of layer is used" )
562 << QObject::tr( "QgsProcessingFeatureSourceDefinition: CRS of source is used" )
563 << QStringLiteral( "QgsProperty" );
564 }
565
566 QStringList acceptedStringValues() const override
567 {
568 return QStringList() << QObject::tr( "CRS as an auth ID (e.g. 'EPSG:3111')" )
569 << QObject::tr( "CRS as a PROJ4 string (e.g. 'PROJ4:…')" )
570 << QObject::tr( "CRS as a WKT string (e.g. 'WKT:…')" )
571 << QObject::tr( "Path to a layer. The CRS of the layer is used." ) ;
572 }
573
574 QStringList acceptedParameterTypes() const override
575 {
576 return QStringList()
577 << QgsProcessingParameterCrs::typeName()
578 << QgsProcessingParameterExpression::typeName()
579 << QgsProcessingParameterString::typeName()
580 << QgsProcessingParameterRasterLayer::typeName()
581 << QgsProcessingParameterVectorLayer::typeName()
582 << QgsProcessingParameterMeshLayer::typeName()
583 << QgsProcessingParameterFeatureSource::typeName()
584 << QgsProcessingParameterPointCloudLayer::typeName()
585 << QgsProcessingParameterAnnotationLayer::typeName();
586 }
587
588 QStringList acceptedOutputTypes() const override
589 {
590 return QStringList() << QgsProcessingOutputVectorLayer::typeName()
591 << QgsProcessingOutputRasterLayer::typeName()
592 << QgsProcessingOutputMapLayer::typeName()
593 << QgsProcessingOutputString::typeName()
594 << QgsProcessingOutputVariant::typeName();
595 }
596
597 QColor modelColor() const override { return QColor( 255, 131, 23 ); /* orange */ };
598};
599
607class CORE_EXPORT QgsProcessingParameterTypeRange : public QgsProcessingParameterType
608{
609 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
610 {
611 return new QgsProcessingParameterRange( name );
612 }
613
614 QString description() const override
615 {
616 return QCoreApplication::translate( "Processing", "A numeric range parameter for processing algorithms." );
617 }
618
619 QString name() const override
620 {
621 return QCoreApplication::translate( "Processing", "Range" );
622 }
623
624 QString id() const override
625 {
626 return QStringLiteral( "range" );
627 }
628
629 QString pythonImportString() const override
630 {
631 return QStringLiteral( "from qgis.core import QgsProcessingParameterRange" );
632 }
633
634 QString className() const override
635 {
636 return QStringLiteral( "QgsProcessingParameterRange" );
637 }
638
639 QStringList acceptedPythonTypes() const override
640 {
641 return QStringList() << QObject::tr( "list[float]: list of 2 float values" )
642 << QObject::tr( "list[str]: list of strings representing floats" )
643 << QObject::tr( "str: as two comma delimited floats, e.g. '1,10'" )
644 << QStringLiteral( "QgsProperty" );
645 }
646
647 QStringList acceptedStringValues() const override
648 {
649 return QStringList() << QObject::tr( "Two comma separated numeric values, e.g. '1,10'" );
650 }
651
652 QStringList acceptedParameterTypes() const override
653 {
654 return QStringList()
655 << QgsProcessingParameterRange::typeName()
656 << QgsProcessingParameterString::typeName();
657 }
658
659 QStringList acceptedOutputTypes() const override
660 {
661 return QStringList() << QgsProcessingOutputString::typeName()
662 << QgsProcessingOutputVariant::typeName();
663 }
664
665 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
666};
667
675class CORE_EXPORT QgsProcessingParameterTypePoint : public QgsProcessingParameterType
676{
677 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
678 {
679 return new QgsProcessingParameterPoint( name );
680 }
681
682 QString description() const override
683 {
684 return QCoreApplication::translate( "Processing", "A point geometry parameter." );
685 }
686
687 QString name() const override
688 {
689 return QCoreApplication::translate( "Processing", "Point" );
690 }
691
692 QString id() const override
693 {
694 return QStringLiteral( "point" );
695 }
696
697 QString pythonImportString() const override
698 {
699 return QStringLiteral( "from qgis.core import QgsProcessingParameterPoint" );
700 }
701
702 QString className() const override
703 {
704 return QStringLiteral( "QgsProcessingParameterPoint" );
705 }
706
707 QStringList acceptedPythonTypes() const override
708 {
709 return QStringList() << QObject::tr( "str: as an 'x,y' string, e.g. '1.5,10.1'" )
710 << QStringLiteral( "QgsPointXY" )
711 << QStringLiteral( "QgsProperty" )
712 << QStringLiteral( "QgsReferencedPointXY" )
713 << QStringLiteral( "QgsGeometry: centroid of geometry is used" );
714 }
715
716 QStringList acceptedStringValues() const override
717 {
718 return QStringList() << QObject::tr( "Point coordinate as an 'x,y' string, e.g. '1.5,10.1'" );
719 }
720
721 QStringList acceptedParameterTypes() const override
722 {
723 return QStringList()
724 << QgsProcessingParameterPoint::typeName()
725 << QgsProcessingParameterString::typeName();
726 }
727
728 QStringList acceptedOutputTypes() const override
729 {
730 return QStringList()
731 << QgsProcessingOutputString::typeName()
732 << QgsProcessingOutputVariant::typeName();
733 }
734
735 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
736};
737
745class CORE_EXPORT QgsProcessingParameterTypeGeometry : public QgsProcessingParameterType
746{
747 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
748 {
749 return new QgsProcessingParameterGeometry( name );
750 }
751
752 QString description() const override
753 {
754 return QCoreApplication::translate( "Processing", "A geometry parameter." );
755 }
756
757 QString name() const override
758 {
759 return QCoreApplication::translate( "Processing", "Geometry" );
760 }
761
762 QString id() const override
763 {
764 return QStringLiteral( "geometry" );
765 }
766
767 QString pythonImportString() const override
768 {
769 return QStringLiteral( "from qgis.core import QgsProcessingParameterGeometry" );
770 }
771
772 QString className() const override
773 {
774 return QStringLiteral( "QgsProcessingParameterGeometry" );
775 }
776
777 QStringList acceptedPythonTypes() const override
778 {
779 return QStringList() << QObject::tr( "str: as Well-Known Text string (WKT)" )
780 << QStringLiteral( "QgsGeometry" )
781 << QStringLiteral( "QgsProperty" );
782 }
783
784 QStringList acceptedStringValues() const override
785 {
786 return QStringList() << QObject::tr( "Well-Known Text string (WKT)" );
787 }
788
789 QStringList acceptedParameterTypes() const override
790 {
791 return QStringList()
792 << QgsProcessingParameterGeometry::typeName()
793 << QgsProcessingParameterString::typeName()
794 << QgsProcessingParameterPoint::typeName()
795 << QgsProcessingParameterExtent::typeName();
796 }
797
798 QStringList acceptedOutputTypes() const override
799 {
800 return QStringList()
801 << QgsProcessingOutputString::typeName()
802 << QgsProcessingOutputVariant::typeName();
803 }
804
805 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
806};
807
815class CORE_EXPORT QgsProcessingParameterTypeEnum : public QgsProcessingParameterType
816{
817 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
818 {
819 return new QgsProcessingParameterEnum( name );
820 }
821
822 QString description() const override
823 {
824 return QCoreApplication::translate( "Processing", "An enumerated type parameter." );
825 }
826
827 QString name() const override
828 {
829 return QCoreApplication::translate( "Processing", "Enum" );
830 }
831
832 QString id() const override
833 {
834 return QStringLiteral( "enum" );
835 }
836
837 QString pythonImportString() const override
838 {
839 return QStringLiteral( "from qgis.core import QgsProcessingParameterEnum" );
840 }
841
842 QString className() const override
843 {
844 return QStringLiteral( "QgsProcessingParameterEnum" );
845 }
846
847 QStringList acceptedPythonTypes() const override
848 {
849 return QStringList() << QStringLiteral( "int" )
850 << QObject::tr( "str: as string representation of int, e.g. '1'" )
851 << QStringLiteral( "QgsProperty" );
852 }
853
854 QStringList acceptedStringValues() const override
855 {
856 return QStringList() << QObject::tr( "Number of selected option, e.g. '1'" )
857 << QObject::tr( "Comma separated list of options, e.g. '1,3'" );
858 }
859
860 QStringList acceptedParameterTypes() const override
861 {
862 return QStringList()
863 << QgsProcessingParameterEnum::typeName()
864 << QgsProcessingParameterString::typeName()
865 << QgsProcessingParameterNumber::typeName();
866 }
867
868 QStringList acceptedOutputTypes() const override
869 {
870 return QStringList()
871 << QgsProcessingOutputString::typeName()
872 << QgsProcessingOutputVariant::typeName()
873 << QgsProcessingOutputNumber::typeName();
874 }
875
876 QColor modelColor() const override { return QColor( 152, 68, 201 ); /* purple */ };
877};
878
886class CORE_EXPORT QgsProcessingParameterTypeExtent : public QgsProcessingParameterType
887{
888 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
889 {
890 return new QgsProcessingParameterExtent( name );
891 }
892
893 QString description() const override
894 {
895 return QCoreApplication::translate( "Processing", "A map extent parameter." );
896 }
897
898 QString name() const override
899 {
900 return QCoreApplication::translate( "Processing", "Extent" );
901 }
902
903 QString id() const override
904 {
905 return QStringLiteral( "extent" );
906 }
907
908 QString pythonImportString() const override
909 {
910 return QStringLiteral( "from qgis.core import QgsProcessingParameterExtent" );
911 }
912
913 QString className() const override
914 {
915 return QStringLiteral( "QgsProcessingParameterExtent" );
916 }
917
918 QStringList acceptedPythonTypes() const override
919 {
920 return QStringList() << QObject::tr( "str: as comma delimited list of x min, x max, y min, y max. E.g. '4,10,101,105'" )
921 << QObject::tr( "str: layer ID. Extent of layer is used." )
922 << QObject::tr( "str: layer name. Extent of layer is used." )
923 << QObject::tr( "str: layer source. Extent of layer is used." )
924 << QObject::tr( "QgsMapLayer: Extent of layer is used" )
925 << QObject::tr( "QgsProcessingFeatureSourceDefinition: Extent of source is used" )
926 << QStringLiteral( "QgsProperty" )
927 << QStringLiteral( "QgsRectangle" )
928 << QStringLiteral( "QgsReferencedRectangle" )
929 << QStringLiteral( "QgsGeometry: bounding box of geometry is used" );
930 }
931
932 QStringList acceptedStringValues() const override
933 {
934 return QStringList() << QObject::tr( "A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'" )
935 << QObject::tr( "Path to a layer. The extent of the layer is used." ) ;
936 }
937
938 QStringList acceptedParameterTypes() const override
939 {
940 return QStringList()
941 << QgsProcessingParameterExtent::typeName()
942 << QgsProcessingParameterString::typeName()
943 << QgsProcessingParameterMapLayer::typeName()
944 << QgsProcessingParameterFeatureSource::typeName()
945 << QgsProcessingParameterRasterLayer::typeName()
946 << QgsProcessingParameterVectorLayer::typeName()
947 << QgsProcessingParameterMeshLayer::typeName()
948 << QgsProcessingParameterPointCloudLayer::typeName()
949 << QgsProcessingParameterAnnotationLayer::typeName();
950 }
951
952 QStringList acceptedOutputTypes() const override
953 {
954 return QStringList()
955 << QgsProcessingOutputString::typeName()
956 << QgsProcessingOutputRasterLayer::typeName()
957 << QgsProcessingOutputVectorLayer::typeName()
958 << QgsProcessingOutputMapLayer::typeName()
959 << QgsProcessingOutputVariant::typeName();
960 }
961
962 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
963};
964
972class CORE_EXPORT QgsProcessingParameterTypeMatrix : public QgsProcessingParameterType
973{
974 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
975 {
976 return new QgsProcessingParameterMatrix( name );
977 }
978
979 QString description() const override
980 {
981 return QCoreApplication::translate( "Processing", "A table (matrix) parameter for processing algorithms." );
982 }
983
984 QString name() const override
985 {
986 return QCoreApplication::translate( "Processing", "Matrix" );
987 }
988
989 QString id() const override
990 {
991 return QStringLiteral( "matrix" );
992 }
993
994 QString pythonImportString() const override
995 {
996 return QStringLiteral( "from qgis.core import QgsProcessingParameterMatrix" );
997 }
998
999 QString className() const override
1000 {
1001 return QStringLiteral( "QgsProcessingParameterMatrix" );
1002 }
1003
1004 QStringList acceptedPythonTypes() const override
1005 {
1006 return QStringList() << QObject::tr( "str: as comma delimited list of values" )
1007 << QStringLiteral( "list" )
1008 << QStringLiteral( "QgsProperty" );
1009 }
1010
1011 QStringList acceptedStringValues() const override
1012 {
1013 return QStringList() << QObject::tr( "A comma delimited list of values" );
1014 }
1015
1016 QStringList acceptedParameterTypes() const override
1017 {
1018 return QStringList()
1019 << QgsProcessingParameterMatrix::typeName();
1020 }
1021
1022 QStringList acceptedOutputTypes() const override
1023 {
1024 return QStringList();
1025 }
1026
1027 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
1028};
1029
1037class CORE_EXPORT QgsProcessingParameterTypeFile : public QgsProcessingParameterType
1038{
1039 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1040 {
1041 return new QgsProcessingParameterFile( name );
1042 }
1043
1044 QString description() const override
1045 {
1046 return QCoreApplication::translate( "Processing", "A file or folder parameter, for use with non-map layer file sources or folders." );
1047 }
1048
1049 QString name() const override
1050 {
1051 return QCoreApplication::translate( "Processing", "File/Folder" );
1052 }
1053
1054 QString id() const override
1055 {
1056 return QStringLiteral( "file" );
1057 }
1058
1059 QString pythonImportString() const override
1060 {
1061 return QStringLiteral( "from qgis.core import QgsProcessingParameterFile" );
1062 }
1063
1064 QString className() const override
1065 {
1066 return QStringLiteral( "QgsProcessingParameterFile" );
1067 }
1068
1069 QStringList acceptedPythonTypes() const override
1070 {
1071 return QStringList() << QStringLiteral( "str" )
1072 << QStringLiteral( "QgsProperty" );
1073 }
1074
1075 QStringList acceptedStringValues() const override
1076 {
1077 return QStringList() << QObject::tr( "Path to a file" );
1078 }
1079
1080 QStringList acceptedParameterTypes() const override
1081 {
1082 return QStringList()
1083 << QgsProcessingParameterString::typeName()
1084 << QgsProcessingParameterFile::typeName();
1085 }
1086
1087 QStringList acceptedOutputTypes() const override
1088 {
1089 return QStringList() << QgsProcessingOutputFile::typeName()
1090 << QgsProcessingOutputFolder::typeName()
1091 << QgsProcessingOutputString::typeName()
1092 << QgsProcessingOutputVariant::typeName()
1093 << QgsProcessingOutputRasterLayer::typeName()
1094 << QgsProcessingOutputVectorLayer::typeName()
1095 << QgsProcessingOutputMapLayer::typeName();
1096 }
1097
1098 QColor modelColor() const override { return QColor( 80, 80, 80 ); /* dark gray */ };
1099};
1100
1108class CORE_EXPORT QgsProcessingParameterTypeField : public QgsProcessingParameterType
1109{
1110 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1111 {
1112 return new QgsProcessingParameterField( name );
1113 }
1114
1115 QString description() const override
1116 {
1117 return QCoreApplication::translate( "Processing", "A vector field parameter, for selecting an existing field from a vector source." );
1118 }
1119
1120 QString name() const override
1121 {
1122 return QCoreApplication::translate( "Processing", "Vector Field" );
1123 }
1124
1125 QString id() const override
1126 {
1127 return QStringLiteral( "field" );
1128 }
1129
1130 QString pythonImportString() const override
1131 {
1132 return QStringLiteral( "from qgis.core import QgsProcessingParameterField" );
1133 }
1134
1135 QString className() const override
1136 {
1137 return QStringLiteral( "QgsProcessingParameterField" );
1138 }
1139
1140 QStringList acceptedPythonTypes() const override
1141 {
1142 return QStringList() << QStringLiteral( "str" )
1143 << QStringLiteral( "QgsProperty" );
1144 }
1145
1146 QStringList acceptedStringValues() const override
1147 {
1148 return QStringList() << QObject::tr( "The name of an existing field" )
1149 << QObject::tr( "; delimited list of existing field names" );
1150 }
1151
1152 QStringList acceptedParameterTypes() const override
1153 {
1154 return QStringList()
1155 << QgsProcessingParameterField::typeName()
1156 << QgsProcessingParameterString::typeName();
1157 }
1158
1159 QStringList acceptedOutputTypes() const override
1160 {
1161 return QStringList()
1162 << QgsProcessingOutputString::typeName()
1163 << QgsProcessingOutputVariant::typeName();
1164 }
1165};
1166
1167
1197
1206class CORE_EXPORT QgsProcessingParameterTypeVectorDestination : public QgsProcessingParameterTypeDestination
1207{
1208 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1209 {
1210 return new QgsProcessingParameterVectorDestination( name );
1211 }
1212
1213 QString description() const override
1214 {
1215 return QCoreApplication::translate( "Processing", "A vector layer destination parameter." );
1216 }
1217
1218 QString name() const override
1219 {
1220 return QCoreApplication::translate( "Processing", "Vector Destination" );
1221 }
1222
1223 QString id() const override
1224 {
1225 return QStringLiteral( "vectorDestination" );
1226 }
1227
1228 QString pythonImportString() const override
1229 {
1230 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorDestination" );
1231 }
1232
1233 QString className() const override
1234 {
1235 return QStringLiteral( "QgsProcessingParameterVectorDestination" );
1236 }
1237
1238 Qgis::ProcessingParameterTypeFlags flags() const override
1239 {
1240 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1241 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1242 return flags;
1243 }
1244
1245 QStringList acceptedPythonTypes() const override
1246 {
1247 return QStringList() << QStringLiteral( "str" )
1248 << QStringLiteral( "QgsProperty" )
1249 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1250 }
1251
1252 QStringList acceptedStringValues() const override
1253 {
1254 return QStringList() << QObject::tr( "Path for new vector layer" );
1255 }
1256
1257 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
1258};
1259
1268class CORE_EXPORT QgsProcessingParameterTypeFileDestination : public QgsProcessingParameterTypeDestination
1269{
1270 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1271 {
1272 return new QgsProcessingParameterFileDestination( name );
1273 }
1274
1275 QString description() const override
1276 {
1277 return QCoreApplication::translate( "Processing", "A generic file based destination parameter." );
1278 }
1279
1280 QString name() const override
1281 {
1282 return QCoreApplication::translate( "Processing", "File Destination" );
1283 }
1284
1285 QString id() const override
1286 {
1287 return QStringLiteral( "fileDestination" );
1288 }
1289
1290 QString pythonImportString() const override
1291 {
1292 return QStringLiteral( "from qgis.core import QgsProcessingParameterFileDestination" );
1293 }
1294
1295 QString className() const override
1296 {
1297 return QStringLiteral( "QgsProcessingParameterFileDestination" );
1298 }
1299
1300 Qgis::ProcessingParameterTypeFlags flags() const override
1301 {
1302 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1303 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1304 return flags;
1305 }
1306
1307 QStringList acceptedPythonTypes() const override
1308 {
1309 return QStringList() << QStringLiteral( "str" )
1310 << QStringLiteral( "QgsProperty" );
1311 }
1312
1313 QStringList acceptedStringValues() const override
1314 {
1315 return QStringList() << QObject::tr( "Path for new file" );
1316 }
1317
1318 QStringList acceptedParameterTypes() const override
1319 {
1320 return QStringList()
1321 << QgsProcessingParameterString::typeName()
1322 << QgsProcessingParameterFile::typeName();
1323 }
1324
1325 QStringList acceptedOutputTypes() const override
1326 {
1327 return QStringList() << QgsProcessingOutputFile::typeName()
1328 << QgsProcessingOutputString::typeName()
1329 << QgsProcessingOutputVariant::typeName()
1330 << QgsProcessingOutputRasterLayer::typeName()
1331 << QgsProcessingOutputVectorLayer::typeName()
1332 << QgsProcessingOutputMapLayer::typeName();
1333 }
1334
1335 QColor modelColor() const override { return QColor( 80, 80, 80 ); /* dark gray */ };
1336};
1337
1347class CORE_EXPORT QgsProcessingParameterTypeFolderDestination : public QgsProcessingParameterTypeDestination
1348{
1349 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1350 {
1351 return new QgsProcessingParameterFolderDestination( name );
1352 }
1353
1354 QString description() const override
1355 {
1356 return QCoreApplication::translate( "Processing", "A folder destination parameter." );
1357 }
1358
1359 QString name() const override
1360 {
1361 return QCoreApplication::translate( "Processing", "Folder Destination" );
1362 }
1363
1364 QString id() const override
1365 {
1366 return QStringLiteral( "folderDestination" );
1367 }
1368
1369 QString pythonImportString() const override
1370 {
1371 return QStringLiteral( "from qgis.core import QgsProcessingParameterFolderDestination" );
1372 }
1373
1374 QString className() const override
1375 {
1376 return QStringLiteral( "QgsProcessingParameterFolderDestination" );
1377 }
1378
1379 Qgis::ProcessingParameterTypeFlags flags() const override
1380 {
1381 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1382 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1383 return flags;
1384 }
1385
1386 QStringList acceptedPythonTypes() const override
1387 {
1388 return QStringList() << QStringLiteral( "str" )
1389 << QStringLiteral( "QgsProperty" );
1390 }
1391
1392 QStringList acceptedStringValues() const override
1393 {
1394 return QStringList() << QObject::tr( "Path for an existing or new folder" );
1395 }
1396
1397 QStringList acceptedParameterTypes() const override
1398 {
1399 return QStringList()
1400 << QgsProcessingParameterString::typeName()
1401 << QgsProcessingParameterFile::typeName();
1402 }
1403
1404 QStringList acceptedOutputTypes() const override
1405 {
1406 return QStringList() << QgsProcessingOutputFile::typeName()
1407 << QgsProcessingOutputFolder::typeName()
1408 << QgsProcessingOutputString::typeName()
1409 << QgsProcessingOutputVariant::typeName();
1410 }
1411
1412 QColor modelColor() const override { return QColor( 80, 80, 80 ); /* dark gray */ };
1413};
1414
1423class CORE_EXPORT QgsProcessingParameterTypeRasterDestination : public QgsProcessingParameterTypeDestination
1424{
1425 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1426 {
1427 return new QgsProcessingParameterRasterDestination( name );
1428 }
1429
1430 QString description() const override
1431 {
1432 return QCoreApplication::translate( "Processing", "A raster layer destination parameter." );
1433 }
1434
1435 QString name() const override
1436 {
1437 return QCoreApplication::translate( "Processing", "Raster Destination" );
1438 }
1439
1440 QString id() const override
1441 {
1442 return QStringLiteral( "rasterDestination" );
1443 }
1444
1445 QString pythonImportString() const override
1446 {
1447 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterDestination" );
1448 }
1449
1450 QString className() const override
1451 {
1452 return QStringLiteral( "QgsProcessingParameterRasterDestination" );
1453 }
1454
1455 Qgis::ProcessingParameterTypeFlags flags() const override
1456 {
1457 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
1458 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
1459 return flags;
1460 }
1461
1462 QStringList acceptedPythonTypes() const override
1463 {
1464 return QStringList() << QStringLiteral( "str" )
1465 << QStringLiteral( "QgsProperty" )
1466 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1467 }
1468
1469 QStringList acceptedStringValues() const override
1470 {
1471 return QStringList() << QObject::tr( "Path for new raster layer" );
1472 }
1473
1474 QColor modelColor() const override { return QColor( 0, 180, 180 ); /* turquoise */ };
1475};
1476
1484class CORE_EXPORT QgsProcessingParameterTypeString : public QgsProcessingParameterType
1485{
1486 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1487 {
1488 return new QgsProcessingParameterString( name );
1489 }
1490
1491 QString description() const override
1492 {
1493 return QCoreApplication::translate( "Processing", "A freeform string parameter." );
1494 }
1495
1496 QString name() const override
1497 {
1498 return QCoreApplication::translate( "Processing", "String" );
1499 }
1500
1501 QString id() const override
1502 {
1503 return QStringLiteral( "string" );
1504 }
1505
1506 QString pythonImportString() const override
1507 {
1508 return QStringLiteral( "from qgis.core import QgsProcessingParameterString" );
1509 }
1510
1511 QString className() const override
1512 {
1513 return QStringLiteral( "QgsProcessingParameterString" );
1514 }
1515
1516 QStringList acceptedPythonTypes() const override
1517 {
1518 return QStringList() << QStringLiteral( "str" )
1519 << QStringLiteral( "QgsProperty" );
1520 }
1521
1522 QStringList acceptedStringValues() const override
1523 {
1524 return QStringList() << QObject::tr( "String value" )
1525 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1526 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1527 }
1528
1529 QStringList acceptedParameterTypes() const override
1530 {
1531 return QStringList()
1532 << QgsProcessingParameterString::typeName()
1533 << QgsProcessingParameterAuthConfig::typeName()
1534 << QgsProcessingParameterNumber::typeName()
1535 << QgsProcessingParameterDistance::typeName()
1536 << QgsProcessingParameterArea::typeName()
1537 << QgsProcessingParameterVolume::typeName()
1538 << QgsProcessingParameterDuration::typeName()
1539 << QgsProcessingParameterScale::typeName()
1540 << QgsProcessingParameterFile::typeName()
1541 << QgsProcessingParameterField::typeName()
1542 << QgsProcessingParameterExpression::typeName()
1543 << QgsProcessingParameterCoordinateOperation::typeName()
1544 << QgsProcessingParameterProviderConnection::typeName();
1545 }
1546
1547 QStringList acceptedOutputTypes() const override
1548 {
1549 return QStringList() << QgsProcessingOutputNumber::typeName()
1550 << QgsProcessingOutputVariant::typeName()
1551 << QgsProcessingOutputFile::typeName()
1552 << QgsProcessingOutputFolder::typeName()
1553 << QgsProcessingOutputString::typeName();
1554 }
1555
1556 QColor modelColor() const override { return QColor( 255, 131, 23 ); /* orange */ };
1557};
1558
1566class CORE_EXPORT QgsProcessingParameterTypeAuthConfig : public QgsProcessingParameterType
1567{
1568 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1569 {
1570 return new QgsProcessingParameterAuthConfig( name );
1571 }
1572
1573 QString description() const override
1574 {
1575 return QCoreApplication::translate( "Processing", "An authentication configuration parameter." );
1576 }
1577
1578 QString name() const override
1579 {
1580 return QCoreApplication::translate( "Processing", "Authentication Configuration" );
1581 }
1582
1583 QString id() const override
1584 {
1585 return QStringLiteral( "authcfg" );
1586 }
1587
1588 QString pythonImportString() const override
1589 {
1590 return QStringLiteral( "from qgis.core import QgsProcessingParameterAuthConfig" );
1591 }
1592
1593 QString className() const override
1594 {
1595 return QStringLiteral( "QgsProcessingParameterAuthConfig" );
1596 }
1597
1598 QStringList acceptedPythonTypes() const override
1599 {
1600 return QStringList() << QStringLiteral( "str" );
1601 }
1602
1603 QStringList acceptedStringValues() const override
1604 {
1605 return QStringList() << QObject::tr( "An existing QGIS authentication ID string" );
1606 }
1607
1608 QStringList acceptedParameterTypes() const override
1609 {
1610 return QStringList()
1611 << QgsProcessingParameterAuthConfig::typeName()
1612 << QgsProcessingParameterString::typeName()
1613 << QgsProcessingParameterExpression::typeName();
1614 }
1615
1616 QStringList acceptedOutputTypes() const override
1617 {
1618 return QStringList() << QgsProcessingOutputString::typeName()
1619 << QgsProcessingOutputVariant::typeName();
1620 }
1621};
1622
1630class CORE_EXPORT QgsProcessingParameterTypeMultipleLayers : public QgsProcessingParameterType
1631{
1632 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1633 {
1634 return new QgsProcessingParameterMultipleLayers( name );
1635 }
1636
1637 QString description() const override
1638 {
1639 return QCoreApplication::translate( "Processing", "An input allowing selection of multiple sources, including multiple map layers or file sources." );
1640 }
1641
1642 QString name() const override
1643 {
1644 return QCoreApplication::translate( "Processing", "Multiple Input" );
1645 }
1646
1647 QString id() const override
1648 {
1649 return QStringLiteral( "multilayer" );
1650 }
1651
1652 QString pythonImportString() const override
1653 {
1654 return QStringLiteral( "from qgis.core import QgsProcessingParameterMultipleLayers" );
1655 }
1656
1657 QString className() const override
1658 {
1659 return QStringLiteral( "QgsProcessingParameterMultipleLayers" );
1660 }
1661
1662 QStringList acceptedPythonTypes() const override
1663 {
1664 return QStringList() << QObject::tr( "list[str]: list of layer IDs" )
1665 << QObject::tr( "list[str]: list of layer names" )
1666 << QObject::tr( "list[str]: list of layer sources" )
1667 << QStringLiteral( "list[QgsMapLayer]" )
1668 << QStringLiteral( "QgsProperty" );
1669 }
1670
1671 QStringList acceptedParameterTypes() const override
1672 {
1673 return QStringList()
1674 << QgsProcessingParameterMultipleLayers::typeName()
1675 << QgsProcessingParameterMapLayer::typeName()
1676 << QgsProcessingParameterVectorLayer::typeName()
1677 << QgsProcessingParameterMeshLayer::typeName()
1678 << QgsProcessingParameterFeatureSource::typeName()
1679 << QgsProcessingParameterRasterLayer::typeName()
1680 << QgsProcessingParameterFile::typeName()
1681 << QgsProcessingParameterString::typeName();
1682 }
1683 QStringList acceptedOutputTypes() const override
1684 {
1685 return QStringList()
1686 << QgsProcessingOutputMapLayer::typeName()
1687 << QgsProcessingOutputRasterLayer::typeName()
1688 << QgsProcessingOutputVectorLayer::typeName()
1689 << QgsProcessingOutputMultipleLayers::typeName()
1690 << QgsProcessingOutputFile::typeName()
1691 << QgsProcessingOutputString::typeName()
1692 << QgsProcessingOutputVariant::typeName();
1693 }
1694
1695 QColor modelColor() const override { return QColor( 137, 150, 171 ); /* cold gray */ };
1696};
1697
1705class CORE_EXPORT QgsProcessingParameterTypeFeatureSource : public QgsProcessingParameterType
1706{
1707 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1708 {
1709 return new QgsProcessingParameterFeatureSource( name );
1710 }
1711
1712 QString description() const override
1713 {
1714 return QCoreApplication::translate( "Processing", "A vector feature parameter, e.g. for algorithms which operate on the features within a layer." );
1715 }
1716
1717 QString name() const override
1718 {
1719 return QCoreApplication::translate( "Processing", "Vector Features" );
1720 }
1721
1722 QString id() const override
1723 {
1724 return QStringLiteral( "source" );
1725 }
1726
1727 QString pythonImportString() const override
1728 {
1729 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSource" );
1730 }
1731
1732 QString className() const override
1733 {
1734 return QStringLiteral( "QgsProcessingParameterFeatureSource" );
1735 }
1736
1737 QStringList acceptedPythonTypes() const override
1738 {
1739 return QStringList() << QObject::tr( "str: layer ID" )
1740 << QObject::tr( "str: layer name" )
1741 << QObject::tr( "str: layer source" )
1742 << QStringLiteral( "QgsProcessingFeatureSourceDefinition" )
1743 << QStringLiteral( "QgsProperty" )
1744 << QStringLiteral( "QgsVectorLayer" );
1745 }
1746
1747 QStringList acceptedStringValues() const override
1748 {
1749 return QStringList() << QObject::tr( "Path to a vector layer" );
1750 }
1751
1752 QStringList acceptedParameterTypes() const override
1753 {
1754 return QStringList()
1755 << QgsProcessingParameterFeatureSource::typeName()
1756 << QgsProcessingParameterVectorLayer::typeName()
1757 << QgsProcessingParameterMapLayer::typeName()
1758 << QgsProcessingParameterString::typeName()
1759 << QgsProcessingParameterExpression::typeName();
1760 }
1761
1762 QStringList acceptedOutputTypes() const override
1763 {
1764 return QStringList()
1765 << QgsProcessingOutputString::typeName()
1766 << QgsProcessingOutputVectorLayer::typeName()
1767 << QgsProcessingOutputMapLayer::typeName()
1768 << QgsProcessingOutputFile::typeName()
1769 << QgsProcessingOutputFolder::typeName();
1770 }
1771
1772 QList<int> acceptedDataTypes( const QgsProcessingParameterDefinition *parameter ) const override
1773 {
1774 if ( const QgsProcessingParameterFeatureSource *param = dynamic_cast<const QgsProcessingParameterFeatureSource *>( parameter ) )
1775 return param->dataTypes();
1776 else
1777 return QList<int>();
1778 }
1779
1780 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
1781};
1782
1790class CORE_EXPORT QgsProcessingParameterTypeNumber : public QgsProcessingParameterType
1791{
1792 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1793 {
1794 return new QgsProcessingParameterNumber( name );
1795 }
1796
1797 QString description() const override
1798 {
1799 return QCoreApplication::translate( "Processing", "A numeric parameter, including float or integer values." );
1800 }
1801
1802 QString name() const override
1803 {
1804 return QCoreApplication::translate( "Processing", "Number" );
1805 }
1806
1807 QString id() const override
1808 {
1809 return QStringLiteral( "number" );
1810 }
1811
1812 QString pythonImportString() const override
1813 {
1814 return QStringLiteral( "from qgis.core import QgsProcessingParameterNumber" );
1815 }
1816
1817 QString className() const override
1818 {
1819 return QStringLiteral( "QgsProcessingParameterNumber" );
1820 }
1821
1822 QStringList acceptedPythonTypes() const override
1823 {
1824 return QStringList() << QStringLiteral( "int" )
1825 << QStringLiteral( "float" )
1826 << QStringLiteral( "QgsProperty" );
1827 }
1828
1829 QStringList acceptedStringValues() const override
1830 {
1831 return QStringList() << QObject::tr( "A numeric value" )
1832 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1833 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1834 }
1835
1836 QStringList acceptedParameterTypes() const override
1837 {
1838 return QStringList()
1839 << QgsProcessingParameterString::typeName()
1840 << QgsProcessingParameterNumber::typeName()
1841 << QgsProcessingParameterDistance::typeName()
1842 << QgsProcessingParameterVolume::typeName()
1843 << QgsProcessingParameterDuration::typeName()
1844 << QgsProcessingParameterScale::typeName();
1845 }
1846
1847 QStringList acceptedOutputTypes() const override
1848 {
1849 return QStringList() << QgsProcessingOutputNumber::typeName()
1850 << QgsProcessingOutputVariant::typeName()
1851 << QgsProcessingOutputString::typeName();
1852 }
1853
1854 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
1855};
1856
1864class CORE_EXPORT QgsProcessingParameterTypeDistance : public QgsProcessingParameterTypeNumber
1865{
1866 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1867 {
1868 return new QgsProcessingParameterDistance( name );
1869 }
1870
1871 QString description() const override
1872 {
1873 return QCoreApplication::translate( "Processing", "A numeric parameter representing a distance measure." );
1874 }
1875
1876 QString name() const override
1877 {
1878 return QCoreApplication::translate( "Processing", "Distance" );
1879 }
1880
1881 QString id() const override
1882 {
1883 return QStringLiteral( "distance" );
1884 }
1885
1886 QString pythonImportString() const override
1887 {
1888 return QStringLiteral( "from qgis.core import QgsProcessingParameterDistance" );
1889 }
1890
1891 QString className() const override
1892 {
1893 return QStringLiteral( "QgsProcessingParameterDistance" );
1894 }
1895
1896 QStringList acceptedPythonTypes() const override
1897 {
1898 return QStringList() << QStringLiteral( "int" )
1899 << QStringLiteral( "float" )
1900 << QStringLiteral( "QgsProperty" );
1901 }
1902
1903 QStringList acceptedStringValues() const override
1904 {
1905 return QStringList() << QObject::tr( "A numeric value" )
1906 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1907 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1908 }
1909
1910 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
1911};
1912
1913
1921class CORE_EXPORT QgsProcessingParameterTypeArea : public QgsProcessingParameterTypeNumber
1922{
1923 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1924 {
1925 return new QgsProcessingParameterArea( name );
1926 }
1927
1928 QString description() const override
1929 {
1930 return QCoreApplication::translate( "Processing", "A numeric parameter representing an area measure." );
1931 }
1932
1933 QString name() const override
1934 {
1935 return QCoreApplication::translate( "Processing", "Area" );
1936 }
1937
1938 QString id() const override
1939 {
1940 return QStringLiteral( "area" );
1941 }
1942
1943 QString pythonImportString() const override
1944 {
1945 return QStringLiteral( "from qgis.core import QgsProcessingParameterArea" );
1946 }
1947
1948 QString className() const override
1949 {
1950 return QStringLiteral( "QgsProcessingParameterArea" );
1951 }
1952
1953 QStringList acceptedPythonTypes() const override
1954 {
1955 return QStringList() << QStringLiteral( "int" )
1956 << QStringLiteral( "float" )
1957 << QStringLiteral( "QgsProperty" );
1958 }
1959
1960 QStringList acceptedStringValues() const override
1961 {
1962 return QStringList() << QObject::tr( "A numeric value" )
1963 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
1964 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
1965 }
1966};
1967
1968
1976class CORE_EXPORT QgsProcessingParameterTypeVolume : public QgsProcessingParameterTypeNumber
1977{
1978 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1979 {
1980 return new QgsProcessingParameterVolume( name );
1981 }
1982
1983 QString description() const override
1984 {
1985 return QCoreApplication::translate( "Processing", "A numeric parameter representing a volume measure." );
1986 }
1987
1988 QString name() const override
1989 {
1990 return QCoreApplication::translate( "Processing", "Volume" );
1991 }
1992
1993 QString id() const override
1994 {
1995 return QStringLiteral( "volume" );
1996 }
1997
1998 QString pythonImportString() const override
1999 {
2000 return QStringLiteral( "from qgis.core import QgsProcessingParameterVolume" );
2001 }
2002
2003 QString className() const override
2004 {
2005 return QStringLiteral( "QgsProcessingParameterVolume" );
2006 }
2007
2008 QStringList acceptedPythonTypes() const override
2009 {
2010 return QStringList() << QStringLiteral( "int" )
2011 << QStringLiteral( "float" )
2012 << QStringLiteral( "QgsProperty" );
2013 }
2014
2015 QStringList acceptedStringValues() const override
2016 {
2017 return QStringList() << QObject::tr( "A numeric value" )
2018 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2019 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2020 }
2021};
2022
2023
2024
2032class CORE_EXPORT QgsProcessingParameterTypeDuration : public QgsProcessingParameterTypeNumber
2033{
2034 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2035 {
2036 return new QgsProcessingParameterDuration( name );
2037 }
2038
2039 QString description() const override
2040 {
2041 return QCoreApplication::translate( "Processing", "A numeric parameter representing a duration measure." );
2042 }
2043
2044 QString name() const override
2045 {
2046 return QCoreApplication::translate( "Processing", "Duration" );
2047 }
2048
2049 QString id() const override
2050 {
2051 return QStringLiteral( "duration" );
2052 }
2053
2054 QString pythonImportString() const override
2055 {
2056 return QStringLiteral( "from qgis.core import QgsProcessingParameterDuration" );
2057 }
2058
2059 QString className() const override
2060 {
2061 return QStringLiteral( "QgsProcessingParameterDuration" );
2062 }
2063
2064 QStringList acceptedPythonTypes() const override
2065 {
2066 return QStringList() << QStringLiteral( "int" )
2067 << QStringLiteral( "float" )
2068 << QStringLiteral( "QgsProperty" );
2069 }
2070
2071 QStringList acceptedStringValues() const override
2072 {
2073 return QStringList() << QObject::tr( "A numeric value (unit type set by algorithms)" )
2074 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2075 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2076 }
2077
2078 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
2079};
2080
2088class CORE_EXPORT QgsProcessingParameterTypeScale : public QgsProcessingParameterTypeNumber
2089{
2090 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2091 {
2092 return new QgsProcessingParameterScale( name );
2093 }
2094
2095 QString description() const override
2096 {
2097 return QCoreApplication::translate( "Processing", "A numeric parameter representing a map scale." );
2098 }
2099
2100 QString name() const override
2101 {
2102 return QCoreApplication::translate( "Processing", "Scale" );
2103 }
2104
2105 QString id() const override
2106 {
2107 return QStringLiteral( "scale" );
2108 }
2109
2110 QString pythonImportString() const override
2111 {
2112 return QStringLiteral( "from qgis.core import QgsProcessingParameterScale" );
2113 }
2114
2115 QString className() const override
2116 {
2117 return QStringLiteral( "QgsProcessingParameterScale" );
2118 }
2119
2120 QStringList acceptedPythonTypes() const override
2121 {
2122 return QStringList() << QStringLiteral( "int: scale denominator" )
2123 << QStringLiteral( "float: scale denominator" )
2124 << QStringLiteral( "QgsProperty" );
2125 }
2126
2127 QStringList acceptedStringValues() const override
2128 {
2129 return QStringList() << QObject::tr( "A numeric value representing the scale denominator" );
2130 }
2131
2132 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
2133};
2134
2142class CORE_EXPORT QgsProcessingParameterTypeBand : public QgsProcessingParameterType
2143{
2144 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2145 {
2146 return new QgsProcessingParameterBand( name );
2147 }
2148
2149 QString description() const override
2150 {
2151 return QCoreApplication::translate( "Processing", "A raster band parameter, for selecting an existing band from a raster source." );
2152 }
2153
2154 QString name() const override
2155 {
2156 return QCoreApplication::translate( "Processing", "Raster Band" );
2157 }
2158
2159 QString id() const override
2160 {
2161 return QStringLiteral( "band" );
2162 }
2163
2164 QString pythonImportString() const override
2165 {
2166 return QStringLiteral( "from qgis.core import QgsProcessingParameterBand" );
2167 }
2168
2169 QString className() const override
2170 {
2171 return QStringLiteral( "QgsProcessingParameterBand" );
2172 }
2173
2174 QStringList acceptedPythonTypes() const override
2175 {
2176 return QStringList() << QStringLiteral( "int" )
2177 << QStringLiteral( "QgsProperty" );
2178 }
2179
2180 QStringList acceptedStringValues() const override
2181 {
2182 return QStringList() << QObject::tr( "Integer value representing an existing raster band number" );
2183 }
2184
2185 QStringList acceptedParameterTypes() const override
2186 {
2187 return QStringList()
2188 << QgsProcessingParameterBand::typeName()
2189 << QgsProcessingParameterNumber::typeName();
2190 }
2191
2192 QStringList acceptedOutputTypes() const override
2193 {
2194 return QStringList()
2195 << QgsProcessingOutputNumber::typeName()
2196 << QgsProcessingOutputVariant::typeName();
2197 }
2198};
2199
2207class CORE_EXPORT QgsProcessingParameterTypeFeatureSink : public QgsProcessingParameterTypeDestination
2208{
2209 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2210 {
2211 return new QgsProcessingParameterFeatureSink( name );
2212 }
2213
2214 Qgis::ProcessingParameterTypeFlags flags() const override
2215 {
2216 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
2217 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
2218 return flags;
2219 }
2220
2221 QString description() const override
2222 {
2223 return QCoreApplication::translate( "Processing", "A feature sink destination parameter." );
2224 }
2225
2226 QString name() const override
2227 {
2228 return QCoreApplication::translate( "Processing", "Feature Sink" );
2229 }
2230
2231 QString id() const override
2232 {
2233 return QStringLiteral( "sink" );
2234 }
2235
2236 QString pythonImportString() const override
2237 {
2238 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSink" );
2239 }
2240
2241 QString className() const override
2242 {
2243 return QStringLiteral( "QgsProcessingParameterFeatureSink" );
2244 }
2245
2246 QStringList acceptedPythonTypes() const override
2247 {
2248 return QStringList() << QObject::tr( "str: destination vector file, e.g. 'd:/test.shp'" )
2249 << QObject::tr( "str: 'memory:' to store result in temporary memory layer" )
2250 << QObject::tr( "str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table" )
2251 << QStringLiteral( "QgsProcessingOutputLayerDefinition" )
2252 << QStringLiteral( "QgsProperty" );
2253 }
2254
2255 QStringList acceptedStringValues() const override
2256 {
2257 return QStringList() << QObject::tr( "Path for new vector layer" );
2258 }
2259
2260 QColor modelColor() const override { return QColor( 122, 0, 47 ); /* burgundy */ };
2261};
2262
2270class CORE_EXPORT QgsProcessingParameterTypeLayout : public QgsProcessingParameterType
2271{
2272 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2273 {
2274 return new QgsProcessingParameterLayout( name );
2275 }
2276
2277 QString description() const override
2278 {
2279 return QCoreApplication::translate( "Processing", "A print layout parameter." );
2280 }
2281
2282 QString name() const override
2283 {
2284 return QCoreApplication::translate( "Processing", "Print Layout" );
2285 }
2286
2287 QString id() const override
2288 {
2289 return QStringLiteral( "layout" );
2290 }
2291
2292 QString pythonImportString() const override
2293 {
2294 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayout" );
2295 }
2296
2297 QString className() const override
2298 {
2299 return QStringLiteral( "QgsProcessingParameterLayout" );
2300 }
2301
2302 QStringList acceptedPythonTypes() const override
2303 {
2304 return QStringList() << QObject::tr( "str: name of print layout in current project" )
2305 << QStringLiteral( "QgsProperty" );
2306 }
2307
2308 QStringList acceptedStringValues() const override
2309 {
2310 return QStringList() << QObject::tr( "Name of print layout in current project" );
2311 }
2312
2313 QStringList acceptedParameterTypes() const override
2314 {
2315 return QStringList()
2316 << QgsProcessingParameterLayout::typeName()
2317 << QgsProcessingParameterString::typeName();
2318 }
2319
2320 QStringList acceptedOutputTypes() const override
2321 {
2322 return QStringList()
2323 << QgsProcessingOutputString::typeName()
2324 << QgsProcessingOutputVariant::typeName();
2325 }
2326};
2327
2335class CORE_EXPORT QgsProcessingParameterTypeLayoutItem : public QgsProcessingParameterType
2336{
2337 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2338 {
2339 return new QgsProcessingParameterLayoutItem( name );
2340 }
2341
2342 QString description() const override
2343 {
2344 return QCoreApplication::translate( "Processing", "A print layout item parameter." );
2345 }
2346
2347 QString name() const override
2348 {
2349 return QCoreApplication::translate( "Processing", "Print Layout Item" );
2350 }
2351
2352 QString id() const override
2353 {
2354 return QStringLiteral( "layoutitem" );
2355 }
2356
2357 QString pythonImportString() const override
2358 {
2359 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayoutItem" );
2360 }
2361
2362 QString className() const override
2363 {
2364 return QStringLiteral( "QgsProcessingParameterLayoutItem" );
2365 }
2366
2367 QStringList acceptedPythonTypes() const override
2368 {
2369 return QStringList() << QObject::tr( "str: UUID of print layout item" )
2370 << QObject::tr( "str: id of print layout item" )
2371 << QStringLiteral( "QgsProperty" );
2372 }
2373
2374 QStringList acceptedStringValues() const override
2375 {
2376 return QStringList() << QObject::tr( "UUID or item id of layout item" );
2377 }
2378
2379 QStringList acceptedParameterTypes() const override
2380 {
2381 return QStringList()
2382 << QgsProcessingParameterLayoutItem::typeName()
2383 << QgsProcessingParameterString::typeName();
2384 }
2385
2386 QStringList acceptedOutputTypes() const override
2387 {
2388 return QStringList()
2389 << QgsProcessingOutputString::typeName()
2390 << QgsProcessingOutputVariant::typeName();
2391 }
2392};
2393
2401class CORE_EXPORT QgsProcessingParameterTypeColor : public QgsProcessingParameterType
2402{
2403 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2404 {
2405 return new QgsProcessingParameterColor( name );
2406 }
2407
2408 QString description() const override
2409 {
2410 return QCoreApplication::translate( "Processing", "A color parameter." );
2411 }
2412
2413 QString name() const override
2414 {
2415 return QCoreApplication::translate( "Processing", "Color" );
2416 }
2417
2418 QString id() const override
2419 {
2420 return QStringLiteral( "color" );
2421 }
2422
2423 QString pythonImportString() const override
2424 {
2425 return QStringLiteral( "from qgis.core import QgsProcessingParameterColor" );
2426 }
2427
2428 QString className() const override
2429 {
2430 return QStringLiteral( "QgsProcessingParameterColor" );
2431 }
2432
2433 QStringList acceptedPythonTypes() const override
2434 {
2435 return QStringList() << QObject::tr( "str: string representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
2436 << QStringLiteral( "QColor" )
2437 << QStringLiteral( "QgsProperty" );
2438 }
2439
2440 QStringList acceptedStringValues() const override
2441 {
2442 return QStringList() << QObject::tr( "String representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
2443 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2444 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2445 }
2446
2447 QStringList acceptedParameterTypes() const override
2448 {
2449 return QStringList()
2450 << QgsProcessingParameterColor::typeName()
2451 << QgsProcessingParameterString::typeName();
2452 }
2453
2454 QStringList acceptedOutputTypes() const override
2455 {
2456 return QStringList()
2457 << QgsProcessingOutputString::typeName()
2458 << QgsProcessingOutputVariant::typeName();
2459 }
2460
2461 QColor modelColor() const override { return QColor( 34, 157, 214 ); /* blue */ };
2462};
2463
2471class CORE_EXPORT QgsProcessingParameterTypeCoordinateOperation : public QgsProcessingParameterType
2472{
2473 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2474 {
2475 return new QgsProcessingParameterCoordinateOperation( name );
2476 }
2477
2478 QString description() const override
2479 {
2480 return QCoreApplication::translate( "Processing", "A coordinate operation parameter." );
2481 }
2482
2483 QString name() const override
2484 {
2485 return QCoreApplication::translate( "Processing", "Coordinate Operation" );
2486 }
2487
2488 QString id() const override
2489 {
2490 return QStringLiteral( "coordinateoperation" );
2491 }
2492
2493 QString pythonImportString() const override
2494 {
2495 return QStringLiteral( "from qgis.core import QgsProcessingParameterCoordinateOperation" );
2496 }
2497
2498 QString className() const override
2499 {
2500 return QStringLiteral( "QgsProcessingParameterCoordinateOperation" );
2501 }
2502
2503 QStringList acceptedPythonTypes() const override
2504 {
2505 return QStringList() << QObject::tr( "str: string representation of a Proj coordinate operation" );
2506 }
2507
2508 QStringList acceptedStringValues() const override
2509 {
2510 return QStringList() << QObject::tr( "String representation of Proj coordinate operation" );
2511 }
2512
2513 QStringList acceptedParameterTypes() const override
2514 {
2515 return QStringList()
2516 << QgsProcessingParameterCoordinateOperation::typeName()
2517 << QgsProcessingParameterString::typeName();
2518 }
2519
2520 QStringList acceptedOutputTypes() const override
2521 {
2522 return QStringList()
2523 << QgsProcessingOutputString::typeName()
2524 << QgsProcessingOutputVariant::typeName();
2525 }
2526};
2527
2535class CORE_EXPORT QgsProcessingParameterTypeMapTheme: public QgsProcessingParameterType
2536{
2537 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2538 {
2539 return new QgsProcessingParameterMapTheme( name );
2540 }
2541
2542 QString description() const override
2543 {
2544 return QCoreApplication::translate( "Processing", "A map theme parameter." );
2545 }
2546
2547 QString name() const override
2548 {
2549 return QCoreApplication::translate( "Processing", "Map Theme" );
2550 }
2551
2552 QString id() const override
2553 {
2554 return QStringLiteral( "maptheme" );
2555 }
2556
2557 QString pythonImportString() const override
2558 {
2559 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapTheme" );
2560 }
2561
2562 QString className() const override
2563 {
2564 return QStringLiteral( "QgsProcessingParameterMapTheme" );
2565 }
2566
2567 QStringList acceptedPythonTypes() const override
2568 {
2569 return QStringList() << QObject::tr( "str: name of an existing map theme" )
2570 << QStringLiteral( "QgsProperty" );
2571 }
2572
2573 QStringList acceptedStringValues() const override
2574 {
2575 return QStringList() << QObject::tr( "Name of an existing map theme" );
2576 }
2577
2578 QStringList acceptedParameterTypes() const override
2579 {
2580 return QStringList()
2581 << QgsProcessingParameterString::typeName()
2582 << QgsProcessingParameterExpression::typeName();
2583 }
2584
2585 QStringList acceptedOutputTypes() const override
2586 {
2587 return QStringList()
2588 << QgsProcessingOutputString::typeName()
2589 << QgsProcessingOutputVariant::typeName();
2590 }
2591};
2592
2600class CORE_EXPORT QgsProcessingParameterTypeDateTime : public QgsProcessingParameterType
2601{
2602 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2603 {
2604 return new QgsProcessingParameterDateTime( name );
2605 }
2606
2607 QString description() const override
2608 {
2609 return QCoreApplication::translate( "Processing", "A datetime parameter, including datetime, date or time values." );
2610 }
2611
2612 QString name() const override
2613 {
2614 return QCoreApplication::translate( "Processing", "Datetime" );
2615 }
2616
2617 QString id() const override
2618 {
2619 return QStringLiteral( "datetime" );
2620 }
2621
2622 QString pythonImportString() const override
2623 {
2624 return QStringLiteral( "from qgis.core import QgsProcessingParameterDateTime" );
2625 }
2626
2627 QString className() const override
2628 {
2629 return QStringLiteral( "QgsProcessingParameterDateTime" );
2630 }
2631
2632 QStringList acceptedPythonTypes() const override
2633 {
2634 return QStringList() << QStringLiteral( "str" )
2635 << QStringLiteral( "QDateTime" )
2636 << QStringLiteral( "QDate" )
2637 << QStringLiteral( "QTime" )
2638 << QStringLiteral( "QgsProperty" );
2639 }
2640
2641 QStringList acceptedStringValues() const override
2642 {
2643 return QStringList() << QObject::tr( "A datetime value in ISO format" )
2644 << QObject::tr( "field:FIELD_NAME to use a data defined value taken from the FIELD_NAME field" )
2645 << QObject::tr( "expression:SOME EXPRESSION to use a data defined value calculated using a custom QGIS expression" );
2646 }
2647
2648 QStringList acceptedParameterTypes() const override
2649 {
2650 return QStringList()
2651 << QgsProcessingParameterDateTime::typeName()
2652 << QgsProcessingParameterString::typeName();
2653 }
2654
2655 QStringList acceptedOutputTypes() const override
2656 {
2657 return QStringList()
2658 << QgsProcessingOutputString::typeName()
2659 << QgsProcessingOutputVariant::typeName();
2660 }
2661
2662 QColor modelColor() const override { return QColor( 255, 131, 23 ); /* orange */ };
2663};
2664
2672class CORE_EXPORT QgsProcessingParameterTypeProviderConnection : public QgsProcessingParameterType
2673{
2674 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2675 {
2676 return new QgsProcessingParameterProviderConnection( name, QString(), QString() );
2677 }
2678
2679 QString description() const override
2680 {
2681 return QCoreApplication::translate( "Processing", "A connection name parameter, for registered database connections." );
2682 }
2683
2684 QString name() const override
2685 {
2686 return QCoreApplication::translate( "Processing", "Connection Name" );
2687 }
2688
2689 QString id() const override
2690 {
2691 return QStringLiteral( "providerconnection" );
2692 }
2693
2694 QString pythonImportString() const override
2695 {
2696 return QStringLiteral( "from qgis.core import QgsProcessingParameterProviderConnection" );
2697 }
2698
2699 QString className() const override
2700 {
2701 return QStringLiteral( "QgsProcessingParameterProviderConnection" );
2702 }
2703
2704 QStringList acceptedPythonTypes() const override
2705 {
2706 return QStringList() << QStringLiteral( "str" )
2707 << QStringLiteral( "QgsProperty" );
2708 }
2709
2710 QStringList acceptedStringValues() const override
2711 {
2712 return QStringList() << QObject::tr( "Name of registered database connection" );
2713 }
2714
2715 QStringList acceptedParameterTypes() const override
2716 {
2717 return QStringList()
2718 << QgsProcessingParameterProviderConnection::typeName()
2719 << QgsProcessingParameterString::typeName()
2720 << QgsProcessingParameterExpression::typeName();
2721 }
2722
2723 QStringList acceptedOutputTypes() const override
2724 {
2725 return QStringList()
2726 << QgsProcessingOutputString::typeName()
2727 << QgsProcessingOutputVariant::typeName();
2728 }
2729};
2730
2738class CORE_EXPORT QgsProcessingParameterTypeDatabaseSchema : public QgsProcessingParameterType
2739{
2740 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2741 {
2742 return new QgsProcessingParameterDatabaseSchema( name, QString(), QString() );
2743 }
2744
2745 QString description() const override
2746 {
2747 return QCoreApplication::translate( "Processing", "A database schema parameter." );
2748 }
2749
2750 QString name() const override
2751 {
2752 return QCoreApplication::translate( "Processing", "Database Schema" );
2753 }
2754
2755 QString id() const override
2756 {
2757 return QStringLiteral( "databaseschema" );
2758 }
2759
2760 QString pythonImportString() const override
2761 {
2762 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseSchema" );
2763 }
2764
2765 QString className() const override
2766 {
2767 return QStringLiteral( "QgsProcessingParameterDatabaseSchema" );
2768 }
2769
2770 QStringList acceptedPythonTypes() const override
2771 {
2772 return QStringList() << QStringLiteral( "str" )
2773 << QStringLiteral( "QgsProperty" );
2774 }
2775
2776 QStringList acceptedStringValues() const override
2777 {
2778 return QStringList() << QObject::tr( "Name of existing database schema" );
2779 }
2780
2781 QStringList acceptedParameterTypes() const override
2782 {
2783 return QStringList()
2784 << QgsProcessingParameterDatabaseSchema::typeName()
2785 << QgsProcessingParameterString::typeName()
2786 << QgsProcessingParameterExpression::typeName();
2787 }
2788
2789 QStringList acceptedOutputTypes() const override
2790 {
2791 return QStringList()
2792 << QgsProcessingOutputString::typeName()
2793 << QgsProcessingOutputVariant::typeName();
2794 }
2795};
2796
2804class CORE_EXPORT QgsProcessingParameterTypeDatabaseTable: public QgsProcessingParameterType
2805{
2806 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2807 {
2808 return new QgsProcessingParameterDatabaseTable( name, QString(), QString(), QString() );
2809 }
2810
2811 QString description() const override
2812 {
2813 return QCoreApplication::translate( "Processing", "A database table parameter." );
2814 }
2815
2816 QString name() const override
2817 {
2818 return QCoreApplication::translate( "Processing", "Database Table" );
2819 }
2820
2821 QString id() const override
2822 {
2823 return QStringLiteral( "databasetable" );
2824 }
2825
2826 QString pythonImportString() const override
2827 {
2828 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseTable" );
2829 }
2830
2831 QString className() const override
2832 {
2833 return QStringLiteral( "QgsProcessingParameterDatabaseTable" );
2834 }
2835
2836 QStringList acceptedPythonTypes() const override
2837 {
2838 return QStringList() << QStringLiteral( "str" )
2839 << QStringLiteral( "QgsProperty" );
2840 }
2841
2842 QStringList acceptedStringValues() const override
2843 {
2844 return QStringList() << QObject::tr( "Name of existing database table" );
2845 }
2846
2847 QStringList acceptedParameterTypes() const override
2848 {
2849 return QStringList()
2850 << QgsProcessingParameterDatabaseTable::typeName()
2851 << QgsProcessingParameterString::typeName()
2852 << QgsProcessingParameterExpression::typeName();
2853 }
2854
2855 QStringList acceptedOutputTypes() const override
2856 {
2857 return QStringList()
2858 << QgsProcessingOutputString::typeName()
2859 << QgsProcessingOutputVariant::typeName();
2860 }
2861};
2862
2870class CORE_EXPORT QgsProcessingParameterTypePointCloudLayer : public QgsProcessingParameterType
2871{
2872 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2873 {
2874 return new QgsProcessingParameterPointCloudLayer( name );
2875 }
2876
2877 QString description() const override
2878 {
2879 return QCoreApplication::translate( "Processing", "A point cloud layer parameter." );
2880 }
2881
2882 QString name() const override
2883 {
2884 return QCoreApplication::translate( "Processing", "Point Cloud Layer" );
2885 }
2886
2887 QString pythonImportString() const override
2888 {
2889 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudLayer" );
2890 }
2891
2892 QString className() const override
2893 {
2894 return QStringLiteral( "QgsProcessingParameterPointCloudLayer" );
2895 }
2896
2897 QString id() const override
2898 {
2899 return QStringLiteral( "pointcloud" );
2900 }
2901
2902 QStringList acceptedPythonTypes() const override
2903 {
2904 return QStringList() << QObject::tr( "str: layer ID" )
2905 << QObject::tr( "str: layer name" )
2906 << QObject::tr( "str: layer source" )
2907 << QStringLiteral( "QgsPointCloudLayer" );
2908 }
2909
2910 QStringList acceptedStringValues() const override
2911 {
2912 return QStringList() << QObject::tr( "Path to a point cloud layer" );
2913 }
2914
2915 QStringList acceptedParameterTypes() const override
2916 {
2917 return QStringList()
2918 << QgsProcessingParameterPointCloudLayer::typeName()
2919 << QgsProcessingParameterMapLayer::typeName()
2920 << QgsProcessingParameterString::typeName()
2921 << QgsProcessingParameterExpression::typeName();
2922 }
2923
2924 QStringList acceptedOutputTypes() const override
2925 {
2926 return QStringList()
2927 << QgsProcessingOutputString::typeName()
2928 << QgsProcessingOutputPointCloudLayer::typeName()
2929 << QgsProcessingOutputMapLayer::typeName()
2930 << QgsProcessingOutputFile::typeName()
2931 << QgsProcessingOutputFolder::typeName();
2932 }
2933
2934 QColor modelColor() const override { return QColor( 137, 150, 171 ); /* cold gray */ };
2935};
2936
2944class CORE_EXPORT QgsProcessingParameterTypeAnnotationLayer : public QgsProcessingParameterType
2945{
2946 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2947 {
2948 return new QgsProcessingParameterAnnotationLayer( name );
2949 }
2950
2951 QString description() const override
2952 {
2953 return QCoreApplication::translate( "Processing", "An annotation layer parameter." );
2954 }
2955
2956 QString name() const override
2957 {
2958 return QCoreApplication::translate( "Processing", "Annotation Layer" );
2959 }
2960
2961 QString pythonImportString() const override
2962 {
2963 return QStringLiteral( "from qgis.core import QgsProcessingParameterAnnotationLayer" );
2964 }
2965
2966 QString className() const override
2967 {
2968 return QStringLiteral( "QgsProcessingParameterAnnotationLayer" );
2969 }
2970
2971 QString id() const override
2972 {
2973 return QStringLiteral( "annotation" );
2974 }
2975
2976 QStringList acceptedPythonTypes() const override
2977 {
2978 return QStringList() << QObject::tr( "str: layer ID" )
2979 << QObject::tr( "str: layer name" )
2980 << QObject::tr( "\"main\": main annotation layer for a project" )
2981 << QStringLiteral( "QgsAnnotationLayer" );
2982 }
2983
2984 QStringList acceptedStringValues() const override
2985 {
2986 return QStringList() << QObject::tr( "Layer ID for an annotation layer, or \"main\" for the main annotation layer in a project." );
2987 }
2988
2989 QStringList acceptedParameterTypes() const override
2990 {
2991 return QStringList()
2992 << QgsProcessingParameterAnnotationLayer::typeName()
2993 << QgsProcessingParameterMapLayer::typeName()
2994 << QgsProcessingParameterString::typeName()
2995 << QgsProcessingParameterExpression::typeName();
2996 }
2997
2998 QStringList acceptedOutputTypes() const override
2999 {
3000 return QStringList()
3001 << QgsProcessingOutputString::typeName()
3002 << QgsProcessingOutputMapLayer::typeName()
3003 << QgsProcessingOutputVariant::typeName();
3004 }
3005
3006 QColor modelColor() const override { return QColor( 137, 150, 171 ); /* cold gray */ };
3007};
3008
3017class CORE_EXPORT QgsProcessingParameterTypePointCloudDestination : public QgsProcessingParameterTypeDestination
3018{
3019 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
3020 {
3021 return new QgsProcessingParameterPointCloudDestination( name );
3022 }
3023
3024 QString description() const override
3025 {
3026 return QCoreApplication::translate( "Processing", "A point cloud layer destination parameter." );
3027 }
3028
3029 QString name() const override
3030 {
3031 return QCoreApplication::translate( "Processing", "Point Cloud Destination" );
3032 }
3033
3034 QString id() const override
3035 {
3036 return QStringLiteral( "pointCloudDestination" );
3037 }
3038
3039 QString pythonImportString() const override
3040 {
3041 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudDestination" );
3042 }
3043
3044 QString className() const override
3045 {
3046 return QStringLiteral( "QgsProcessingParameterPointCloudDestination" );
3047 }
3048
3049 Qgis::ProcessingParameterTypeFlags flags() const override
3050 {
3051 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
3052 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
3053 return flags;
3054 }
3055
3056 QStringList acceptedPythonTypes() const override
3057 {
3058 return QStringList() << QStringLiteral( "str" )
3059 << QStringLiteral( "QgsProperty" )
3060 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
3061 }
3062
3063 QStringList acceptedStringValues() const override
3064 {
3065 return QStringList() << QObject::tr( "Path for new point cloud layer" );
3066 }
3067
3068 QColor modelColor() const override { return QColor( 80, 80, 80 ); /* dark gray */ };
3069};
3070
3078class CORE_EXPORT QgsProcessingParameterTypePointCloudAttribute : public QgsProcessingParameterType
3079{
3080 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
3081 {
3082 return new QgsProcessingParameterPointCloudAttribute( name );
3083 }
3084
3085 QString description() const override
3086 {
3087 return QCoreApplication::translate( "Processing", "A point cloud attribute parameter, for selecting an attribute from a point cloud source." );
3088 }
3089
3090 QString name() const override
3091 {
3092 return QCoreApplication::translate( "Processing", "Point Cloud Attribute" );
3093 }
3094
3095 QString id() const override
3096 {
3097 return QStringLiteral( "attribute" );
3098 }
3099
3100 QString pythonImportString() const override
3101 {
3102 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudAttribute" );
3103 }
3104
3105 QString className() const override
3106 {
3107 return QStringLiteral( "QgsProcessingParameterPointCloudAttribute" );
3108 }
3109
3110 QStringList acceptedPythonTypes() const override
3111 {
3112 return QStringList() << QStringLiteral( "str" )
3113 << QStringLiteral( "QgsProperty" );
3114 }
3115
3116 QStringList acceptedStringValues() const override
3117 {
3118 return QStringList() << QObject::tr( "The name of an attribute" )
3119 << QObject::tr( "; delimited list of attribute names" );
3120 }
3121
3122 QStringList acceptedParameterTypes() const override
3123 {
3124 return QStringList()
3125 << QgsProcessingParameterPointCloudAttribute::typeName()
3126 << QgsProcessingParameterString::typeName();
3127 }
3128
3129 QStringList acceptedOutputTypes() const override
3130 {
3131 return QStringList()
3132 << QgsProcessingOutputString::typeName()
3133 << QgsProcessingOutputVariant::typeName();
3134 }
3135};
3136
3145class CORE_EXPORT QgsProcessingParameterTypeVectorTileDestination : public QgsProcessingParameterTypeDestination
3146{
3147 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
3148 {
3149 return new QgsProcessingParameterVectorTileDestination( name );
3150 }
3151
3152 QString description() const override
3153 {
3154 return QCoreApplication::translate( "Processing", "A vector tiles layer destination parameter." );
3155 }
3156
3157 QString name() const override
3158 {
3159 return QCoreApplication::translate( "Processing", "Vector Tile Destination" );
3160 }
3161
3162 QString id() const override
3163 {
3164 return QStringLiteral( "vectorTileDestination" );
3165 }
3166
3167 QString pythonImportString() const override
3168 {
3169 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorTileDestination" );
3170 }
3171
3172 QString className() const override
3173 {
3174 return QStringLiteral( "QgsProcessingParameterVectorTileDestination" );
3175 }
3176
3177 Qgis::ProcessingParameterTypeFlags flags() const override
3178 {
3179 Qgis::ProcessingParameterTypeFlags flags = QgsProcessingParameterType::flags();
3180 flags.setFlag( Qgis::ProcessingParameterTypeFlag::ExposeToModeler, false );
3181 return flags;
3182 }
3183
3184 QStringList acceptedPythonTypes() const override
3185 {
3186 return QStringList() << QStringLiteral( "str" )
3187 << QStringLiteral( "QgsProperty" )
3188 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
3189 }
3190
3191 QStringList acceptedStringValues() const override
3192 {
3193 return QStringList() << QObject::tr( "Path for new vector tile layer" );
3194 }
3195
3196 QColor modelColor() const override { return QColor( 80, 80, 80 ); /* dark gray */ };
3197};
3198
3199#endif // QGSPROCESSINGPARAMETERTYPEIMPL_H
Qgis::ProcessingParameterTypeFlag::ExposeToModeler
@ ExposeToModeler
Is this parameter available in the modeler. Is set to on by default.
Definition qgis.h:3737
Qgis::ProcessingParameterTypeFlags
QFlags< ProcessingParameterTypeFlag > ProcessingParameterTypeFlags
Flags which dictate the behavior of Processing parameter types.
Definition qgis.h:3751
QgsProcessingOutputBoolean::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:451
QgsProcessingOutputFile::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:498
QgsProcessingOutputFolder::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:474
QgsProcessingOutputMapLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:212
QgsProcessingOutputMultipleLayers::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:326
QgsProcessingOutputNumber::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:402
QgsProcessingOutputPointCloudLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:298
QgsProcessingOutputRasterLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:274
QgsProcessingOutputString::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:425
QgsProcessingOutputVariant::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:376
QgsProcessingOutputVectorLayer::typeName
static QString typeName()
Returns the type name for the output class.
Definition qgsprocessingoutputs.h:237
QgsProcessingParameterAnnotationLayer
An annotation layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:4686
QgsProcessingParameterAnnotationLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4698
QgsProcessingParameterArea
A double numeric parameter for area values.
Definition qgsprocessingparameters.h:2550
QgsProcessingParameterArea::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2566
QgsProcessingParameterAuthConfig
A string parameter for authentication configuration ID values.
Definition qgsprocessingparameters.h:3078
QgsProcessingParameterAuthConfig::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3090
QgsProcessingParameterBand
A raster band parameter for Processing algorithms.
Definition qgsprocessingparameters.h:3922
QgsProcessingParameterBand::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3936
QgsProcessingParameterBoolean
A boolean parameter for processing algorithms.
Definition qgsprocessingparameters.h:1890
QgsProcessingParameterBoolean::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1902
QgsProcessingParameterColor
A color parameter for processing algorithms.
Definition qgsprocessingparameters.h:4109
QgsProcessingParameterColor::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4124
QgsProcessingParameterCoordinateOperation
A coordinate operation parameter for processing algorithms.
Definition qgsprocessingparameters.h:4176
QgsProcessingParameterCoordinateOperation::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4190
QgsProcessingParameterCrs
A coordinate reference system parameter for processing algorithms.
Definition qgsprocessingparameters.h:1920
QgsProcessingParameterCrs::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1934
QgsProcessingParameterDatabaseSchema
A database schema parameter for processing algorithms, allowing users to select from existing schemas...
Definition qgsprocessingparameters.h:4494
QgsProcessingParameterDatabaseSchema::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4511
QgsProcessingParameterDatabaseTable
A database table name parameter for processing algorithms.
Definition qgsprocessingparameters.h:4558
QgsProcessingParameterDatabaseTable::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4580
QgsProcessingParameterDateTime
A datetime (or pure date or time) parameter for processing algorithms.
Definition qgsprocessingparameters.h:4326
QgsProcessingParameterDateTime::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4343
QgsProcessingParameterDefinition
Base class for the definition of processing parameters.
Definition qgsprocessingparameters.h:431
QgsProcessingParameterDistance
A double numeric parameter for distance values.
Definition qgsprocessingparameters.h:2463
QgsProcessingParameterDistance::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2479
QgsProcessingParameterDuration
A double numeric parameter for duration values.
Definition qgsprocessingparameters.h:2705
QgsProcessingParameterDuration::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2720
QgsProcessingParameterEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values.
Definition qgsprocessingparameters.h:2910
QgsProcessingParameterEnum::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2927
QgsProcessingParameterExpression
An expression parameter for processing algorithms.
Definition qgsprocessingparameters.h:3109
QgsProcessingParameterExpression::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3122
QgsProcessingParameterExtent
A rectangular map extent parameter for processing algorithms.
Definition qgsprocessingparameters.h:1955
QgsProcessingParameterExtent::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:1967
QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition qgsprocessingparameters.h:3598
QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3436
QgsProcessingParameterFeatureSource::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3449
QgsProcessingParameterField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparameters.h:3329
QgsProcessingParameterField::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3345
QgsProcessingParameterFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition qgsprocessingparameters.h:3827
QgsProcessingParameterFile
An input file or folder parameter for processing algorithms.
Definition qgsprocessingparameters.h:2099
QgsProcessingParameterFile::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2115
QgsProcessingParameterFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition qgsprocessingparameters.h:3888
QgsProcessingParameterGeometry
A geometry parameter for processing algorithms.
Definition qgsprocessingparameters.h:2030
QgsProcessingParameterGeometry::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2045
QgsProcessingParameterLayoutItem
A print layout item parameter, allowing users to select a particular item from a print layout.
Definition qgsprocessingparameters.h:4035
QgsProcessingParameterLayoutItem::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4049
QgsProcessingParameterLayout
A print layout parameter, allowing users to select a print layout.
Definition qgsprocessingparameters.h:3997
QgsProcessingParameterLayout::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4009
QgsProcessingParameterMapLayer
A map layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:3289
QgsProcessingParameterMapLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3302
QgsProcessingParameterMapTheme
A map theme parameter for processing algorithms, allowing users to select an existing map theme from ...
Definition qgsprocessingparameters.h:4283
QgsProcessingParameterMatrix
A table (matrix) parameter for processing algorithms.
Definition qgsprocessingparameters.h:2195
QgsProcessingParameterMatrix::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2209
QgsProcessingParameterMeshLayer
A mesh layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:3254
QgsProcessingParameterMeshLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3268
QgsProcessingParameterMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition qgsprocessingparameters.h:2281
QgsProcessingParameterMultipleLayers::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2294
QgsProcessingParameterNumber
A numeric parameter for processing algorithms.
Definition qgsprocessingparameters.h:2364
QgsProcessingParameterNumber::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2381
QgsProcessingParameterPointCloudAttribute
A point cloud layer attribute parameter for Processing algorithms.
Definition qgsprocessingparameters.h:4765
QgsProcessingParameterPointCloudAttribute::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4780
QgsProcessingParameterPointCloudDestination
A point cloud layer destination parameter, for specifying the destination path for a point cloud laye...
Definition qgsprocessingparameters.h:4720
QgsProcessingParameterPointCloudLayer
A point cloud layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:4651
QgsProcessingParameterPointCloudLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4663
QgsProcessingParameterPoint
A point parameter for processing algorithms.
Definition qgsprocessingparameters.h:1998
QgsProcessingParameterPoint::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2010
QgsProcessingParameterProviderConnection
A data provider connection parameter for processing algorithms, allowing users to select from availab...
Definition qgsprocessingparameters.h:4435
QgsProcessingParameterProviderConnection::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:4450
QgsProcessingParameterRange
A numeric range parameter for processing algorithms.
Definition qgsprocessingparameters.h:2795
QgsProcessingParameterRange::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2809
QgsProcessingParameterRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition qgsprocessingparameters.h:3767
QgsProcessingParameterRasterLayer
A raster layer parameter for processing algorithms.
Definition qgsprocessingparameters.h:2848
QgsProcessingParameterRasterLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2860
QgsProcessingParameterScale
A double numeric parameter for map scale values.
Definition qgsprocessingparameters.h:2762
QgsProcessingParameterScale::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2775
QgsProcessingParameterString
A string parameter for processing algorithms.
Definition qgsprocessingparameters.h:3018
QgsProcessingParameterString::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3031
QgsProcessingParameterTypeAnnotationLayer
An annotation layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2945
QgsProcessingParameterTypeArea
An area parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1922
QgsProcessingParameterTypeAuthConfig
An authentication configuration parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1567
QgsProcessingParameterTypeBand
A raster band parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2143
QgsProcessingParameterTypeBoolean
A boolean parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:352
QgsProcessingParameterTypeColor
A color parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2402
QgsProcessingParameterTypeCoordinateOperation
A coordinate operation parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2472
QgsProcessingParameterTypeCrs
A crs parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:519
QgsProcessingParameterTypeDatabaseSchema
A database schema name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2739
QgsProcessingParameterTypeDatabaseTable
A database table name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2805
QgsProcessingParameterTypeDateTime
A datetime parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2601
QgsProcessingParameterTypeDestination
A common generic type for destination parameter, for specifying the destination path for a vector lay...
Definition qgsprocessingparametertypeimpl.h:1176
QgsProcessingParameterTypeDistance
A distance parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1865
QgsProcessingParameterTypeDuration
A duration parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2033
QgsProcessingParameterTypeEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values.
Definition qgsprocessingparametertypeimpl.h:816
QgsProcessingParameterTypeExpression
An expression parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:445
QgsProcessingParameterTypeExtent
A rectangular map extent parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:887
QgsProcessingParameterTypeFeatureSink
A feature sink parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2208
QgsProcessingParameterTypeFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1706
QgsProcessingParameterTypeField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1109
QgsProcessingParameterTypeFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition qgsprocessingparametertypeimpl.h:1269
QgsProcessingParameterTypeFile
An input file or folder parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1038
QgsProcessingParameterTypeFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition qgsprocessingparametertypeimpl.h:1348
QgsProcessingParameterTypeGeometry
A geometry parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:746
QgsProcessingParameterTypeLayoutItem
A print layout item parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2336
QgsProcessingParameterTypeLayout
A print layout parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2271
QgsProcessingParameterTypeMapLayer
A generic map layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:270
QgsProcessingParameterTypeMapTheme
A map theme parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2536
QgsProcessingParameterTypeMatrix
A table (matrix) parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:973
QgsProcessingParameterTypeMeshLayer
A mesh layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:113
QgsProcessingParameterTypeMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition qgsprocessingparametertypeimpl.h:1631
QgsProcessingParameterTypeNumber
A numeric parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1791
QgsProcessingParameterTypePointCloudAttribute
A point cloud layer attribute parameter for Processing algorithms.
Definition qgsprocessingparametertypeimpl.h:3079
QgsProcessingParameterTypePointCloudDestination
A pointcloud layer destination parameter, for specifying the destination path for a point cloud layer...
Definition qgsprocessingparametertypeimpl.h:3018
QgsProcessingParameterTypePointCloudLayer
A point cloud layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2871
QgsProcessingParameterTypePoint
A point parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:676
QgsProcessingParameterTypeProviderConnection
A provider connection name parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2673
QgsProcessingParameterTypeRange
A numeric range parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:608
QgsProcessingParameterTypeRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition qgsprocessingparametertypeimpl.h:1424
QgsProcessingParameterTypeRasterLayer
A raster layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:37
QgsProcessingParameterTypeScale
A scale parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:2089
QgsProcessingParameterTypeString
A string parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1485
QgsProcessingParameterTypeVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition qgsprocessingparametertypeimpl.h:1207
QgsProcessingParameterTypeVectorLayer
A vector layer parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:187
QgsProcessingParameterTypeVectorTileDestination
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
Definition qgsprocessingparametertypeimpl.h:3146
QgsProcessingParameterTypeVolume
A volume parameter for processing algorithms.
Definition qgsprocessingparametertypeimpl.h:1977
QgsProcessingParameterType
Makes metadata of processing parameters available.
Definition qgsprocessingparametertype.h:35
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:35
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:50
QgsProcessingParameterType::modelColor
virtual QColor modelColor() const
Returns the color to use for the parameter in model designer windows.
Definition qgsprocessingparametertype.cpp:60
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:84
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:55
QgsProcessingParameterType::acceptedParameterTypes
virtual QStringList acceptedParameterTypes() const =0
Returns a list of compatible Processing parameter types for inputs for this parameter type.
Definition qgsprocessingparametertype.cpp:45
QgsProcessingParameterType::flags
virtual Qgis::ProcessingParameterTypeFlags flags() const
Determines if this parameter is available in the modeler.
Definition qgsprocessingparametertype.cpp:25
QgsProcessingParameterType::acceptedStringValues
virtual QStringList acceptedStringValues() const
Returns a descriptive list of the possible string values acceptable for the parameter.
Definition qgsprocessingparametertype.cpp:40
QgsProcessingParameterType::pythonImportString
virtual QString pythonImportString() const
Returns a valid Python import string for importing the corresponding parameter type,...
Definition qgsprocessingparametertype.h:74
QgsProcessingParameterVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition qgsprocessingparameters.h:3695
QgsProcessingParameterVectorLayer
A vector layer (with or without geometry) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3212
QgsProcessingParameterVectorLayer::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:3227
QgsProcessingParameterVectorTileDestination
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
Definition qgsprocessingparameters.h:4856
QgsProcessingParameterVolume
A double numeric parameter for volume values.
Definition qgsprocessingparameters.h:2634
QgsProcessingParameterVolume::typeName
static QString typeName()
Returns the type name for the parameter class.
Definition qgsprocessingparameters.h:2650
qgis_sip.h
SIP_FACTORY
#define SIP_FACTORY
Definition qgis_sip.h:84
Generated on for QGIS API Documentation by doxygen 1.15.0