QGIS API Documentation 3.35.0-Master (b0df9e2bb04)
Loading...
Searching...
No Matches
qgsprocessingparametervectortilewriterlayers.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingparametervectortilewriterlayers.cpp
3 ---------------------
4 Date : April 2020
5 Copyright : (C) 2020 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
18#include "qgsvectorlayer.h"
19
20
22 : QgsProcessingParameterDefinition( name, description, QVariant(), false )
23{
24}
25
30
35
37{
38 if ( !input.isValid() )
39 return mFlags & FlagOptional;
40
41 if ( input.type() != QVariant::List )
42 return false;
43
44 const QVariantList inputList = input.toList();
45 for ( const QVariant &inputItem : inputList )
46 {
47 if ( inputItem.type() != QVariant::Map )
48 return false;
49 QVariantMap inputItemMap = inputItem.toMap();
50
51 // "layer" is required - pointing to a vector layer
52 if ( !inputItemMap.contains( "layer" ) )
53 return false;
54
55 const QVariant inputItemLayer = inputItemMap["layer"];
56
57 if ( qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( inputItemLayer ) ) )
58 continue;
59
60 if ( !context )
61 continue; // when called without context, we will skip checking whether the layer can be resolved
62
63 if ( !QgsProcessingUtils::mapLayerFromString( inputItemLayer.toString(), *context ) )
64 return false;
65 }
66
67 return true;
68}
69
71{
72 QStringList parts;
73 const QList<QgsVectorTileWriter::Layer> layers = parameterAsLayers( value, context );
74 for ( const QgsVectorTileWriter::Layer &layer : layers )
75 {
76 QStringList layerDefParts;
77 layerDefParts << QStringLiteral( "'layer': " ) + QgsProcessingUtils::stringToPythonLiteral( QgsProcessingUtils::normalizeLayerSource( layer.layer()->source() ) );
78 if ( !layer.filterExpression().isEmpty() )
79 layerDefParts << QStringLiteral( "'filterExpression': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.filterExpression() );
80 if ( !layer.layerName().isEmpty() )
81 layerDefParts << QStringLiteral( "'layerName': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.layerName() );
82 if ( layer.minZoom() >= 0 )
83 layerDefParts << QStringLiteral( "'minZoom': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.minZoom() );
84 if ( layer.maxZoom() >= 0 )
85 layerDefParts << QStringLiteral( "'maxZoom': " ) + QgsProcessingUtils::variantToPythonLiteral( layer.maxZoom() );
86
87 const QString layerDef = QStringLiteral( "{ %1 }" ).arg( layerDefParts.join( ',' ) );
88 parts << layerDef;
89 }
90 return parts.join( ',' ).prepend( '[' ).append( ']' );
91}
92
94{
95 switch ( outputType )
96 {
98 {
99 QString code = QStringLiteral( "QgsProcessingParameterVectorTileWriterLayers('%1', %2)" )
101 return code;
102 }
103 }
104 return QString();
105}
106
107QList<QgsVectorTileWriter::Layer> QgsProcessingParameterVectorTileWriterLayers::parameterAsLayers( const QVariant &layersVariant, QgsProcessingContext &context )
108{
109 QList<QgsVectorTileWriter::Layer> layers;
110 const QVariantList layersVariantList = layersVariant.toList();
111 for ( const QVariant &layerItem : layersVariantList )
112 {
113 const QVariantMap layerVariantMap = layerItem.toMap();
114 layers << variantMapAsLayer( layerVariantMap, context );
115 }
116 return layers;
117}
118
120{
121 const QVariant layerVariant = layerVariantMap["layer"];
122
123 QgsVectorLayer *inputLayer = nullptr;
124 if ( ( inputLayer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( layerVariant ) ) ) )
125 {
126 // good
127 }
128 else if ( ( inputLayer = qobject_cast< QgsVectorLayer * >( QgsProcessingUtils::mapLayerFromString( layerVariant.toString(), context ) ) ) )
129 {
130 // good
131 }
132 else
133 {
134 // bad
135 }
136
137 QgsVectorTileWriter::Layer writerLayer( inputLayer );
138 if ( layerVariantMap.contains( "filterExpression" ) )
139 writerLayer.setFilterExpression( layerVariantMap["filterExpression"].toString() );
140 if ( layerVariantMap.contains( "minZoom" ) )
141 writerLayer.setMinZoom( layerVariantMap["minZoom"].toInt() );
142 if ( layerVariantMap.contains( "maxZoom" ) )
143 writerLayer.setMaxZoom( layerVariantMap["maxZoom"].toInt() );
144 if ( layerVariantMap.contains( "layerName" ) )
145 writerLayer.setLayerName( layerVariantMap["layerName"].toString() );
146
147 return writerLayer;
148}
149
151{
152 QVariantMap vm;
153 if ( !layer.layer() )
154 return vm;
155
156 vm["layer"] = layer.layer()->id();
157 vm["minZoom"] = layer.minZoom();
158 vm["maxZoom"] = layer.maxZoom();
159 vm["layerName"] = layer.layerName();
160 vm["filterExpression"] = layer.filterExpression();
161 return vm;
162}
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
Contains information about the context in which a processing algorithm is executed.
Base class for the definition of processing parameters.
QString description() const
Returns the description for the parameter.
QString name() const
Returns the name of the parameter.
A parameter for processing algorithms that need a list of input vector layers for writing of vector t...
QString valueAsPythonString(const QVariant &value, QgsProcessingContext &context) const override
Returns a string version of the parameter input value, which is suitable for use as an input paramete...
static QList< QgsVectorTileWriter::Layer > parameterAsLayers(const QVariant &layersVariant, QgsProcessingContext &context)
Converts a QVariant value (a QVariantList) to a list of input layers.
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
static QgsVectorTileWriter::Layer variantMapAsLayer(const QVariantMap &layerVariantMap, QgsProcessingContext &context)
Converts a QVariant value (a QVariantMap) to a single input layer.
static QVariantMap layerAsVariantMap(const QgsVectorTileWriter::Layer &layer)
Converts a single input layer to QVariant representation (a QVariantMap)
bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const override
Checks whether the specified input value is acceptable for the parameter.
QgsProcessingParameterVectorTileWriterLayers(const QString &name, const QString &description=QString())
Constructor for QgsProcessingParameterVectorTileWriterLayers.
QString asPythonString(QgsProcessing::PythonOutputType outputType=QgsProcessing::PythonQgsProcessingAlgorithmSubclass) const override
Returns the parameter definition as a Python command which can be used within a Python Processing scr...
static QString typeName()
Returns the type name for the parameter class.
static QString stringToPythonLiteral(const QString &string)
Converts a string to a Python string literal.
static QString normalizeLayerSource(const QString &source)
Normalizes a layer source string for safe comparison across different operating system environments.
static QString variantToPythonLiteral(const QVariant &value)
Converts a variant to a Python literal.
static QgsMapLayer * mapLayerFromString(const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers=true, QgsProcessingUtils::LayerHint typeHint=QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags=QgsProcessing::LayerOptionsFlags())
Interprets a string as a map layer within the supplied context.
PythonOutputType
Available Python output types.
@ PythonQgsProcessingAlgorithmSubclass
Full Python QgsProcessingAlgorithm subclass.
Represents a vector layer which manages a vector based data sets.
Configuration of a single input vector layer to be included in the output.
QString layerName() const
Returns layer name in the output. If not set, layer()->name() will be used.
void setLayerName(const QString &name)
Sets layer name in the output. If not set, layer()->name() will be used.
QgsVectorLayer * layer() const
Returns vector layer of this entry.
void setMaxZoom(int maxzoom)
Sets maximum zoom level at which this layer will be used. Negative value means no max....
void setFilterExpression(const QString &expr)
Sets filter expression. If not empty, only features matching the expression will be used.
void setMinZoom(int minzoom)
Sets minimum zoom level at which this layer will be used. Negative value means no min....
QString filterExpression() const
Returns filter expression. If not empty, only features matching the expression will be used.
int maxZoom() const
Returns maximum zoom level at which this layer will be used. Negative value means no max....
int minZoom() const
Returns minimum zoom level at which this layer will be used. Negative value means no min....