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