QGIS API Documentation 3.29.0-Master (006c3c0232)
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
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"
24#include <QCoreApplication>
25
26#define SIP_NO_FILE
27
36{
37 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
38 {
39 return new QgsProcessingParameterRasterLayer( name );
40 }
41
42 QString description() const override
43 {
44 return QCoreApplication::translate( "Processing", "A raster layer parameter." );
45 }
46
47 QString name() const override
48 {
49 return QCoreApplication::translate( "Processing", "Raster Layer" );
50 }
51
52 QString pythonImportString() const override
53 {
54 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterLayer" );
55 }
56
57 QString className() const override
58 {
59 return QStringLiteral( "QgsProcessingParameterRasterLayer" );
60 }
61
62 QString id() const override
63 {
64 return QStringLiteral( "raster" );
65 }
66
67 QStringList acceptedPythonTypes() const override
68 {
69 return QStringList() << QObject::tr( "str: layer ID" )
70 << QObject::tr( "str: layer name" )
71 << QObject::tr( "str: layer source" )
72 << QStringLiteral( "QgsProperty" )
73 << QStringLiteral( "QgsRasterLayer" );
74 }
75
76 QStringList acceptedStringValues() const override
77 {
78 return QStringList() << QObject::tr( "Path to a raster layer" );
79 }
80};
81
90{
91 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
92 {
93 return new QgsProcessingParameterMeshLayer( name );
94 }
95
96 QString description() const override
97 {
98 return QCoreApplication::translate( "Processing", "A mesh layer parameter." );
99 }
100
101 QString name() const override
102 {
103 return QCoreApplication::translate( "Processing", "Mesh Layer" );
104 }
105
106 QString pythonImportString() const override
107 {
108 return QStringLiteral( "from qgis.core import QgsProcessingParameterMeshLayer" );
109 }
110
111 QString className() const override
112 {
113 return QStringLiteral( "QgsProcessingParameterMeshLayer" );
114 }
115
116 QString id() const override
117 {
118 return QStringLiteral( "mesh" );
119 }
120
121 QStringList acceptedPythonTypes() const override
122 {
123 return QStringList() << QObject::tr( "str: layer ID" )
124 << QObject::tr( "str: layer name" )
125 << QObject::tr( "str: layer source" )
126 << QStringLiteral( "QgsMeshLayer" );
127 }
128
129 QStringList acceptedStringValues() const override
130 {
131 return QStringList() << QObject::tr( "Path to a mesh layer" );
132 }
133};
134
143{
144 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
145 {
146 return new QgsProcessingParameterVectorLayer( name );
147 }
148
149 QString description() const override
150 {
151 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." );
152 }
153
154 QString name() const override
155 {
156 return QCoreApplication::translate( "Processing", "Vector Layer" );
157 }
158
159 QString pythonImportString() const override
160 {
161 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorLayer" );
162 }
163
164 QString className() const override
165 {
166 return QStringLiteral( "QgsProcessingParameterVectorLayer" );
167 }
168
169 QString id() const override
170 {
171 return QStringLiteral( "vector" );
172 }
173
174 QStringList acceptedPythonTypes() const override
175 {
176 return QStringList() << QObject::tr( "str: layer ID" )
177 << QObject::tr( "str: layer name" )
178 << QObject::tr( "str: layer source" )
179 << QStringLiteral( "QgsProperty" )
180 << QStringLiteral( "QgsVectorLayer" );
181 }
182
183 QStringList acceptedStringValues() const override
184 {
185 return QStringList() << QObject::tr( "Path to a vector layer" );
186 }
187};
188
197{
198 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
199 {
200 return new QgsProcessingParameterMapLayer( name );
201 }
202
203 QString description() const override
204 {
205 return QCoreApplication::translate( "Processing", "A generic map layer parameter, which accepts either vector or raster layers." );
206 }
207
208 QString name() const override
209 {
210 return QCoreApplication::translate( "Processing", "Map Layer" );
211 }
212
213 QString id() const override
214 {
215 return QStringLiteral( "layer" );
216 }
217
218 QString pythonImportString() const override
219 {
220 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapLayer" );
221 }
222
223 QString className() const override
224 {
225 return QStringLiteral( "QgsProcessingParameterMapLayer" );
226 }
227
228 QStringList acceptedPythonTypes() const override
229 {
230 return QStringList() << QObject::tr( "str: layer ID" )
231 << QObject::tr( "str: layer name" )
232 << QObject::tr( "str: layer source" )
233 << QStringLiteral( "QgsMapLayer" )
234 << QStringLiteral( "QgsProperty" )
235 << QStringLiteral( "QgsRasterLayer" )
236 << QStringLiteral( "QgsVectorLayer" );
237 }
238
239 QStringList acceptedStringValues() const override
240 {
241 return QStringList() << QObject::tr( "Path to a vector, raster or mesh layer" );
242 }
243};
244
253{
254 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
255 {
256 return new QgsProcessingParameterBoolean( name );
257 }
258
259 QString description() const override
260 {
261 return QCoreApplication::translate( "Processing", "A boolean parameter, for true/false values." );
262 }
263
264 QString name() const override
265 {
266 return QCoreApplication::translate( "Processing", "Boolean" );
267 }
268
269 QString id() const override
270 {
271 return QStringLiteral( "boolean" );
272 }
273
274 QString pythonImportString() const override
275 {
276 return QStringLiteral( "from qgis.core import QgsProcessingParameterBoolean" );
277 }
278
279 QString className() const override
280 {
281 return QStringLiteral( "QgsProcessingParameterBoolean" );
282 }
283
284 QStringList acceptedPythonTypes() const override
285 {
286 return QStringList() << QStringLiteral( "bool" )
287 << QStringLiteral( "int" )
288 << QStringLiteral( "str" )
289 << QStringLiteral( "QgsProperty" );
290 }
291
292 QStringList acceptedStringValues() const override
293 {
294 return QStringList() << QObject::tr( "1 for true/yes" )
295 << QObject::tr( "0 for false/no" );
296 }
297};
298
307{
308 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
309 {
310 return new QgsProcessingParameterExpression( name );
311 }
312
313 QString description() const override
314 {
315 return QCoreApplication::translate( "Processing", "An expression parameter, to add custom expressions based on layer fields." );
316 }
317
318 QString name() const override
319 {
320 return QCoreApplication::translate( "Processing", "Expression" );
321 }
322
323 QString id() const override
324 {
325 return QStringLiteral( "expression" );
326 }
327
328 QString pythonImportString() const override
329 {
330 return QStringLiteral( "from qgis.core import QgsProcessingParameterExpression" );
331 }
332
333 QString className() const override
334 {
335 return QStringLiteral( "QgsProcessingParameterExpression" );
336 }
337
338 QStringList acceptedPythonTypes() const override
339 {
340 return QStringList() << QStringLiteral( "str" )
341 << QStringLiteral( "QgsProperty" );
342 }
343
344 QStringList acceptedStringValues() const override
345 {
346 return QStringList() << QObject::tr( "A valid QGIS expression string, e.g \"road_name\" = 'MAIN RD'" );
347 }
348};
349
358{
359 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
360 {
361 return new QgsProcessingParameterCrs( name );
362 }
363
364 QString description() const override
365 {
366 return QCoreApplication::translate( "Processing", "A coordinate reference system (CRS) input parameter." );
367 }
368
369 QString name() const override
370 {
371 return QCoreApplication::translate( "Processing", "CRS" );
372 }
373
374 QString id() const override
375 {
376 return QStringLiteral( "crs" );
377 }
378
379 QString pythonImportString() const override
380 {
381 return QStringLiteral( "from qgis.core import QgsProcessingParameterCrs" );
382 }
383
384 QString className() const override
385 {
386 return QStringLiteral( "QgsProcessingParameterCrs" );
387 }
388
389 QStringList acceptedPythonTypes() const override
390 {
391 return QStringList()
392 << QStringLiteral( "str: 'ProjectCrs'" )
393 << QObject::tr( "str: CRS auth ID (e.g. 'EPSG:3111')" )
394 << QObject::tr( "str: CRS PROJ4 (e.g. 'PROJ4:…')" )
395 << QObject::tr( "str: CRS WKT (e.g. 'WKT:…')" )
396 << QObject::tr( "str: layer ID. CRS of layer is used." )
397 << QObject::tr( "str: layer name. CRS of layer is used." )
398 << QObject::tr( "str: layer source. CRS of layer is used." )
399 << QObject::tr( "QgsCoordinateReferenceSystem" )
400 << QObject::tr( "QgsMapLayer: CRS of layer is used" )
401 << QObject::tr( "QgsProcessingFeatureSourceDefinition: CRS of source is used" )
402 << QStringLiteral( "QgsProperty" );
403 }
404
405 QStringList acceptedStringValues() const override
406 {
407 return QStringList() << QObject::tr( "CRS as an auth ID (e.g. 'EPSG:3111')" )
408 << QObject::tr( "CRS as a PROJ4 string (e.g. 'PROJ4:…')" )
409 << QObject::tr( "CRS as a WKT string (e.g. 'WKT:…')" )
410 << QObject::tr( "Path to a layer. The CRS of the layer is used." ) ;
411 }
412};
413
422{
423 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
424 {
425 return new QgsProcessingParameterRange( name );
426 }
427
428 QString description() const override
429 {
430 return QCoreApplication::translate( "Processing", "A numeric range parameter for processing algorithms." );
431 }
432
433 QString name() const override
434 {
435 return QCoreApplication::translate( "Processing", "Range" );
436 }
437
438 QString id() const override
439 {
440 return QStringLiteral( "range" );
441 }
442
443 QString pythonImportString() const override
444 {
445 return QStringLiteral( "from qgis.core import QgsProcessingParameterRange" );
446 }
447
448 QString className() const override
449 {
450 return QStringLiteral( "QgsProcessingParameterRange" );
451 }
452
453 QStringList acceptedPythonTypes() const override
454 {
455 return QStringList() << QObject::tr( "list[float]: list of 2 float values" )
456 << QObject::tr( "list[str]: list of strings representing floats" )
457 << QObject::tr( "str: as two comma delimited floats, e.g. '1,10'" )
458 << QStringLiteral( "QgsProperty" );
459 }
460
461 QStringList acceptedStringValues() const override
462 {
463 return QStringList() << QObject::tr( "Two comma separated numeric values, e.g. '1,10'" );
464 }
465};
466
475{
476 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
477 {
478 return new QgsProcessingParameterPoint( name );
479 }
480
481 QString description() const override
482 {
483 return QCoreApplication::translate( "Processing", "A point geometry parameter." );
484 }
485
486 QString name() const override
487 {
488 return QCoreApplication::translate( "Processing", "Point" );
489 }
490
491 QString id() const override
492 {
493 return QStringLiteral( "point" );
494 }
495
496 QString pythonImportString() const override
497 {
498 return QStringLiteral( "from qgis.core import QgsProcessingParameterPoint" );
499 }
500
501 QString className() const override
502 {
503 return QStringLiteral( "QgsProcessingParameterPoint" );
504 }
505
506 QStringList acceptedPythonTypes() const override
507 {
508 return QStringList() << QObject::tr( "str: as an 'x,y' string, e.g. '1.5,10.1'" )
509 << QStringLiteral( "QgsPointXY" )
510 << QStringLiteral( "QgsProperty" )
511 << QStringLiteral( "QgsReferencedPointXY" )
512 << QStringLiteral( "QgsGeometry: centroid of geometry is used" );
513 }
514
515 QStringList acceptedStringValues() const override
516 {
517 return QStringList() << QObject::tr( "Point coordinate as an 'x,y' string, e.g. '1.5,10.1'" );
518 }
519};
520
529{
530 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
531 {
532 return new QgsProcessingParameterGeometry( name );
533 }
534
535 QString description() const override
536 {
537 return QCoreApplication::translate( "Processing", "A geometry parameter." );
538 }
539
540 QString name() const override
541 {
542 return QCoreApplication::translate( "Processing", "Geometry" );
543 }
544
545 QString id() const override
546 {
547 return QStringLiteral( "geometry" );
548 }
549
550 QString pythonImportString() const override
551 {
552 return QStringLiteral( "from qgis.core import QgsProcessingParameterGeometry" );
553 }
554
555 QString className() const override
556 {
557 return QStringLiteral( "QgsProcessingParameterGeometry" );
558 }
559
560 QStringList acceptedPythonTypes() const override
561 {
562 return QStringList() << QObject::tr( "str: as Well-Known Text string (WKT)" )
563 << QStringLiteral( "QgsGeometry" )
564 << QStringLiteral( "QgsProperty" );
565 }
566
567 QStringList acceptedStringValues() const override
568 {
569 return QStringList() << QObject::tr( "Well-Known Text string (WKT)" );
570 }
571};
572
581{
582 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
583 {
584 return new QgsProcessingParameterEnum( name );
585 }
586
587 QString description() const override
588 {
589 return QCoreApplication::translate( "Processing", "An enumerated type parameter." );
590 }
591
592 QString name() const override
593 {
594 return QCoreApplication::translate( "Processing", "Enum" );
595 }
596
597 QString id() const override
598 {
599 return QStringLiteral( "enum" );
600 }
601
602 QString pythonImportString() const override
603 {
604 return QStringLiteral( "from qgis.core import QgsProcessingParameterEnum" );
605 }
606
607 QString className() const override
608 {
609 return QStringLiteral( "QgsProcessingParameterEnum" );
610 }
611
612 QStringList acceptedPythonTypes() const override
613 {
614 return QStringList() << QStringLiteral( "int" )
615 << QObject::tr( "str: as string representation of int, e.g. '1'" )
616 << QStringLiteral( "QgsProperty" );
617 }
618
619 QStringList acceptedStringValues() const override
620 {
621 return QStringList() << QObject::tr( "Number of selected option, e.g. '1'" )
622 << QObject::tr( "Comma separated list of options, e.g. '1,3'" );
623 }
624};
625
634{
635 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
636 {
637 return new QgsProcessingParameterExtent( name );
638 }
639
640 QString description() const override
641 {
642 return QCoreApplication::translate( "Processing", "A map extent parameter." );
643 }
644
645 QString name() const override
646 {
647 return QCoreApplication::translate( "Processing", "Extent" );
648 }
649
650 QString id() const override
651 {
652 return QStringLiteral( "extent" );
653 }
654
655 QString pythonImportString() const override
656 {
657 return QStringLiteral( "from qgis.core import QgsProcessingParameterExtent" );
658 }
659
660 QString className() const override
661 {
662 return QStringLiteral( "QgsProcessingParameterExtent" );
663 }
664
665 QStringList acceptedPythonTypes() const override
666 {
667 return QStringList() << QObject::tr( "str: as comma delimited list of x min, x max, y min, y max. E.g. '4,10,101,105'" )
668 << QObject::tr( "str: layer ID. Extent of layer is used." )
669 << QObject::tr( "str: layer name. Extent of layer is used." )
670 << QObject::tr( "str: layer source. Extent of layer is used." )
671 << QObject::tr( "QgsMapLayer: Extent of layer is used" )
672 << QObject::tr( "QgsProcessingFeatureSourceDefinition: Extent of source is used" )
673 << QStringLiteral( "QgsProperty" )
674 << QStringLiteral( "QgsRectangle" )
675 << QStringLiteral( "QgsReferencedRectangle" )
676 << QStringLiteral( "QgsGeometry: bounding box of geometry is used" );
677 }
678
679 QStringList acceptedStringValues() const override
680 {
681 return QStringList() << QObject::tr( "A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'" )
682 << QObject::tr( "Path to a layer. The extent of the layer is used." ) ;
683 }
684};
685
694{
695 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
696 {
697 return new QgsProcessingParameterMatrix( name );
698 }
699
700 QString description() const override
701 {
702 return QCoreApplication::translate( "Processing", "A table (matrix) parameter for processing algorithms." );
703 }
704
705 QString name() const override
706 {
707 return QCoreApplication::translate( "Processing", "Matrix" );
708 }
709
710 QString id() const override
711 {
712 return QStringLiteral( "matrix" );
713 }
714
715 QString pythonImportString() const override
716 {
717 return QStringLiteral( "from qgis.core import QgsProcessingParameterMatrix" );
718 }
719
720 QString className() const override
721 {
722 return QStringLiteral( "QgsProcessingParameterMatrix" );
723 }
724
725 QStringList acceptedPythonTypes() const override
726 {
727 return QStringList() << QObject::tr( "str: as comma delimited list of values" )
728 << QStringLiteral( "list" )
729 << QStringLiteral( "QgsProperty" );
730 }
731
732 QStringList acceptedStringValues() const override
733 {
734 return QStringList() << QObject::tr( "A comma delimited list of values" );
735 }
736};
737
746{
747 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
748 {
749 return new QgsProcessingParameterFile( name );
750 }
751
752 QString description() const override
753 {
754 return QCoreApplication::translate( "Processing", "A file or folder parameter, for use with non-map layer file sources or folders." );
755 }
756
757 QString name() const override
758 {
759 return QCoreApplication::translate( "Processing", "File/Folder" );
760 }
761
762 QString id() const override
763 {
764 return QStringLiteral( "file" );
765 }
766
767 QString pythonImportString() const override
768 {
769 return QStringLiteral( "from qgis.core import QgsProcessingParameterFile" );
770 }
771
772 QString className() const override
773 {
774 return QStringLiteral( "QgsProcessingParameterFile" );
775 }
776
777 QStringList acceptedPythonTypes() const override
778 {
779 return QStringList() << QStringLiteral( "str" )
780 << QStringLiteral( "QgsProperty" );
781 }
782
783 QStringList acceptedStringValues() const override
784 {
785 return QStringList() << QObject::tr( "Path to a file" );
786 }
787};
788
797{
798 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
799 {
800 return new QgsProcessingParameterField( name );
801 }
802
803 QString description() const override
804 {
805 return QCoreApplication::translate( "Processing", "A vector field parameter, for selecting an existing field from a vector source." );
806 }
807
808 QString name() const override
809 {
810 return QCoreApplication::translate( "Processing", "Vector Field" );
811 }
812
813 QString id() const override
814 {
815 return QStringLiteral( "field" );
816 }
817
818 QString pythonImportString() const override
819 {
820 return QStringLiteral( "from qgis.core import QgsProcessingParameterField" );
821 }
822
823 QString className() const override
824 {
825 return QStringLiteral( "QgsProcessingParameterField" );
826 }
827
828 QStringList acceptedPythonTypes() const override
829 {
830 return QStringList() << QStringLiteral( "str" )
831 << QStringLiteral( "QgsProperty" );
832 }
833
834 QStringList acceptedStringValues() const override
835 {
836 return QStringList() << QObject::tr( "The name of an existing field" )
837 << QObject::tr( "; delimited list of existing field names" );
838 }
839};
840
850{
851 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
852 {
854 }
855
856 QString description() const override
857 {
858 return QCoreApplication::translate( "Processing", "A vector layer destination parameter." );
859 }
860
861 QString name() const override
862 {
863 return QCoreApplication::translate( "Processing", "Vector Destination" );
864 }
865
866 QString id() const override
867 {
868 return QStringLiteral( "vectorDestination" );
869 }
870
871 QString pythonImportString() const override
872 {
873 return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorDestination" );
874 }
875
876 QString className() const override
877 {
878 return QStringLiteral( "QgsProcessingParameterVectorDestination" );
879 }
880
881 ParameterFlags flags() const override
882 {
883 ParameterFlags flags = QgsProcessingParameterType::flags();
884 flags.setFlag( ParameterFlag::ExposeToModeler, false );
885 return flags;
886 }
887
888 QStringList acceptedPythonTypes() const override
889 {
890 return QStringList() << QStringLiteral( "str" )
891 << QStringLiteral( "QgsProperty" )
892 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
893 }
894
895 QStringList acceptedStringValues() const override
896 {
897 return QStringList() << QObject::tr( "Path for new vector layer" );
898 }
899};
900
910{
911 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
912 {
913 return new QgsProcessingParameterFileDestination( name );
914 }
915
916 QString description() const override
917 {
918 return QCoreApplication::translate( "Processing", "A generic file based destination parameter." );
919 }
920
921 QString name() const override
922 {
923 return QCoreApplication::translate( "Processing", "File Destination" );
924 }
925
926 QString id() const override
927 {
928 return QStringLiteral( "fileDestination" );
929 }
930
931 QString pythonImportString() const override
932 {
933 return QStringLiteral( "from qgis.core import QgsProcessingParameterFileDestination" );
934 }
935
936 QString className() const override
937 {
938 return QStringLiteral( "QgsProcessingParameterFileDestination" );
939 }
940
941 ParameterFlags flags() const override
942 {
943 ParameterFlags flags = QgsProcessingParameterType::flags();
944 flags.setFlag( ParameterFlag::ExposeToModeler, false );
945 return flags;
946 }
947
948 QStringList acceptedPythonTypes() const override
949 {
950 return QStringList() << QStringLiteral( "str" )
951 << QStringLiteral( "QgsProperty" );
952 }
953
954 QStringList acceptedStringValues() const override
955 {
956 return QStringList() << QObject::tr( "Path for new file" );
957 }
958};
959
970{
971 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
972 {
974 }
975
976 QString description() const override
977 {
978 return QCoreApplication::translate( "Processing", "A folder destination parameter." );
979 }
980
981 QString name() const override
982 {
983 return QCoreApplication::translate( "Processing", "Folder Destination" );
984 }
985
986 QString id() const override
987 {
988 return QStringLiteral( "folderDestination" );
989 }
990
991 QString pythonImportString() const override
992 {
993 return QStringLiteral( "from qgis.core import QgsProcessingParameterFolderDestination" );
994 }
995
996 QString className() const override
997 {
998 return QStringLiteral( "QgsProcessingParameterFolderDestination" );
999 }
1000
1001 ParameterFlags flags() const override
1002 {
1003 ParameterFlags flags = QgsProcessingParameterType::flags();
1004 flags.setFlag( ParameterFlag::ExposeToModeler, false );
1005 return flags;
1006 }
1007
1008 QStringList acceptedPythonTypes() const override
1009 {
1010 return QStringList() << QStringLiteral( "str" )
1011 << QStringLiteral( "QgsProperty" );
1012 }
1013
1014 QStringList acceptedStringValues() const override
1015 {
1016 return QStringList() << QObject::tr( "Path for an existing or new folder" );
1017 }
1018};
1019
1029{
1030 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1031 {
1032 return new QgsProcessingParameterRasterDestination( name );
1033 }
1034
1035 QString description() const override
1036 {
1037 return QCoreApplication::translate( "Processing", "A raster layer destination parameter." );
1038 }
1039
1040 QString name() const override
1041 {
1042 return QCoreApplication::translate( "Processing", "Raster Destination" );
1043 }
1044
1045 QString id() const override
1046 {
1047 return QStringLiteral( "rasterDestination" );
1048 }
1049
1050 QString pythonImportString() const override
1051 {
1052 return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterDestination" );
1053 }
1054
1055 QString className() const override
1056 {
1057 return QStringLiteral( "QgsProcessingParameterRasterDestination" );
1058 }
1059
1060 ParameterFlags flags() const override
1061 {
1062 ParameterFlags flags = QgsProcessingParameterType::flags();
1063 flags.setFlag( ParameterFlag::ExposeToModeler, false );
1064 return flags;
1065 }
1066
1067 QStringList acceptedPythonTypes() const override
1068 {
1069 return QStringList() << QStringLiteral( "str" )
1070 << QStringLiteral( "QgsProperty" )
1071 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1072 }
1073
1074 QStringList acceptedStringValues() const override
1075 {
1076 return QStringList() << QObject::tr( "Path for new raster layer" );
1077 }
1078};
1079
1088{
1089 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1090 {
1091 return new QgsProcessingParameterString( name );
1092 }
1093
1094 QString description() const override
1095 {
1096 return QCoreApplication::translate( "Processing", "A freeform string parameter." );
1097 }
1098
1099 QString name() const override
1100 {
1101 return QCoreApplication::translate( "Processing", "String" );
1102 }
1103
1104 QString id() const override
1105 {
1106 return QStringLiteral( "string" );
1107 }
1108
1109 QString pythonImportString() const override
1110 {
1111 return QStringLiteral( "from qgis.core import QgsProcessingParameterString" );
1112 }
1113
1114 QString className() const override
1115 {
1116 return QStringLiteral( "QgsProcessingParameterString" );
1117 }
1118
1119 QStringList acceptedPythonTypes() const override
1120 {
1121 return QStringList() << QStringLiteral( "str" )
1122 << QStringLiteral( "QgsProperty" );
1123 }
1124
1125 QStringList acceptedStringValues() const override
1126 {
1127 return QStringList() << QObject::tr( "String value" );
1128 }
1129};
1130
1139{
1140 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1141 {
1142 return new QgsProcessingParameterAuthConfig( name );
1143 }
1144
1145 QString description() const override
1146 {
1147 return QCoreApplication::translate( "Processing", "A authentication configuration parameter." );
1148 }
1149
1150 QString name() const override
1151 {
1152 return QCoreApplication::translate( "Processing", "Authentication Configuration" );
1153 }
1154
1155 QString id() const override
1156 {
1157 return QStringLiteral( "authcfg" );
1158 }
1159
1160 QString pythonImportString() const override
1161 {
1162 return QStringLiteral( "from qgis.core import QgsProcessingParameterAuthConfig" );
1163 }
1164
1165 QString className() const override
1166 {
1167 return QStringLiteral( "QgsProcessingParameterAuthConfig" );
1168 }
1169
1170 QStringList acceptedPythonTypes() const override
1171 {
1172 return QStringList() << QStringLiteral( "str" );
1173 }
1174
1175 QStringList acceptedStringValues() const override
1176 {
1177 return QStringList() << QObject::tr( "An existing QGIS authentication ID string" );
1178 }
1179};
1180
1189{
1190 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1191 {
1192 return new QgsProcessingParameterMultipleLayers( name );
1193 }
1194
1195 QString description() const override
1196 {
1197 return QCoreApplication::translate( "Processing", "An input allowing selection of multiple sources, including multiple map layers or file sources." );
1198 }
1199
1200 QString name() const override
1201 {
1202 return QCoreApplication::translate( "Processing", "Multiple Input" );
1203 }
1204
1205 QString id() const override
1206 {
1207 return QStringLiteral( "multilayer" );
1208 }
1209
1210 QString pythonImportString() const override
1211 {
1212 return QStringLiteral( "from qgis.core import QgsProcessingParameterMultipleLayers" );
1213 }
1214
1215 QString className() const override
1216 {
1217 return QStringLiteral( "QgsProcessingParameterMultipleLayers" );
1218 }
1219
1220 QStringList acceptedPythonTypes() const override
1221 {
1222 return QStringList() << QObject::tr( "list[str]: list of layer IDs" )
1223 << QObject::tr( "list[str]: list of layer names" )
1224 << QObject::tr( "list[str]: list of layer sources" )
1225 << QStringLiteral( "list[QgsMapLayer]" )
1226 << QStringLiteral( "QgsProperty" );
1227 }
1228};
1229
1238{
1239 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1240 {
1241 return new QgsProcessingParameterFeatureSource( name );
1242 }
1243
1244 QString description() const override
1245 {
1246 return QCoreApplication::translate( "Processing", "A vector feature parameter, e.g. for algorithms which operate on the features within a layer." );
1247 }
1248
1249 QString name() const override
1250 {
1251 return QCoreApplication::translate( "Processing", "Vector Features" );
1252 }
1253
1254 QString id() const override
1255 {
1256 return QStringLiteral( "source" );
1257 }
1258
1259 QString pythonImportString() const override
1260 {
1261 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSource" );
1262 }
1263
1264 QString className() const override
1265 {
1266 return QStringLiteral( "QgsProcessingParameterFeatureSource" );
1267 }
1268
1269 QStringList acceptedPythonTypes() const override
1270 {
1271 return QStringList() << QObject::tr( "str: layer ID" )
1272 << QObject::tr( "str: layer name" )
1273 << QObject::tr( "str: layer source" )
1274 << QStringLiteral( "QgsProcessingFeatureSourceDefinition" )
1275 << QStringLiteral( "QgsProperty" )
1276 << QStringLiteral( "QgsVectorLayer" );
1277 }
1278
1279 QStringList acceptedStringValues() const override
1280 {
1281 return QStringList() << QObject::tr( "Path to a vector layer" );
1282 }
1283};
1284
1293{
1294 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1295 {
1296 return new QgsProcessingParameterNumber( name );
1297 }
1298
1299 QString description() const override
1300 {
1301 return QCoreApplication::translate( "Processing", "A numeric parameter, including float or integer values." );
1302 }
1303
1304 QString name() const override
1305 {
1306 return QCoreApplication::translate( "Processing", "Number" );
1307 }
1308
1309 QString id() const override
1310 {
1311 return QStringLiteral( "number" );
1312 }
1313
1314 QString pythonImportString() const override
1315 {
1316 return QStringLiteral( "from qgis.core import QgsProcessingParameterNumber" );
1317 }
1318
1319 QString className() const override
1320 {
1321 return QStringLiteral( "QgsProcessingParameterNumber" );
1322 }
1323
1324 QStringList acceptedPythonTypes() const override
1325 {
1326 return QStringList() << QStringLiteral( "int" )
1327 << QStringLiteral( "float" )
1328 << QStringLiteral( "QgsProperty" );
1329 }
1330
1331 QStringList acceptedStringValues() const override
1332 {
1333 return QStringList() << QObject::tr( "A numeric value" );
1334 }
1335};
1336
1345{
1346 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1347 {
1348 return new QgsProcessingParameterDistance( name );
1349 }
1350
1351 QString description() const override
1352 {
1353 return QCoreApplication::translate( "Processing", "A numeric parameter representing a distance measure." );
1354 }
1355
1356 QString name() const override
1357 {
1358 return QCoreApplication::translate( "Processing", "Distance" );
1359 }
1360
1361 QString id() const override
1362 {
1363 return QStringLiteral( "distance" );
1364 }
1365
1366 QString pythonImportString() const override
1367 {
1368 return QStringLiteral( "from qgis.core import QgsProcessingParameterDistance" );
1369 }
1370
1371 QString className() const override
1372 {
1373 return QStringLiteral( "QgsProcessingParameterDistance" );
1374 }
1375
1376 QStringList acceptedPythonTypes() const override
1377 {
1378 return QStringList() << QStringLiteral( "int" )
1379 << QStringLiteral( "float" )
1380 << QStringLiteral( "QgsProperty" );
1381 }
1382
1383 QStringList acceptedStringValues() const override
1384 {
1385 return QStringList() << QObject::tr( "A numeric value" );
1386 }
1387};
1388
1397{
1398 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1399 {
1400 return new QgsProcessingParameterDuration( name );
1401 }
1402
1403 QString description() const override
1404 {
1405 return QCoreApplication::translate( "Processing", "A numeric parameter representing a duration measure." );
1406 }
1407
1408 QString name() const override
1409 {
1410 return QCoreApplication::translate( "Processing", "Duration" );
1411 }
1412
1413 QString id() const override
1414 {
1415 return QStringLiteral( "duration" );
1416 }
1417
1418 QString pythonImportString() const override
1419 {
1420 return QStringLiteral( "from qgis.core import QgsProcessingParameterDuration" );
1421 }
1422
1423 QString className() const override
1424 {
1425 return QStringLiteral( "QgsProcessingParameterDuration" );
1426 }
1427
1428 QStringList acceptedPythonTypes() const override
1429 {
1430 return QStringList() << QStringLiteral( "int" )
1431 << QStringLiteral( "float" )
1432 << QStringLiteral( "QgsProperty" );
1433 }
1434
1435 QStringList acceptedStringValues() const override
1436 {
1437 return QStringList() << QObject::tr( "A numeric value (unit type set by algorithms)" );
1438 }
1439};
1440
1449{
1450 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1451 {
1452 return new QgsProcessingParameterScale( name );
1453 }
1454
1455 QString description() const override
1456 {
1457 return QCoreApplication::translate( "Processing", "A numeric parameter representing a map scale." );
1458 }
1459
1460 QString name() const override
1461 {
1462 return QCoreApplication::translate( "Processing", "Scale" );
1463 }
1464
1465 QString id() const override
1466 {
1467 return QStringLiteral( "scale" );
1468 }
1469
1470 QString pythonImportString() const override
1471 {
1472 return QStringLiteral( "from qgis.core import QgsProcessingParameterScale" );
1473 }
1474
1475 QString className() const override
1476 {
1477 return QStringLiteral( "QgsProcessingParameterScale" );
1478 }
1479
1480 QStringList acceptedPythonTypes() const override
1481 {
1482 return QStringList() << QStringLiteral( "int: scale denominator" )
1483 << QStringLiteral( "float: scale denominator" )
1484 << QStringLiteral( "QgsProperty" );
1485 }
1486
1487 QStringList acceptedStringValues() const override
1488 {
1489 return QStringList() << QObject::tr( "A numeric value representing the scale denominator" );
1490 }
1491};
1492
1501{
1502 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1503 {
1504 return new QgsProcessingParameterBand( name );
1505 }
1506
1507 QString description() const override
1508 {
1509 return QCoreApplication::translate( "Processing", "A raster band parameter, for selecting an existing band from a raster source." );
1510 }
1511
1512 QString name() const override
1513 {
1514 return QCoreApplication::translate( "Processing", "Raster Band" );
1515 }
1516
1517 QString id() const override
1518 {
1519 return QStringLiteral( "band" );
1520 }
1521
1522 QString pythonImportString() const override
1523 {
1524 return QStringLiteral( "from qgis.core import QgsProcessingParameterBand" );
1525 }
1526
1527 QString className() const override
1528 {
1529 return QStringLiteral( "QgsProcessingParameterBand" );
1530 }
1531
1532 QStringList acceptedPythonTypes() const override
1533 {
1534 return QStringList() << QStringLiteral( "int" )
1535 << QStringLiteral( "QgsProperty" );
1536 }
1537
1538 QStringList acceptedStringValues() const override
1539 {
1540 return QStringList() << QObject::tr( "Integer value representing an existing raster band number" );
1541 }
1542};
1543
1552{
1553 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1554 {
1555 return new QgsProcessingParameterFeatureSink( name );
1556 }
1557
1558 ParameterFlags flags() const override
1559 {
1560 ParameterFlags flags = QgsProcessingParameterType::flags();
1561 flags.setFlag( ParameterFlag::ExposeToModeler, false );
1562 return flags;
1563 }
1564
1565 QString description() const override
1566 {
1567 return QCoreApplication::translate( "Processing", "A feature sink destination parameter." );
1568 }
1569
1570 QString name() const override
1571 {
1572 return QCoreApplication::translate( "Processing", "Feature Sink" );
1573 }
1574
1575 QString id() const override
1576 {
1577 return QStringLiteral( "sink" );
1578 }
1579
1580 QString pythonImportString() const override
1581 {
1582 return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSink" );
1583 }
1584
1585 QString className() const override
1586 {
1587 return QStringLiteral( "QgsProcessingParameterFeatureSink" );
1588 }
1589
1590 QStringList acceptedPythonTypes() const override
1591 {
1592 return QStringList() << QObject::tr( "str: destination vector file, e.g. 'd:/test.shp'" )
1593 << QObject::tr( "str: 'memory:' to store result in temporary memory layer" )
1594 << QObject::tr( "str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table" )
1595 << QStringLiteral( "QgsProcessingOutputLayerDefinition" )
1596 << QStringLiteral( "QgsProperty" );
1597 }
1598
1599 QStringList acceptedStringValues() const override
1600 {
1601 return QStringList() << QObject::tr( "Path for new vector layer" );
1602 }
1603};
1604
1613{
1614 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1615 {
1616 return new QgsProcessingParameterLayout( name );
1617 }
1618
1619 QString description() const override
1620 {
1621 return QCoreApplication::translate( "Processing", "A print layout parameter." );
1622 }
1623
1624 QString name() const override
1625 {
1626 return QCoreApplication::translate( "Processing", "Print Layout" );
1627 }
1628
1629 QString id() const override
1630 {
1631 return QStringLiteral( "layout" );
1632 }
1633
1634 QString pythonImportString() const override
1635 {
1636 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayout" );
1637 }
1638
1639 QString className() const override
1640 {
1641 return QStringLiteral( "QgsProcessingParameterLayout" );
1642 }
1643
1644 QStringList acceptedPythonTypes() const override
1645 {
1646 return QStringList() << QObject::tr( "str: name of print layout in current project" )
1647 << QStringLiteral( "QgsProperty" );
1648 }
1649
1650 QStringList acceptedStringValues() const override
1651 {
1652 return QStringList() << QObject::tr( "Name of print layout in current project" );
1653 }
1654};
1655
1664{
1665 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1666 {
1667 return new QgsProcessingParameterLayoutItem( name );
1668 }
1669
1670 QString description() const override
1671 {
1672 return QCoreApplication::translate( "Processing", "A print layout item parameter." );
1673 }
1674
1675 QString name() const override
1676 {
1677 return QCoreApplication::translate( "Processing", "Print Layout Item" );
1678 }
1679
1680 QString id() const override
1681 {
1682 return QStringLiteral( "layoutitem" );
1683 }
1684
1685 QString pythonImportString() const override
1686 {
1687 return QStringLiteral( "from qgis.core import QgsProcessingParameterLayoutItem" );
1688 }
1689
1690 QString className() const override
1691 {
1692 return QStringLiteral( "QgsProcessingParameterLayoutItem" );
1693 }
1694
1695 QStringList acceptedPythonTypes() const override
1696 {
1697 return QStringList() << QObject::tr( "str: UUID of print layout item" )
1698 << QObject::tr( "str: id of print layout item" )
1699 << QStringLiteral( "QgsProperty" );
1700 }
1701
1702 QStringList acceptedStringValues() const override
1703 {
1704 return QStringList() << QObject::tr( "UUID or item id of layout item" );
1705 }
1706};
1707
1716{
1717 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1718 {
1719 return new QgsProcessingParameterColor( name );
1720 }
1721
1722 QString description() const override
1723 {
1724 return QCoreApplication::translate( "Processing", "A color parameter." );
1725 }
1726
1727 QString name() const override
1728 {
1729 return QCoreApplication::translate( "Processing", "Color" );
1730 }
1731
1732 QString id() const override
1733 {
1734 return QStringLiteral( "color" );
1735 }
1736
1737 QString pythonImportString() const override
1738 {
1739 return QStringLiteral( "from qgis.core import QgsProcessingParameterColor" );
1740 }
1741
1742 QString className() const override
1743 {
1744 return QStringLiteral( "QgsProcessingParameterColor" );
1745 }
1746
1747 QStringList acceptedPythonTypes() const override
1748 {
1749 return QStringList() << QObject::tr( "str: string representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
1750 << QStringLiteral( "QColor" )
1751 << QStringLiteral( "QgsProperty" );
1752 }
1753
1754 QStringList acceptedStringValues() const override
1755 {
1756 return QStringList() << QObject::tr( "String representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" );
1757 }
1758};
1759
1768{
1769 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1770 {
1772 }
1773
1774 QString description() const override
1775 {
1776 return QCoreApplication::translate( "Processing", "A coordinate operation parameter." );
1777 }
1778
1779 QString name() const override
1780 {
1781 return QCoreApplication::translate( "Processing", "Coordinate Operation" );
1782 }
1783
1784 QString id() const override
1785 {
1786 return QStringLiteral( "coordinateoperation" );
1787 }
1788
1789 QString pythonImportString() const override
1790 {
1791 return QStringLiteral( "from qgis.core import QgsProcessingParameterCoordinateOperation" );
1792 }
1793
1794 QString className() const override
1795 {
1796 return QStringLiteral( "QgsProcessingParameterCoordinateOperation" );
1797 }
1798
1799 QStringList acceptedPythonTypes() const override
1800 {
1801 return QStringList() << QObject::tr( "str: string representation of a Proj coordinate operation" );
1802 }
1803
1804 QStringList acceptedStringValues() const override
1805 {
1806 return QStringList() << QObject::tr( "String representation of Proj coordinate operation" );
1807 }
1808};
1809
1818{
1819 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1820 {
1821 return new QgsProcessingParameterMapTheme( name );
1822 }
1823
1824 QString description() const override
1825 {
1826 return QCoreApplication::translate( "Processing", "A map theme parameter." );
1827 }
1828
1829 QString name() const override
1830 {
1831 return QCoreApplication::translate( "Processing", "Map Theme" );
1832 }
1833
1834 QString id() const override
1835 {
1836 return QStringLiteral( "maptheme" );
1837 }
1838
1839 QString pythonImportString() const override
1840 {
1841 return QStringLiteral( "from qgis.core import QgsProcessingParameterMapTheme" );
1842 }
1843
1844 QString className() const override
1845 {
1846 return QStringLiteral( "QgsProcessingParameterMapTheme" );
1847 }
1848
1849 QStringList acceptedPythonTypes() const override
1850 {
1851 return QStringList() << QObject::tr( "str: name of an existing map theme" )
1852 << QStringLiteral( "QgsProperty" );
1853 }
1854
1855 QStringList acceptedStringValues() const override
1856 {
1857 return QStringList() << QObject::tr( "Name of an existing map theme" );
1858 }
1859};
1860
1869{
1870 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1871 {
1872 return new QgsProcessingParameterDateTime( name );
1873 }
1874
1875 QString description() const override
1876 {
1877 return QCoreApplication::translate( "Processing", "A datetime parameter, including datetime, date or time values." );
1878 }
1879
1880 QString name() const override
1881 {
1882 return QCoreApplication::translate( "Processing", "Datetime" );
1883 }
1884
1885 QString id() const override
1886 {
1887 return QStringLiteral( "datetime" );
1888 }
1889
1890 QString pythonImportString() const override
1891 {
1892 return QStringLiteral( "from qgis.core import QgsProcessingParameterDateTime" );
1893 }
1894
1895 QString className() const override
1896 {
1897 return QStringLiteral( "QgsProcessingParameterDateTime" );
1898 }
1899
1900 QStringList acceptedPythonTypes() const override
1901 {
1902 return QStringList() << QStringLiteral( "str" )
1903 << QStringLiteral( "QDateTime" )
1904 << QStringLiteral( "QDate" )
1905 << QStringLiteral( "QTime" )
1906 << QStringLiteral( "QgsProperty" );
1907 }
1908
1909 QStringList acceptedStringValues() const override
1910 {
1911 return QStringList() << QObject::tr( "A datetime value in ISO format" );
1912 }
1913};
1914
1923{
1924 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1925 {
1926 return new QgsProcessingParameterProviderConnection( name, QString(), QString() );
1927 }
1928
1929 QString description() const override
1930 {
1931 return QCoreApplication::translate( "Processing", "A connection name parameter, for registered database connections." );
1932 }
1933
1934 QString name() const override
1935 {
1936 return QCoreApplication::translate( "Processing", "Connection Name" );
1937 }
1938
1939 QString id() const override
1940 {
1941 return QStringLiteral( "providerconnection" );
1942 }
1943
1944 QString pythonImportString() const override
1945 {
1946 return QStringLiteral( "from qgis.core import QgsProcessingParameterProviderConnection" );
1947 }
1948
1949 QString className() const override
1950 {
1951 return QStringLiteral( "QgsProcessingParameterProviderConnection" );
1952 }
1953
1954 QStringList acceptedPythonTypes() const override
1955 {
1956 return QStringList() << QStringLiteral( "str" )
1957 << QStringLiteral( "QgsProperty" );
1958 }
1959
1960 QStringList acceptedStringValues() const override
1961 {
1962 return QStringList() << QObject::tr( "Name of registered database connection" );
1963 }
1964};
1965
1974{
1975 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1976 {
1977 return new QgsProcessingParameterDatabaseSchema( name, QString(), QString() );
1978 }
1979
1980 QString description() const override
1981 {
1982 return QCoreApplication::translate( "Processing", "A database schema parameter." );
1983 }
1984
1985 QString name() const override
1986 {
1987 return QCoreApplication::translate( "Processing", "Database Schema" );
1988 }
1989
1990 QString id() const override
1991 {
1992 return QStringLiteral( "databaseschema" );
1993 }
1994
1995 QString pythonImportString() const override
1996 {
1997 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseSchema" );
1998 }
1999
2000 QString className() const override
2001 {
2002 return QStringLiteral( "QgsProcessingParameterDatabaseSchema" );
2003 }
2004
2005 QStringList acceptedPythonTypes() const override
2006 {
2007 return QStringList() << QStringLiteral( "str" )
2008 << QStringLiteral( "QgsProperty" );
2009 }
2010
2011 QStringList acceptedStringValues() const override
2012 {
2013 return QStringList() << QObject::tr( "Name of existing database schema" );
2014 }
2015};
2016
2025{
2026 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2027 {
2028 return new QgsProcessingParameterDatabaseTable( name, QString(), QString(), QString() );
2029 }
2030
2031 QString description() const override
2032 {
2033 return QCoreApplication::translate( "Processing", "A database table parameter." );
2034 }
2035
2036 QString name() const override
2037 {
2038 return QCoreApplication::translate( "Processing", "Database Table" );
2039 }
2040
2041 QString id() const override
2042 {
2043 return QStringLiteral( "databasetable" );
2044 }
2045
2046 QString pythonImportString() const override
2047 {
2048 return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseTable" );
2049 }
2050
2051 QString className() const override
2052 {
2053 return QStringLiteral( "QgsProcessingParameterDatabaseTable" );
2054 }
2055
2056 QStringList acceptedPythonTypes() const override
2057 {
2058 return QStringList() << QStringLiteral( "str" )
2059 << QStringLiteral( "QgsProperty" );
2060 }
2061
2062 QStringList acceptedStringValues() const override
2063 {
2064 return QStringList() << QObject::tr( "Name of existing database table" );
2065 }
2066};
2067
2076{
2077 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2078 {
2079 return new QgsProcessingParameterPointCloudLayer( name );
2080 }
2081
2082 QString description() const override
2083 {
2084 return QCoreApplication::translate( "Processing", "A point cloud layer parameter." );
2085 }
2086
2087 QString name() const override
2088 {
2089 return QCoreApplication::translate( "Processing", "Point Cloud Layer" );
2090 }
2091
2092 QString pythonImportString() const override
2093 {
2094 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudLayer" );
2095 }
2096
2097 QString className() const override
2098 {
2099 return QStringLiteral( "QgsProcessingParameterPointCloudLayer" );
2100 }
2101
2102 QString id() const override
2103 {
2104 return QStringLiteral( "pointcloud" );
2105 }
2106
2107 QStringList acceptedPythonTypes() const override
2108 {
2109 return QStringList() << QObject::tr( "str: layer ID" )
2110 << QObject::tr( "str: layer name" )
2111 << QObject::tr( "str: layer source" )
2112 << QStringLiteral( "QgsPointCloudLayer" );
2113 }
2114
2115 QStringList acceptedStringValues() const override
2116 {
2117 return QStringList() << QObject::tr( "Path to a point cloud layer" );
2118 }
2119};
2120
2129{
2130 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2131 {
2132 return new QgsProcessingParameterAnnotationLayer( name );
2133 }
2134
2135 QString description() const override
2136 {
2137 return QCoreApplication::translate( "Processing", "An annotation layer parameter." );
2138 }
2139
2140 QString name() const override
2141 {
2142 return QCoreApplication::translate( "Processing", "Annotation Layer" );
2143 }
2144
2145 QString pythonImportString() const override
2146 {
2147 return QStringLiteral( "from qgis.core import QgsProcessingParameterAnnotationLayer" );
2148 }
2149
2150 QString className() const override
2151 {
2152 return QStringLiteral( "QgsProcessingParameterAnnotationLayer" );
2153 }
2154
2155 QString id() const override
2156 {
2157 return QStringLiteral( "annotation" );
2158 }
2159
2160 QStringList acceptedPythonTypes() const override
2161 {
2162 return QStringList() << QObject::tr( "str: layer ID" )
2163 << QObject::tr( "str: layer name" )
2164 << QObject::tr( "\"main\": main annotation layer for a project" )
2165 << QStringLiteral( "QgsAnnotationLayer" );
2166 }
2167
2168 QStringList acceptedStringValues() const override
2169 {
2170 return QStringList() << QObject::tr( "Layer ID for an annotation layer, or \"main\" for the main annotation layer in a project." );
2171 }
2172};
2173
2183{
2184 QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
2185 {
2187 }
2188
2189 QString description() const override
2190 {
2191 return QCoreApplication::translate( "Processing", "A point cloud layer destination parameter." );
2192 }
2193
2194 QString name() const override
2195 {
2196 return QCoreApplication::translate( "Processing", "Point Cloud Destination" );
2197 }
2198
2199 QString id() const override
2200 {
2201 return QStringLiteral( "pointCloudDestination" );
2202 }
2203
2204 QString pythonImportString() const override
2205 {
2206 return QStringLiteral( "from qgis.core import QgsProcessingParameterPointCloudDestination" );
2207 }
2208
2209 QString className() const override
2210 {
2211 return QStringLiteral( "QgsProcessingParameterPointCloudDestination" );
2212 }
2213
2214 ParameterFlags flags() const override
2215 {
2216 ParameterFlags flags = QgsProcessingParameterType::flags();
2217 flags.setFlag( ParameterFlag::ExposeToModeler, false );
2218 return flags;
2219 }
2220
2221 QStringList acceptedPythonTypes() const override
2222 {
2223 return QStringList() << QStringLiteral( "str" )
2224 << QStringLiteral( "QgsProperty" )
2225 << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
2226 }
2227
2228 QStringList acceptedStringValues() const override
2229 {
2230 return QStringList() << QObject::tr( "Path for new point cloud layer" );
2231 }
2232};
2233
2234#endif // QGSPROCESSINGPARAMETERTYPEIMPL_H
An annotation layer parameter for processing algorithms.
A string parameter for authentication configuration ID values.
A raster band parameter for Processing algorithms.
A boolean parameter for processing algorithms.
A color parameter for processing algorithms.
A coordinate operation parameter for processing algorithms, for selection between available coordinat...
A coordinate reference system parameter for processing algorithms.
A database schema parameter for processing algorithms, allowing users to select from existing schemas...
A database table name parameter for processing algorithms, allowing users to select from existing dat...
A datetime (or pure date or time) parameter for processing algorithms.
Base class for the definition of processing parameters.
A double numeric parameter for distance values.
A double numeric parameter for duration values.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
An expression parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A geometry parameter for processing algorithms.
A print layout item parameter, allowing users to select a particular item from a print layout.
A print layout parameter, allowing users to select a print layout.
A map layer parameter for processing algorithms.
A map theme parameter for processing algorithms, allowing users to select an existing map theme from ...
A table (matrix) parameter for processing algorithms.
A mesh layer parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A numeric parameter for processing algorithms.
A point cloud layer destination parameter, for specifying the destination path for a point cloud laye...
A point cloud layer parameter for processing algorithms.
A point parameter for processing algorithms.
A data provider connection parameter for processing algorithms, allowing users to select from availab...
A numeric range parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A raster layer parameter for processing algorithms.
A double numeric parameter for map scale values.
A string parameter for processing algorithms.
An annotation layer parameter for processing algorithms.
A authentication configuration parameter for processing algorithms.
A raster band parameter for Processing algorithms.
A boolean parameter for processing algorithms.
A color parameter for Processing algorithms.
A coordinate operation parameter for Processing algorithms.
A crs parameter for processing algorithms.
A database schema name parameter for processing algorithms.
A database table name parameter for processing algorithms.
A datetime parameter for processing algorithms.
A distance parameter for processing algorithms.
A duration parameter for processing algorithms.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
An expression parameter for processing algorithms.
A rectangular map extent parameter for processing algorithms.
A feature sink parameter for Processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A geometry parameter for processing algorithms.
A print layout item parameter for Processing algorithms.
A print layout parameter for Processing algorithms.
A generic map layer parameter for processing algorithms.
A map theme parameter for Processing algorithms.
A table (matrix) parameter for processing algorithms.
A mesh layer parameter for processing algorithms.
A parameter for processing algorithms which accepts multiple map layers.
A numeric parameter for processing algorithms.
A pointcloud layer destination parameter, for specifying the destination path for a point cloud layer...
A point cloud layer parameter for processing algorithms.
A point parameter for processing algorithms.
A provider connection name parameter for processing algorithms.
A numeric range parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A raster layer parameter for processing algorithms.
A scale parameter for processing algorithms.
A string parameter for processing algorithms.
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
A vector layer parameter for processing algorithms.
Makes metadata of processing parameters available.
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
virtual QStringList acceptedPythonTypes() const
Returns a list of the Python data types accepted as values for the parameter.
virtual QgsProcessingParameterDefinition * create(const QString &name) const =0
Creates a new parameter of this type.
virtual QString description() const =0
A human readable and translatable description for this parameter type.
virtual ParameterFlags flags() const
Determines if this parameter is available in the modeler.
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
virtual QString className() const
Returns the corresponding class name for the parameter type.
virtual QStringList acceptedStringValues() const
Returns a descriptive list of the possible string values acceptable for the parameter.
virtual QString pythonImportString() const
Returns a valid Python import string for importing the corresponding parameter type,...
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
A vector layer (with or without geometry) parameter for processing algorithms.
#define SIP_FACTORY
Definition: qgis_sip.h:76