QGIS API Documentation  3.14.0-Pi (9f7028fd23)
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 QgsProcessingParameterEnum( name );
533  }
534 
535  QString description() const override
536  {
537  return QCoreApplication::translate( "Processing", "An enumerated type parameter." );
538  }
539 
540  QString name() const override
541  {
542  return QCoreApplication::translate( "Processing", "Enum" );
543  }
544 
545  QString id() const override
546  {
547  return QStringLiteral( "enum" );
548  }
549 
550  QString pythonImportString() const override
551  {
552  return QStringLiteral( "from qgis.core import QgsProcessingParameterEnum" );
553  }
554 
555  QString className() const override
556  {
557  return QStringLiteral( "QgsProcessingParameterEnum" );
558  }
559 
560  QStringList acceptedPythonTypes() const override
561  {
562  return QStringList() << QStringLiteral( "int" )
563  << QObject::tr( "str: as string representation of int, e.g. '1'" )
564  << QStringLiteral( "QgsProperty" );
565  }
566 
567  QStringList acceptedStringValues() const override
568  {
569  return QStringList() << QObject::tr( "Number of selected option, e.g. '1'" )
570  << QObject::tr( "Comma separated list of options, e.g. '1,3'" );
571  }
572 };
573 
582 {
583  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
584  {
585  return new QgsProcessingParameterExtent( name );
586  }
587 
588  QString description() const override
589  {
590  return QCoreApplication::translate( "Processing", "A map extent parameter." );
591  }
592 
593  QString name() const override
594  {
595  return QCoreApplication::translate( "Processing", "Extent" );
596  }
597 
598  QString id() const override
599  {
600  return QStringLiteral( "extent" );
601  }
602 
603  QString pythonImportString() const override
604  {
605  return QStringLiteral( "from qgis.core import QgsProcessingParameterExtent" );
606  }
607 
608  QString className() const override
609  {
610  return QStringLiteral( "QgsProcessingParameterExtent" );
611  }
612 
613  QStringList acceptedPythonTypes() const override
614  {
615  return QStringList() << QObject::tr( "str: as comma delimited list of x min, x max, y min, y max. E.g. '4,10,101,105'" )
616  << QObject::tr( "str: layer ID. Extent of layer is used." )
617  << QObject::tr( "str: layer name. Extent of layer is used." )
618  << QObject::tr( "str: layer source. Extent of layer is used." )
619  << QObject::tr( "QgsMapLayer: Extent of layer is used" )
620  << QObject::tr( "QgsProcessingFeatureSourceDefinition: Extent of source is used" )
621  << QStringLiteral( "QgsProperty" )
622  << QStringLiteral( "QgsRectangle" )
623  << QStringLiteral( "QgsReferencedRectangle" )
624  << QStringLiteral( "QgsGeometry: bounding box of geometry is used" );;
625  }
626 
627  QStringList acceptedStringValues() const override
628  {
629  return QStringList() << QObject::tr( "A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'" )
630  << QObject::tr( "Path to a layer. The extent of the layer is used." ) ;
631  }
632 };
633 
642 {
643  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
644  {
645  return new QgsProcessingParameterMatrix( name );
646  }
647 
648  QString description() const override
649  {
650  return QCoreApplication::translate( "Processing", "A table (matrix) parameter for processing algorithms." );
651  }
652 
653  QString name() const override
654  {
655  return QCoreApplication::translate( "Processing", "Matrix" );
656  }
657 
658  QString id() const override
659  {
660  return QStringLiteral( "matrix" );
661  }
662 
663  QString pythonImportString() const override
664  {
665  return QStringLiteral( "from qgis.core import QgsProcessingParameterMatrix" );
666  }
667 
668  QString className() const override
669  {
670  return QStringLiteral( "QgsProcessingParameterMatrix" );
671  }
672 
673  QStringList acceptedPythonTypes() const override
674  {
675  return QStringList() << QObject::tr( "str: as comma delimited list of values" )
676  << QStringLiteral( "list" )
677  << QStringLiteral( "QgsProperty" );
678  }
679 
680  QStringList acceptedStringValues() const override
681  {
682  return QStringList() << QObject::tr( "A comma delimited list of values" );
683  }
684 };
685 
694 {
695  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
696  {
697  return new QgsProcessingParameterFile( name );
698  }
699 
700  QString description() const override
701  {
702  return QCoreApplication::translate( "Processing", "A file or folder parameter, for use with non-map layer file sources or folders." );
703  }
704 
705  QString name() const override
706  {
707  return QCoreApplication::translate( "Processing", "File/Folder" );
708  }
709 
710  QString id() const override
711  {
712  return QStringLiteral( "file" );
713  }
714 
715  QString pythonImportString() const override
716  {
717  return QStringLiteral( "from qgis.core import QgsProcessingParameterFile" );
718  }
719 
720  QString className() const override
721  {
722  return QStringLiteral( "QgsProcessingParameterFile" );
723  }
724 
725  QStringList acceptedPythonTypes() const override
726  {
727  return QStringList() << QStringLiteral( "str" )
728  << QStringLiteral( "QgsProperty" );
729  }
730 
731  QStringList acceptedStringValues() const override
732  {
733  return QStringList() << QObject::tr( "Path to a file" );
734  }
735 };
736 
745 {
746  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
747  {
748  return new QgsProcessingParameterField( name );
749  }
750 
751  QString description() const override
752  {
753  return QCoreApplication::translate( "Processing", "A vector field parameter, for selecting an existing field from a vector source." );
754  }
755 
756  QString name() const override
757  {
758  return QCoreApplication::translate( "Processing", "Vector Field" );
759  }
760 
761  QString id() const override
762  {
763  return QStringLiteral( "field" );
764  }
765 
766  QString pythonImportString() const override
767  {
768  return QStringLiteral( "from qgis.core import QgsProcessingParameterField" );
769  }
770 
771  QString className() const override
772  {
773  return QStringLiteral( "QgsProcessingParameterField" );
774  }
775 
776  QStringList acceptedPythonTypes() const override
777  {
778  return QStringList() << QStringLiteral( "str" )
779  << QStringLiteral( "QgsProperty" );
780  }
781 
782  QStringList acceptedStringValues() const override
783  {
784  return QStringList() << QObject::tr( "The name of an existing field" )
785  << QObject::tr( "; delimited list of existing field names" );
786  }
787 };
788 
798 {
799  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
800  {
801  return new QgsProcessingParameterVectorDestination( name );
802  }
803 
804  QString description() const override
805  {
806  return QCoreApplication::translate( "Processing", "A vector layer destination parameter." );
807  }
808 
809  QString name() const override
810  {
811  return QCoreApplication::translate( "Processing", "Vector Destination" );
812  }
813 
814  QString id() const override
815  {
816  return QStringLiteral( "vectorDestination" );
817  }
818 
819  QString pythonImportString() const override
820  {
821  return QStringLiteral( "from qgis.core import QgsProcessingParameterVectorDestination" );
822  }
823 
824  QString className() const override
825  {
826  return QStringLiteral( "QgsProcessingParameterVectorDestination" );
827  }
828 
829  ParameterFlags flags() const override
830  {
831  ParameterFlags flags = QgsProcessingParameterType::flags();
832  flags.setFlag( ParameterFlag::ExposeToModeler, false );
833  return flags;
834  }
835 
836  QStringList acceptedPythonTypes() const override
837  {
838  return QStringList() << QStringLiteral( "str" )
839  << QStringLiteral( "QgsProperty" )
840  << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
841  }
842 
843  QStringList acceptedStringValues() const override
844  {
845  return QStringList() << QObject::tr( "Path for new vector layer" );
846  }
847 
848 };
849 
859 {
860  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
861  {
862  return new QgsProcessingParameterFileDestination( name );
863  }
864 
865  QString description() const override
866  {
867  return QCoreApplication::translate( "Processing", "A generic file based destination parameter." );
868  }
869 
870  QString name() const override
871  {
872  return QCoreApplication::translate( "Processing", "File Destination" );
873  }
874 
875  QString id() const override
876  {
877  return QStringLiteral( "fileDestination" );
878  }
879 
880  QString pythonImportString() const override
881  {
882  return QStringLiteral( "from qgis.core import QgsProcessingParameterFileDestination" );
883  }
884 
885  QString className() const override
886  {
887  return QStringLiteral( "QgsProcessingParameterFileDestination" );
888  }
889 
890  ParameterFlags flags() const override
891  {
892  ParameterFlags flags = QgsProcessingParameterType::flags();
893  flags.setFlag( ParameterFlag::ExposeToModeler, false );
894  return flags;
895  }
896 
897  QStringList acceptedPythonTypes() const override
898  {
899  return QStringList() << QStringLiteral( "str" )
900  << QStringLiteral( "QgsProperty" );
901  }
902 
903  QStringList acceptedStringValues() const override
904  {
905  return QStringList() << QObject::tr( "Path for new file" );
906  }
907 
908 };
909 
920 {
921  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
922  {
923  return new QgsProcessingParameterFolderDestination( name );
924  }
925 
926  QString description() const override
927  {
928  return QCoreApplication::translate( "Processing", "A folder destination parameter." );
929  }
930 
931  QString name() const override
932  {
933  return QCoreApplication::translate( "Processing", "Folder Destination" );
934  }
935 
936  QString id() const override
937  {
938  return QStringLiteral( "folderDestination" );
939  }
940 
941  QString pythonImportString() const override
942  {
943  return QStringLiteral( "from qgis.core import QgsProcessingParameterFolderDestination" );
944  }
945 
946  QString className() const override
947  {
948  return QStringLiteral( "QgsProcessingParameterFolderDestination" );
949  }
950 
951  ParameterFlags flags() const override
952  {
953  ParameterFlags flags = QgsProcessingParameterType::flags();
954  flags.setFlag( ParameterFlag::ExposeToModeler, false );
955  return flags;
956  }
957 
958  QStringList acceptedPythonTypes() const override
959  {
960  return QStringList() << QStringLiteral( "str" )
961  << QStringLiteral( "QgsProperty" );
962  }
963 
964  QStringList acceptedStringValues() const override
965  {
966  return QStringList() << QObject::tr( "Path for an existing or new folder" );
967  }
968 
969 };
970 
980 {
981  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
982  {
983  return new QgsProcessingParameterRasterDestination( name );
984  }
985 
986  QString description() const override
987  {
988  return QCoreApplication::translate( "Processing", "A raster layer destination parameter." );
989  }
990 
991  QString name() const override
992  {
993  return QCoreApplication::translate( "Processing", "Raster Destination" );
994  }
995 
996  QString id() const override
997  {
998  return QStringLiteral( "rasterDestination" );
999  }
1000 
1001  QString pythonImportString() const override
1002  {
1003  return QStringLiteral( "from qgis.core import QgsProcessingParameterRasterDestination" );
1004  }
1005 
1006  QString className() const override
1007  {
1008  return QStringLiteral( "QgsProcessingParameterRasterDestination" );
1009  }
1010 
1011  ParameterFlags flags() const override
1012  {
1013  ParameterFlags flags = QgsProcessingParameterType::flags();
1014  flags.setFlag( ParameterFlag::ExposeToModeler, false );
1015  return flags;
1016  }
1017 
1018  QStringList acceptedPythonTypes() const override
1019  {
1020  return QStringList() << QStringLiteral( "str" )
1021  << QStringLiteral( "QgsProperty" )
1022  << QStringLiteral( "QgsProcessingOutputLayerDefinition" );
1023  }
1024 
1025  QStringList acceptedStringValues() const override
1026  {
1027  return QStringList() << QObject::tr( "Path for new raster layer" );
1028  }
1029 
1030 };
1031 
1040 {
1041  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1042  {
1043  return new QgsProcessingParameterString( name );
1044  }
1045 
1046  QString description() const override
1047  {
1048  return QCoreApplication::translate( "Processing", "A freeform string parameter." );
1049  }
1050 
1051  QString name() const override
1052  {
1053  return QCoreApplication::translate( "Processing", "String" );
1054  }
1055 
1056  QString id() const override
1057  {
1058  return QStringLiteral( "string" );
1059  }
1060 
1061  QString pythonImportString() const override
1062  {
1063  return QStringLiteral( "from qgis.core import QgsProcessingParameterString" );
1064  }
1065 
1066  QString className() const override
1067  {
1068  return QStringLiteral( "QgsProcessingParameterString" );
1069  }
1070 
1071  QStringList acceptedPythonTypes() const override
1072  {
1073  return QStringList() << QStringLiteral( "str" )
1074  << QStringLiteral( "QgsProperty" );
1075  }
1076 
1077  QStringList acceptedStringValues() const override
1078  {
1079  return QStringList() << QObject::tr( "String value" );
1080  }
1081 
1082 };
1083 
1092 {
1093  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1094  {
1095  return new QgsProcessingParameterAuthConfig( name );
1096  }
1097 
1098  QString description() const override
1099  {
1100  return QCoreApplication::translate( "Processing", "A authentication configuration parameter." );
1101  }
1102 
1103  QString name() const override
1104  {
1105  return QCoreApplication::translate( "Processing", "Authentication Configuration" );
1106  }
1107 
1108  QString id() const override
1109  {
1110  return QStringLiteral( "authcfg" );
1111  }
1112 
1113  QString pythonImportString() const override
1114  {
1115  return QStringLiteral( "from qgis.core import QgsProcessingParameterAuthConfig" );
1116  }
1117 
1118  QString className() const override
1119  {
1120  return QStringLiteral( "QgsProcessingParameterAuthConfig" );
1121  }
1122 
1123  QStringList acceptedPythonTypes() const override
1124  {
1125  return QStringList() << QStringLiteral( "str" );
1126  }
1127 
1128  QStringList acceptedStringValues() const override
1129  {
1130  return QStringList() << QObject::tr( "An existing QGIS authentication ID string" );
1131  }
1132 
1133 };
1134 
1143 {
1144  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1145  {
1146  return new QgsProcessingParameterMultipleLayers( name );
1147  }
1148 
1149  QString description() const override
1150  {
1151  return QCoreApplication::translate( "Processing", "An input allowing selection of multiple sources, including multiple map layers or file sources." );
1152  }
1153 
1154  QString name() const override
1155  {
1156  return QCoreApplication::translate( "Processing", "Multiple Input" );
1157  }
1158 
1159  QString id() const override
1160  {
1161  return QStringLiteral( "multilayer" );
1162  }
1163 
1164  QString pythonImportString() const override
1165  {
1166  return QStringLiteral( "from qgis.core import QgsProcessingParameterMultipleLayers" );
1167  }
1168 
1169  QString className() const override
1170  {
1171  return QStringLiteral( "QgsProcessingParameterMultipleLayers" );
1172  }
1173 
1174  QStringList acceptedPythonTypes() const override
1175  {
1176  return QStringList() << QObject::tr( "list[str]: list of layer IDs" )
1177  << QObject::tr( "list[str]: list of layer names" )
1178  << QObject::tr( "list[str]: list of layer sources" )
1179  << QStringLiteral( "list[QgsMapLayer]" )
1180  << QStringLiteral( "QgsProperty" );
1181  }
1182 };
1183 
1192 {
1193  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1194  {
1195  return new QgsProcessingParameterFeatureSource( name );
1196  }
1197 
1198  QString description() const override
1199  {
1200  return QCoreApplication::translate( "Processing", "A vector feature parameter, e.g. for algorithms which operate on the features within a layer." );
1201  }
1202 
1203  QString name() const override
1204  {
1205  return QCoreApplication::translate( "Processing", "Vector Features" );
1206  }
1207 
1208  QString id() const override
1209  {
1210  return QStringLiteral( "source" );
1211  }
1212 
1213  QString pythonImportString() const override
1214  {
1215  return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSource" );
1216  }
1217 
1218  QString className() const override
1219  {
1220  return QStringLiteral( "QgsProcessingParameterFeatureSource" );
1221  }
1222 
1223  QStringList acceptedPythonTypes() const override
1224  {
1225  return QStringList() << QObject::tr( "str: layer ID" )
1226  << QObject::tr( "str: layer name" )
1227  << QObject::tr( "str: layer source" )
1228  << QStringLiteral( "QgsProcessingFeatureSourceDefinition" )
1229  << QStringLiteral( "QgsProperty" )
1230  << QStringLiteral( "QgsVectorLayer" );
1231  }
1232 
1233  QStringList acceptedStringValues() const override
1234  {
1235  return QStringList() << QObject::tr( "Path to a vector layer" );
1236  }
1237 
1238 };
1239 
1248 {
1249  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1250  {
1251  return new QgsProcessingParameterNumber( name );
1252  }
1253 
1254  QString description() const override
1255  {
1256  return QCoreApplication::translate( "Processing", "A numeric parameter, including float or integer values." );
1257  }
1258 
1259  QString name() const override
1260  {
1261  return QCoreApplication::translate( "Processing", "Number" );
1262  }
1263 
1264  QString id() const override
1265  {
1266  return QStringLiteral( "number" );
1267  }
1268 
1269  QString pythonImportString() const override
1270  {
1271  return QStringLiteral( "from qgis.core import QgsProcessingParameterNumber" );
1272  }
1273 
1274  QString className() const override
1275  {
1276  return QStringLiteral( "QgsProcessingParameterNumber" );
1277  }
1278 
1279  QStringList acceptedPythonTypes() const override
1280  {
1281  return QStringList() << QStringLiteral( "int" )
1282  << QStringLiteral( "float" )
1283  << QStringLiteral( "QgsProperty" );
1284  }
1285 
1286  QStringList acceptedStringValues() const override
1287  {
1288  return QStringList() << QObject::tr( "A numeric value" );
1289  }
1290 
1291 };
1292 
1301 {
1302  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1303  {
1304  return new QgsProcessingParameterDistance( name );
1305  }
1306 
1307  QString description() const override
1308  {
1309  return QCoreApplication::translate( "Processing", "A numeric parameter representing a distance measure." );
1310  }
1311 
1312  QString name() const override
1313  {
1314  return QCoreApplication::translate( "Processing", "Distance" );
1315  }
1316 
1317  QString id() const override
1318  {
1319  return QStringLiteral( "distance" );
1320  }
1321 
1322  QString pythonImportString() const override
1323  {
1324  return QStringLiteral( "from qgis.core import QgsProcessingParameterDistance" );
1325  }
1326 
1327  QString className() const override
1328  {
1329  return QStringLiteral( "QgsProcessingParameterDistance" );
1330  }
1331 
1332  QStringList acceptedPythonTypes() const override
1333  {
1334  return QStringList() << QStringLiteral( "int" )
1335  << QStringLiteral( "float" )
1336  << QStringLiteral( "QgsProperty" );
1337  }
1338 
1339  QStringList acceptedStringValues() const override
1340  {
1341  return QStringList() << QObject::tr( "A numeric value" );
1342  }
1343 
1344 
1345 };
1346 
1347 
1356 {
1357  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1358  {
1359  return new QgsProcessingParameterScale( name );
1360  }
1361 
1362  QString description() const override
1363  {
1364  return QCoreApplication::translate( "Processing", "A numeric parameter representing a map scale." );
1365  }
1366 
1367  QString name() const override
1368  {
1369  return QCoreApplication::translate( "Processing", "Scale" );
1370  }
1371 
1372  QString id() const override
1373  {
1374  return QStringLiteral( "scale" );
1375  }
1376 
1377  QString pythonImportString() const override
1378  {
1379  return QStringLiteral( "from qgis.core import QgsProcessingParameterScale" );
1380  }
1381 
1382  QString className() const override
1383  {
1384  return QStringLiteral( "QgsProcessingParameterScale" );
1385  }
1386 
1387  QStringList acceptedPythonTypes() const override
1388  {
1389  return QStringList() << QStringLiteral( "int: scale denominator" )
1390  << QStringLiteral( "float: scale denominator" )
1391  << QStringLiteral( "QgsProperty" );
1392  }
1393 
1394  QStringList acceptedStringValues() const override
1395  {
1396  return QStringList() << QObject::tr( "A numeric value representing the scale denominator" );
1397  }
1398 
1399 
1400 };
1401 
1410 {
1411  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1412  {
1413  return new QgsProcessingParameterBand( name );
1414  }
1415 
1416  QString description() const override
1417  {
1418  return QCoreApplication::translate( "Processing", "A raster band parameter, for selecting an existing band from a raster source." );
1419  }
1420 
1421  QString name() const override
1422  {
1423  return QCoreApplication::translate( "Processing", "Raster Band" );
1424  }
1425 
1426  QString id() const override
1427  {
1428  return QStringLiteral( "band" );
1429  }
1430 
1431  QString pythonImportString() const override
1432  {
1433  return QStringLiteral( "from qgis.core import QgsProcessingParameterBand" );
1434  }
1435 
1436  QString className() const override
1437  {
1438  return QStringLiteral( "QgsProcessingParameterBand" );
1439  }
1440 
1441  QStringList acceptedPythonTypes() const override
1442  {
1443  return QStringList() << QStringLiteral( "int" )
1444  << QStringLiteral( "QgsProperty" );
1445  }
1446 
1447  QStringList acceptedStringValues() const override
1448  {
1449  return QStringList() << QObject::tr( "Integer value representing an existing raster band number" );
1450  }
1451 
1452 
1453 };
1454 
1463 {
1464  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1465  {
1466  return new QgsProcessingParameterFeatureSink( name );
1467  }
1468 
1469  ParameterFlags flags() const override
1470  {
1471  ParameterFlags flags = QgsProcessingParameterType::flags();
1472  flags.setFlag( ParameterFlag::ExposeToModeler, false );
1473  return flags;
1474  }
1475 
1476  QString description() const override
1477  {
1478  return QCoreApplication::translate( "Processing", "A feature sink destination parameter." );
1479  }
1480 
1481  QString name() const override
1482  {
1483  return QCoreApplication::translate( "Processing", "Feature Sink" );
1484  }
1485 
1486  QString id() const override
1487  {
1488  return QStringLiteral( "sink" );
1489  }
1490 
1491  QString pythonImportString() const override
1492  {
1493  return QStringLiteral( "from qgis.core import QgsProcessingParameterFeatureSink" );
1494  }
1495 
1496  QString className() const override
1497  {
1498  return QStringLiteral( "QgsProcessingParameterFeatureSink" );
1499  }
1500 
1501  QStringList acceptedPythonTypes() const override
1502  {
1503  return QStringList() << QObject::tr( "str: destination vector file, e.g. 'd:/test.shp'" )
1504  << QObject::tr( "str: 'memory:' to store result in temporary memory layer" )
1505  << QObject::tr( "str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table" )
1506  << QStringLiteral( "QgsProcessingOutputLayerDefinition" )
1507  << QStringLiteral( "QgsProperty" );
1508  }
1509 
1510  QStringList acceptedStringValues() const override
1511  {
1512  return QStringList() << QObject::tr( "Path for new vector layer" );
1513  }
1514 
1515 
1516 };
1517 
1518 
1527 {
1528  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1529  {
1530  return new QgsProcessingParameterLayout( name );
1531  }
1532 
1533  QString description() const override
1534  {
1535  return QCoreApplication::translate( "Processing", "A print layout parameter." );
1536  }
1537 
1538  QString name() const override
1539  {
1540  return QCoreApplication::translate( "Processing", "Print Layout" );
1541  }
1542 
1543  QString id() const override
1544  {
1545  return QStringLiteral( "layout" );
1546  }
1547 
1548  QString pythonImportString() const override
1549  {
1550  return QStringLiteral( "from qgis.core import QgsProcessingParameterLayout" );
1551  }
1552 
1553  QString className() const override
1554  {
1555  return QStringLiteral( "QgsProcessingParameterLayout" );
1556  }
1557 
1558  QStringList acceptedPythonTypes() const override
1559  {
1560  return QStringList() << QObject::tr( "str: name of print layout in current project" )
1561  << QStringLiteral( "QgsProperty" );
1562  }
1563 
1564  QStringList acceptedStringValues() const override
1565  {
1566  return QStringList() << QObject::tr( "Name of print layout in current project" );
1567  }
1568 
1569 
1570 };
1571 
1572 
1573 
1582 {
1583  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1584  {
1585  return new QgsProcessingParameterLayoutItem( name );
1586  }
1587 
1588  QString description() const override
1589  {
1590  return QCoreApplication::translate( "Processing", "A print layout item parameter." );
1591  }
1592 
1593  QString name() const override
1594  {
1595  return QCoreApplication::translate( "Processing", "Print Layout Item" );
1596  }
1597 
1598  QString id() const override
1599  {
1600  return QStringLiteral( "layoutitem" );
1601  }
1602 
1603  QString pythonImportString() const override
1604  {
1605  return QStringLiteral( "from qgis.core import QgsProcessingParameterLayoutItem" );
1606  }
1607 
1608  QString className() const override
1609  {
1610  return QStringLiteral( "QgsProcessingParameterLayoutItem" );
1611  }
1612 
1613  QStringList acceptedPythonTypes() const override
1614  {
1615  return QStringList() << QObject::tr( "str: UUID of print layout item" )
1616  << QObject::tr( "str: id of print layout item" )
1617  << QStringLiteral( "QgsProperty" );
1618  }
1619 
1620  QStringList acceptedStringValues() const override
1621  {
1622  return QStringList() << QObject::tr( "UUID or item id of layout item" );
1623  }
1624 
1625 
1626 };
1627 
1628 
1637 {
1638  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1639  {
1640  return new QgsProcessingParameterColor( name );
1641  }
1642 
1643  QString description() const override
1644  {
1645  return QCoreApplication::translate( "Processing", "A color parameter." );
1646  }
1647 
1648  QString name() const override
1649  {
1650  return QCoreApplication::translate( "Processing", "Color" );
1651  }
1652 
1653  QString id() const override
1654  {
1655  return QStringLiteral( "color" );
1656  }
1657 
1658  QString pythonImportString() const override
1659  {
1660  return QStringLiteral( "from qgis.core import QgsProcessingParameterColor" );
1661  }
1662 
1663  QString className() const override
1664  {
1665  return QStringLiteral( "QgsProcessingParameterColor" );
1666  }
1667 
1668  QStringList acceptedPythonTypes() const override
1669  {
1670  return QStringList() << QObject::tr( "str: string representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" )
1671  << QStringLiteral( "QColor" )
1672  << QStringLiteral( "QgsProperty" );
1673  }
1674 
1675  QStringList acceptedStringValues() const override
1676  {
1677  return QStringList() << QObject::tr( "String representation of color, e.g #ff0000 or rgba(200,100,50,0.8)" );
1678  }
1679 
1680 
1681 };
1682 
1691 {
1692  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1693  {
1694  return new QgsProcessingParameterCoordinateOperation( name );
1695  }
1696 
1697  QString description() const override
1698  {
1699  return QCoreApplication::translate( "Processing", "A coordinate operation parameter." );
1700  }
1701 
1702  QString name() const override
1703  {
1704  return QCoreApplication::translate( "Processing", "Coordinate Operation" );
1705  }
1706 
1707  QString id() const override
1708  {
1709  return QStringLiteral( "coordinateoperation" );
1710  }
1711 
1712  QString pythonImportString() const override
1713  {
1714  return QStringLiteral( "from qgis.core import QgsProcessingParameterCoordinateOperation" );
1715  }
1716 
1717  QString className() const override
1718  {
1719  return QStringLiteral( "QgsProcessingParameterCoordinateOperation" );
1720  }
1721 
1722  QStringList acceptedPythonTypes() const override
1723  {
1724  return QStringList() << QObject::tr( "str: string representation of a Proj coordinate operation" );
1725  }
1726 
1727  QStringList acceptedStringValues() const override
1728  {
1729  return QStringList() << QObject::tr( "String representation of Proj coordinate operation" );
1730  }
1731 
1732 
1733 };
1734 
1735 
1744 {
1745  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1746  {
1747  return new QgsProcessingParameterMapTheme( name );
1748  }
1749 
1750  QString description() const override
1751  {
1752  return QCoreApplication::translate( "Processing", "A map theme parameter." );
1753  }
1754 
1755  QString name() const override
1756  {
1757  return QCoreApplication::translate( "Processing", "Map Theme" );
1758  }
1759 
1760  QString id() const override
1761  {
1762  return QStringLiteral( "maptheme" );
1763  }
1764 
1765  QString pythonImportString() const override
1766  {
1767  return QStringLiteral( "from qgis.core import QgsProcessingParameterMapTheme" );
1768  }
1769 
1770  QString className() const override
1771  {
1772  return QStringLiteral( "QgsProcessingParameterMapTheme" );
1773  }
1774 
1775  QStringList acceptedPythonTypes() const override
1776  {
1777  return QStringList() << QObject::tr( "str: name of an existing map theme" )
1778  << QStringLiteral( "QgsProperty" );
1779  }
1780 
1781  QStringList acceptedStringValues() const override
1782  {
1783  return QStringList() << QObject::tr( "Name of an existing map theme" );
1784  }
1785 
1786 };
1787 
1796 {
1797  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1798  {
1799  return new QgsProcessingParameterDateTime( name );
1800  }
1801 
1802  QString description() const override
1803  {
1804  return QCoreApplication::translate( "Processing", "A datetime parameter, including datetime, date or time values." );
1805  }
1806 
1807  QString name() const override
1808  {
1809  return QCoreApplication::translate( "Processing", "Datetime" );
1810  }
1811 
1812  QString id() const override
1813  {
1814  return QStringLiteral( "datetime" );
1815  }
1816 
1817  QString pythonImportString() const override
1818  {
1819  return QStringLiteral( "from qgis.core import QgsProcessingParameterDateTime" );
1820  }
1821 
1822  QString className() const override
1823  {
1824  return QStringLiteral( "QgsProcessingParameterDateTime" );
1825  }
1826 
1827  QStringList acceptedPythonTypes() const override
1828  {
1829  return QStringList() << QStringLiteral( "str" )
1830  << QStringLiteral( "QDateTime" )
1831  << QStringLiteral( "QDate" )
1832  << QStringLiteral( "QTime" )
1833  << QStringLiteral( "QgsProperty" );
1834  }
1835 
1836  QStringList acceptedStringValues() const override
1837  {
1838  return QStringList() << QObject::tr( "A datetime value in ISO format" );
1839  }
1840 
1841 };
1842 
1843 
1852 {
1853  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1854  {
1855  return new QgsProcessingParameterProviderConnection( name, QString(), QString() );
1856  }
1857 
1858  QString description() const override
1859  {
1860  return QCoreApplication::translate( "Processing", "A connection name parameter, for registered database connections." );
1861  }
1862 
1863  QString name() const override
1864  {
1865  return QCoreApplication::translate( "Processing", "Connection Name" );
1866  }
1867 
1868  QString id() const override
1869  {
1870  return QStringLiteral( "providerconnection" );
1871  }
1872 
1873  QString pythonImportString() const override
1874  {
1875  return QStringLiteral( "from qgis.core import QgsProcessingParameterProviderConnection" );
1876  }
1877 
1878  QString className() const override
1879  {
1880  return QStringLiteral( "QgsProcessingParameterProviderConnection" );
1881  }
1882 
1883  QStringList acceptedPythonTypes() const override
1884  {
1885  return QStringList() << QStringLiteral( "str" )
1886  << QStringLiteral( "QgsProperty" );
1887  }
1888 
1889  QStringList acceptedStringValues() const override
1890  {
1891  return QStringList() << QObject::tr( "Name of registered database connection" );
1892  }
1893 
1894 };
1895 
1904 {
1905  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1906  {
1907  return new QgsProcessingParameterDatabaseSchema( name, QString(), QString() );
1908  }
1909 
1910  QString description() const override
1911  {
1912  return QCoreApplication::translate( "Processing", "A database schema parameter." );
1913  }
1914 
1915  QString name() const override
1916  {
1917  return QCoreApplication::translate( "Processing", "Database Schema" );
1918  }
1919 
1920  QString id() const override
1921  {
1922  return QStringLiteral( "databaseschema" );
1923  }
1924 
1925  QString pythonImportString() const override
1926  {
1927  return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseSchema" );
1928  }
1929 
1930  QString className() const override
1931  {
1932  return QStringLiteral( "QgsProcessingParameterDatabaseSchema" );
1933  }
1934 
1935  QStringList acceptedPythonTypes() const override
1936  {
1937  return QStringList() << QStringLiteral( "str" )
1938  << QStringLiteral( "QgsProperty" );
1939  }
1940 
1941  QStringList acceptedStringValues() const override
1942  {
1943  return QStringList() << QObject::tr( "Name of existing database schema" );
1944  }
1945 
1946 };
1947 
1948 
1957 {
1958  QgsProcessingParameterDefinition *create( const QString &name ) const override SIP_FACTORY
1959  {
1960  return new QgsProcessingParameterDatabaseTable( name, QString(), QString(), QString() );
1961  }
1962 
1963  QString description() const override
1964  {
1965  return QCoreApplication::translate( "Processing", "A database table parameter." );
1966  }
1967 
1968  QString name() const override
1969  {
1970  return QCoreApplication::translate( "Processing", "Database Table" );
1971  }
1972 
1973  QString id() const override
1974  {
1975  return QStringLiteral( "databasetable" );
1976  }
1977 
1978  QString pythonImportString() const override
1979  {
1980  return QStringLiteral( "from qgis.core import QgsProcessingParameterDatabaseTable" );
1981  }
1982 
1983  QString className() const override
1984  {
1985  return QStringLiteral( "QgsProcessingParameterDatabaseTable" );
1986  }
1987 
1988  QStringList acceptedPythonTypes() const override
1989  {
1990  return QStringList() << QStringLiteral( "str" )
1991  << QStringLiteral( "QgsProperty" );
1992  }
1993 
1994  QStringList acceptedStringValues() const override
1995  {
1996  return QStringList() << QObject::tr( "Name of existing database table" );
1997  }
1998 
1999 };
2000 #endif // QGSPROCESSINGPARAMETERTYPEIMPL_H
QgsProcessingParameterMatrix
Definition: qgsprocessingparameters.h:1670
QgsProcessingParameterTypeCrs
A crs parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:357
QgsProcessingParameterType::create
virtual QgsProcessingParameterDefinition * create(const QString &name) const =0
Creates a new parameter of this type.
qgsprocessingparametertype.h
QgsProcessingParameterTypeAuthConfig
A authentication configuration parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1091
QgsProcessingParameterTypeProviderConnection
A provider connection name parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1851
QgsProcessingParameterNumber
Definition: qgsprocessingparameters.h:1838
QgsProcessingParameterTypeCoordinateOperation
A coordinate operation parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1690
QgsProcessingParameterTypeMapTheme
A map theme parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1743
QgsProcessingParameterRasterDestination
Definition: qgsprocessingparameters.h:2944
QgsProcessingParameterMapTheme
Definition: qgsprocessingparameters.h:3460
QgsProcessingParameterTypeMultipleLayers
A parameter for processing algorithms which accepts multiple map layers.
Definition: qgsprocessingparametertypeimpl.h:1142
QgsProcessingParameterType::description
virtual QString description() const =0
A human readable and translatable description for this parameter type.
qgis.h
QgsProcessingParameterType::name
virtual QString name() const =0
A human readable and translatable short name for this parameter type.
QgsProcessingParameterTypeMatrix
A table (matrix) parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:641
QgsProcessingParameterDefinition
Definition: qgsprocessingparameters.h:330
QgsProcessingParameterFeatureSource
Definition: qgsprocessingparameters.h:2612
QgsProcessingParameterMapLayer
Definition: qgsprocessingparameters.h:2456
QgsProcessingParameterTypeVectorDestination
A vector layer destination parameter, for specifying the destination path for a vector layer created ...
Definition: qgsprocessingparametertypeimpl.h:797
QgsProcessingParameterMultipleLayers
Definition: qgsprocessingparameters.h:1756
QgsProcessingParameterTypeExtent
A rectangular map extent parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:581
QgsProcessingParameterTypeDateTime
A datetime parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1795
QgsProcessingParameterType
Makes metadata of processing parameters available.
Definition: qgsprocessingparametertype.h:33
SIP_FACTORY
#define SIP_FACTORY
Definition: qgis_sip.h:76
QgsProcessingParameterAuthConfig
Definition: qgsprocessingparameters.h:2262
QgsProcessingParameterColor
Definition: qgsprocessingparameters.h:3290
QgsProcessingParameterDatabaseTable
Definition: qgsprocessingparameters.h:3740
QgsProcessingParameterFeatureSink
Definition: qgsprocessingparameters.h:2773
QgsProcessingParameterTypeExpression
An expression parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:306
QgsProcessingParameterScale
Definition: qgsprocessingparameters.h:2014
QgsProcessingParameterRange
Definition: qgsprocessingparameters.h:2048
QgsProcessingParameterTypeBoolean
A boolean parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:252
QgsProcessingParameterTypeFolderDestination
A folder destination parameter, for specifying the destination path for a folder created by the algor...
Definition: qgsprocessingparametertypeimpl.h:919
QgsProcessingParameterMeshLayer
Definition: qgsprocessingparameters.h:2422
QgsProcessingParameterCrs
Definition: qgsprocessingparameters.h:1470
QgsProcessingParameterTypeDatabaseTable
A database table name parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1956
QgsProcessingParameterTypeDatabaseSchema
A database schema name parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1903
QgsProcessingParameterTypeLayout
A print layout parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1526
QgsProcessingParameterTypeVectorLayer
A vector layer parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:142
QgsProcessingParameterFileDestination
Definition: qgsprocessingparameters.h:3005
QgsProcessingParameterLayoutItem
Definition: qgsprocessingparameters.h:3216
QgsProcessingParameterType::id
virtual QString id() const =0
A static id for this type which will be used for storing this parameter type.
qgis_sip.h
QgsProcessingParameterString
Definition: qgsprocessingparameters.h:2202
QgsProcessingParameterTypeRasterLayer
A raster layer parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:35
QgsProcessingParameterExtent
Definition: qgsprocessingparameters.h:1502
QgsProcessingParameterTypeScale
A scale parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1355
QgsProcessingParameterTypeFile
An input file or folder parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:693
QgsProcessingParameterRasterLayer
Definition: qgsprocessingparameters.h:2101
QgsProcessingParameterTypeColor
A color parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1636
QgsProcessingParameterProviderConnection
Definition: qgsprocessingparameters.h:3619
QgsProcessingParameterTypePoint
A point parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:474
QgsProcessingParameterFile
Definition: qgsprocessingparameters.h:1567
QgsProcessingParameterVectorLayer
Definition: qgsprocessingparameters.h:2382
QgsProcessingParameterLayout
Definition: qgsprocessingparameters.h:3178
QgsProcessingParameterVectorDestination
Definition: qgsprocessingparameters.h:2871
QgsProcessingParameterDatabaseSchema
Definition: qgsprocessingparameters.h:3678
QgsProcessingParameterDistance
Definition: qgsprocessingparameters.h:1941
QgsProcessingParameterPoint
Definition: qgsprocessingparameters.h:1535
QgsProcessingParameterTypeFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1191
QgsProcessingParameterType::flags
virtual ParameterFlags flags() const
Determines if this parameter is available in the modeler.
Definition: qgsprocessingparametertype.cpp:20
QgsProcessingParameterType::className
virtual QString className() const
Returns the corresponding class name for the parameter type.
Definition: qgsprocessingparametertype.h:103
QgsProcessingParameterTypeRange
A numeric range parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:421
QgsProcessingParameterBoolean
Definition: qgsprocessingparameters.h:1439
QgsProcessingParameterTypeFeatureSink
A feature sink parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1462
QgsProcessingParameterDateTime
Definition: qgsprocessingparameters.h:3503
QgsProcessingParameterTypeLayoutItem
A print layout item parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1581
QgsProcessingParameterType::pythonImportString
virtual QString pythonImportString() const
Returns a valid Python import string for importing the corresponding parameter type,...
Definition: qgsprocessingparametertype.h:93
QgsProcessingParameterExpression
Definition: qgsprocessingparameters.h:2294
QgsProcessingParameterTypeField
A vector layer or feature source field parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:744
QgsProcessingParameterTypeFileDestination
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
Definition: qgsprocessingparametertypeimpl.h:858
QgsProcessingParameterType::acceptedStringValues
virtual QStringList acceptedStringValues() const
Returns a descriptive list of the possible string values acceptable for the parameter.
Definition: qgsprocessingparametertype.cpp:35
QgsProcessingParameterBand
Definition: qgsprocessingparameters.h:3103
QgsProcessingParameterTypeNumber
A numeric parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1247
QgsProcessingParameterTypeMeshLayer
A mesh layer parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:89
QgsProcessingParameterTypeString
A string parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1039
QgsProcessingParameterEnum
Definition: qgsprocessingparameters.h:2134
QgsProcessingParameterCoordinateOperation
Definition: qgsprocessingparameters.h:3354
QgsProcessingParameterType::acceptedPythonTypes
virtual QStringList acceptedPythonTypes() const
Returns a list of the Python data types accepted as values for the parameter.
Definition: qgsprocessingparametertype.cpp:30
QgsProcessingParameterTypeDistance
A distance parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1300
QgsProcessingParameterField
Definition: qgsprocessingparameters.h:2495
QgsProcessingParameterTypeMapLayer
A generic map layer parameter for processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:196
QgsProcessingParameterTypeBand
A raster band parameter for Processing algorithms.
Definition: qgsprocessingparametertypeimpl.h:1409
QgsProcessingParameterTypeRasterDestination
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Definition: qgsprocessingparametertypeimpl.h:979
QgsProcessingParameterFolderDestination
Definition: qgsprocessingparameters.h:3068
QgsProcessingParameterTypeEnum
An enum based parameter for processing algorithms, allowing for selection from predefined values.
Definition: qgsprocessingparametertypeimpl.h:528