QGIS API Documentation  3.23.0-Master (eb871beae0)
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"
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 geographic point 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  {
853  return new QgsProcessingParameterVectorDestination( name );
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  {
973  return new QgsProcessingParameterFolderDestination( name );
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  {
1771  return new QgsProcessingParameterCoordinateOperation( name );
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 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 QgsProcessingParameterDefinition * create(const QString &name) const =0
Creates a new parameter of this 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