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