QGIS API Documentation 3.43.0-Master (6c62b930b02)
qgsprocessingfieldmapwidgetwrapper.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingfieldmapwidgetwrapper.cpp
3 ---------------------
4 Date : June 2020
5 Copyright : (C) 2020 by Nyall Dawson
6 Email : nyall dot dawson 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#include "moc_qgsprocessingfieldmapwidgetwrapper.cpp"
18
19#include <QBoxLayout>
20#include <QLineEdit>
21#include <QMessageBox>
22#include <QPushButton>
23#include <QStandardItemModel>
24#include <QToolButton>
25#include <QItemSelectionModel>
26
27#include "qgspanelwidget.h"
28
31
33
35
36//
37// QgsProcessingFieldMapPanelWidget
38//
39
40
41QgsProcessingFieldMapPanelWidget::QgsProcessingFieldMapPanelWidget( QWidget *parent )
42 : QgsPanelWidget( parent )
43{
44 setupUi( this );
45
46 mModel = mFieldsView->model();
47 mFieldsView->setDestinationEditable( true );
48
49 mLayerCombo->setAllowEmptyLayer( true );
50 mLayerCombo->setFilters( Qgis::LayerFilter::VectorLayer );
51
52 connect( mResetButton, &QPushButton::clicked, this, &QgsProcessingFieldMapPanelWidget::loadFieldsFromLayer );
53 connect( mAddButton, &QPushButton::clicked, this, &QgsProcessingFieldMapPanelWidget::addField );
54 connect( mDeleteButton, &QPushButton::clicked, mFieldsView, &QgsFieldMappingWidget::removeSelectedFields );
55 connect( mUpButton, &QPushButton::clicked, mFieldsView, &QgsFieldMappingWidget::moveSelectedFieldsUp );
56 connect( mDownButton, &QPushButton::clicked, mFieldsView, &QgsFieldMappingWidget::moveSelectedFieldsDown );
57 connect( mInvertSelectionButton, &QPushButton::clicked, mFieldsView, &QgsFieldMappingWidget::invertSelection );
58 connect( mLoadLayerFieldsButton, &QPushButton::clicked, this, &QgsProcessingFieldMapPanelWidget::loadLayerFields );
59
60
61 connect( mFieldsView, &QgsFieldMappingWidget::changed, this, [=] {
62 if ( !mBlockChangedSignal )
63 {
64 emit changed();
65 }
66 } );
67}
68
69void QgsProcessingFieldMapPanelWidget::setLayer( QgsVectorLayer *layer )
70{
71 if ( layer == mLayer )
72 return;
73
74 mLayer = layer;
75 mFieldsView->setSourceLayer( mLayer );
76 if ( mModel->rowCount() == 0 )
77 {
78 loadFieldsFromLayer();
79 return;
80 }
81
82 QMessageBox dlg( this );
83 dlg.setText( tr( "Do you want to reset the field mapping?" ) );
84 dlg.setStandardButtons(
85 QMessageBox::StandardButtons( QMessageBox::Yes | QMessageBox::No )
86 );
87 dlg.setDefaultButton( QMessageBox::No );
88 if ( dlg.exec() == QMessageBox::Yes )
89 {
90 loadFieldsFromLayer();
91 }
92}
93
94QgsVectorLayer *QgsProcessingFieldMapPanelWidget::layer()
95{
96 return mLayer;
97}
98
99QVariant QgsProcessingFieldMapPanelWidget::value() const
100{
101 const QList<QgsFieldMappingModel::Field> mapping = mFieldsView->mapping();
102
103 QVariantList results;
104 results.reserve( mapping.size() );
105 for ( const QgsFieldMappingModel::Field &field : mapping )
106 {
107 QVariantMap def;
108 def.insert( QStringLiteral( "name" ), field.field.name() );
109 def.insert( QStringLiteral( "type" ), static_cast<int>( field.field.type() ) );
110 def.insert( QStringLiteral( "type_name" ), field.field.typeName() );
111 def.insert( QStringLiteral( "length" ), field.field.length() );
112 def.insert( QStringLiteral( "precision" ), field.field.precision() );
113 def.insert( QStringLiteral( "sub_type" ), static_cast<int>( field.field.subType() ) );
114 def.insert( QStringLiteral( "expression" ), field.expression );
115 def.insert( QStringLiteral( "alias" ), field.field.alias() );
116 def.insert( QStringLiteral( "comment" ), field.field.comment() );
117 results.append( def );
118 }
119 return results;
120}
121
122void QgsProcessingFieldMapPanelWidget::setValue( const QVariant &value )
123{
124 if ( value.userType() != QMetaType::Type::QVariantList )
125 return;
126
127 QgsFields destinationFields;
128 QMap<QString, QString> expressions;
129
130 const QgsFields layerFields = mLayer ? mLayer->fields() : QgsFields();
131 const QVariantList fields = value.toList();
132 for ( const QVariant &field : fields )
133 {
134 const QVariantMap map = field.toMap();
135 QgsField f( map.value( QStringLiteral( "name" ) ).toString(), static_cast<QMetaType::Type>( map.value( QStringLiteral( "type" ), static_cast<int>( QMetaType::Type::UnknownType ) ).toInt() ), map.value( QStringLiteral( "type_name" ), QVariant::typeToName( static_cast<QMetaType::Type>( map.value( QStringLiteral( "type" ), static_cast<int>( QMetaType::Type::UnknownType ) ).toInt() ) ) ).toString(), map.value( QStringLiteral( "length" ), 0 ).toInt(), map.value( QStringLiteral( "precision" ), 0 ).toInt(), QString(), static_cast<QMetaType::Type>( map.value( QStringLiteral( "sub_type" ), QgsVariantUtils::createNullVariant( QMetaType::Type::UnknownType ) ).toInt() ) );
136 f.setAlias( map.value( QStringLiteral( "alias" ) ).toString() );
137 f.setComment( map.value( QStringLiteral( "comment" ) ).toString() );
138
139 if ( map.contains( QStringLiteral( "constraints" ) ) )
140 {
141 const QgsFieldConstraints::Constraints constraints = static_cast<QgsFieldConstraints::Constraints>( map.value( QStringLiteral( "constraints" ), 0 ).toInt() );
142 QgsFieldConstraints fieldConstraints;
143
144 if ( constraints & QgsFieldConstraints::ConstraintNotNull )
146 if ( constraints & QgsFieldConstraints::ConstraintUnique )
150
151 f.setConstraints( fieldConstraints );
152 }
153
154 if ( !map.value( QStringLiteral( "expression" ) ).toString().isEmpty() )
155 {
156 expressions.insert( f.name(), map.value( QStringLiteral( "expression" ) ).toString() );
157 }
158
159 destinationFields.append( f );
160 }
161
162 mBlockChangedSignal = true;
163 if ( destinationFields.size() > 0 )
164 mFieldsView->setDestinationFields( destinationFields, expressions );
165 mBlockChangedSignal = false;
166
167 emit changed();
168}
169
170void QgsProcessingFieldMapPanelWidget::registerExpressionContextGenerator( const QgsExpressionContextGenerator *generator )
171{
172 mFieldsView->registerExpressionContextGenerator( generator );
173}
174
175void QgsProcessingFieldMapPanelWidget::loadFieldsFromLayer()
176{
177 if ( mLayer )
178 {
179 mFieldsView->setSourceFields( mLayer->fields() );
180 mFieldsView->setDestinationFields( mLayer->fields() );
181 }
182}
183
184void QgsProcessingFieldMapPanelWidget::addField()
185{
186 const int rowCount = mModel->rowCount();
187 mModel->appendField( QgsField( QStringLiteral( "new_field" ) ) );
188 const QModelIndex index = mModel->index( rowCount, 0 );
189 mFieldsView->selectionModel()->select(
190 index,
191 QItemSelectionModel::SelectionFlags(
192 QItemSelectionModel::Clear | QItemSelectionModel::Select | QItemSelectionModel::Current | QItemSelectionModel::Rows
193 )
194 );
195 mFieldsView->scrollTo( index );
196}
197
198void QgsProcessingFieldMapPanelWidget::loadLayerFields()
199{
200 if ( QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( mLayerCombo->currentLayer() ) )
201 {
202 mFieldsView->setDestinationFields( vl->fields() );
203 }
204}
205
206//
207// QgsProcessingFieldMapParameterDefinitionWidget
208//
209
210QgsProcessingFieldMapParameterDefinitionWidget::QgsProcessingFieldMapParameterDefinitionWidget( QgsProcessingContext &context, const QgsProcessingParameterWidgetContext &widgetContext, const QgsProcessingParameterDefinition *definition, const QgsProcessingAlgorithm *algorithm, QWidget *parent )
211 : QgsProcessingAbstractParameterDefinitionWidget( context, widgetContext, definition, algorithm, parent )
212{
213 QVBoxLayout *vlayout = new QVBoxLayout();
214 vlayout->setContentsMargins( 0, 0, 0, 0 );
215
216 vlayout->addWidget( new QLabel( tr( "Parent layer" ) ) );
217
218 mParentLayerComboBox = new QComboBox();
219 mParentLayerComboBox->addItem( tr( "None" ), QVariant() );
220
221 QString initialParent;
222 if ( const QgsProcessingParameterFieldMapping *mapParam = dynamic_cast<const QgsProcessingParameterFieldMapping *>( definition ) )
223 initialParent = mapParam->parentLayerParameterName();
224
225 if ( auto *lModel = widgetContext.model() )
226 {
227 // populate combo box with other model input choices
228 const QMap<QString, QgsProcessingModelParameter> components = lModel->parameterComponents();
229 for ( auto it = components.constBegin(); it != components.constEnd(); ++it )
230 {
231 if ( const QgsProcessingParameterFeatureSource *definition = dynamic_cast<const QgsProcessingParameterFeatureSource *>( lModel->parameterDefinition( it.value().parameterName() ) ) )
232 {
233 mParentLayerComboBox->addItem( definition->description(), definition->name() );
234 if ( !initialParent.isEmpty() && initialParent == definition->name() )
235 {
236 mParentLayerComboBox->setCurrentIndex( mParentLayerComboBox->count() - 1 );
237 }
238 }
239 else if ( const QgsProcessingParameterVectorLayer *definition = dynamic_cast<const QgsProcessingParameterVectorLayer *>( lModel->parameterDefinition( it.value().parameterName() ) ) )
240 {
241 mParentLayerComboBox->addItem( definition->description(), definition->name() );
242 if ( !initialParent.isEmpty() && initialParent == definition->name() )
243 {
244 mParentLayerComboBox->setCurrentIndex( mParentLayerComboBox->count() - 1 );
245 }
246 }
247 }
248 }
249
250 if ( mParentLayerComboBox->count() == 1 && !initialParent.isEmpty() )
251 {
252 // if no parent candidates found, we just add the existing one as a placeholder
253 mParentLayerComboBox->addItem( initialParent, initialParent );
254 mParentLayerComboBox->setCurrentIndex( mParentLayerComboBox->count() - 1 );
255 }
256
257 vlayout->addWidget( mParentLayerComboBox );
258 setLayout( vlayout );
259}
260
261QgsProcessingParameterDefinition *QgsProcessingFieldMapParameterDefinitionWidget::createParameter( const QString &name, const QString &description, Qgis::ProcessingParameterFlags flags ) const
262{
263 auto param = std::make_unique<QgsProcessingParameterFieldMapping>( name, description, mParentLayerComboBox->currentData().toString() );
264 param->setFlags( flags );
265 return param.release();
266}
267
268//
269// QgsProcessingFieldMapWidgetWrapper
270//
271
272QgsProcessingFieldMapWidgetWrapper::QgsProcessingFieldMapWidgetWrapper( const QgsProcessingParameterDefinition *parameter, Qgis::ProcessingMode type, QWidget *parent )
273 : QgsAbstractProcessingParameterWidgetWrapper( parameter, type, parent )
274{
275}
276
277QString QgsProcessingFieldMapWidgetWrapper::parameterType() const
278{
280}
281
282QgsAbstractProcessingParameterWidgetWrapper *QgsProcessingFieldMapWidgetWrapper::createWidgetWrapper( const QgsProcessingParameterDefinition *parameter, Qgis::ProcessingMode type )
283{
284 return new QgsProcessingFieldMapWidgetWrapper( parameter, type );
285}
286
287QWidget *QgsProcessingFieldMapWidgetWrapper::createWidget()
288{
289 mPanel = new QgsProcessingFieldMapPanelWidget( nullptr );
290 mPanel->setToolTip( parameterDefinition()->toolTip() );
291 mPanel->registerExpressionContextGenerator( this );
292
293 connect( mPanel, &QgsProcessingFieldMapPanelWidget::changed, this, [=] {
294 emit widgetValueHasChanged( this );
295 } );
296
297 return mPanel;
298}
299
300QgsProcessingAbstractParameterDefinitionWidget *QgsProcessingFieldMapWidgetWrapper::createParameterDefinitionWidget( QgsProcessingContext &context, const QgsProcessingParameterWidgetContext &widgetContext, const QgsProcessingParameterDefinition *definition, const QgsProcessingAlgorithm *algorithm )
301{
302 return new QgsProcessingFieldMapParameterDefinitionWidget( context, widgetContext, definition, algorithm );
303}
304
305void QgsProcessingFieldMapWidgetWrapper::postInitialize( const QList<QgsAbstractProcessingParameterWidgetWrapper *> &wrappers )
306{
308 switch ( type() )
309 {
312 {
313 for ( const QgsAbstractProcessingParameterWidgetWrapper *wrapper : wrappers )
314 {
315 if ( wrapper->parameterDefinition()->name() == static_cast<const QgsProcessingParameterFieldMapping *>( parameterDefinition() )->parentLayerParameterName() )
316 {
317 setParentLayerWrapperValue( wrapper );
319 setParentLayerWrapperValue( wrapper );
320 } );
321 break;
322 }
323 }
324 break;
325 }
326
328 break;
329 }
330}
331
332int QgsProcessingFieldMapWidgetWrapper::stretch() const
333{
334 return 1;
335}
336
337void QgsProcessingFieldMapWidgetWrapper::setParentLayerWrapperValue( const QgsAbstractProcessingParameterWidgetWrapper *parentWrapper )
338{
339 // evaluate value to layer
340 QgsProcessingContext *context = nullptr;
341 std::unique_ptr<QgsProcessingContext> tmpContext;
342 if ( mProcessingContextGenerator )
343 context = mProcessingContextGenerator->processingContext();
344
345 if ( !context )
346 {
347 tmpContext = std::make_unique<QgsProcessingContext>();
348 context = tmpContext.get();
349 }
350
351 QgsVectorLayer *layer = QgsProcessingParameters::parameterAsVectorLayer( parentWrapper->parameterDefinition(), parentWrapper->parameterValue(), *context );
352 if ( !layer )
353 {
354 if ( mPanel )
355 mPanel->setLayer( nullptr );
356 return;
357 }
358
359 // need to grab ownership of layer if required - otherwise layer may be deleted when context
360 // goes out of scope
361 std::unique_ptr<QgsMapLayer> ownedLayer( context->takeResultLayer( layer->id() ) );
362 if ( ownedLayer && ownedLayer->type() == Qgis::LayerType::Vector )
363 {
364 mParentLayer.reset( qobject_cast<QgsVectorLayer *>( ownedLayer.release() ) );
365 layer = mParentLayer.get();
366 }
367 else
368 {
369 // don't need ownership of this layer - it wasn't owned by context (so e.g. is owned by the project)
370 }
371
372 if ( mPanel )
373 mPanel->setLayer( layer );
374}
375
376void QgsProcessingFieldMapWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext & )
377{
378 if ( mPanel )
379 mPanel->setValue( value );
380}
381
382QVariant QgsProcessingFieldMapWidgetWrapper::widgetValue() const
383{
384 return mPanel ? mPanel->value() : QVariant();
385}
386
387QString QgsProcessingFieldMapWidgetWrapper::modelerExpressionFormatString() const
388{
389 return tr( "an array of map items, each containing a 'name', 'type' and 'expression' values (and optional 'length' and 'precision' values)." );
390}
391
392const QgsVectorLayer *QgsProcessingFieldMapWidgetWrapper::linkedVectorLayer() const
393{
394 if ( mPanel && mPanel->layer() )
395 return mPanel->layer();
396
398}
399
ProcessingMode
Types of modes which Processing widgets can be created for.
Definition qgis.h:3553
@ Batch
Batch processing mode.
@ Modeler
Modeler mode.
@ Standard
Standard (single-run) algorithm mode.
@ Vector
Vector layer.
QFlags< ProcessingParameterFlag > ProcessingParameterFlags
Flags which dictate the behavior of Processing parameters.
Definition qgis.h:3659
A widget wrapper for Processing parameter value widgets.
QVariant parameterValue() const
Returns the current value of the parameter.
void widgetValueHasChanged(QgsAbstractProcessingParameterWidgetWrapper *wrapper)
Emitted whenever the parameter value (as defined by the wrapped widget) is changed.
virtual void postInitialize(const QList< QgsAbstractProcessingParameterWidgetWrapper * > &wrappers)
Called after all wrappers have been created within a particular dialog or context,...
virtual const QgsVectorLayer * linkedVectorLayer() const
Returns the optional vector layer associated with this widget wrapper, or nullptr if no vector layer ...
const QgsProcessingParameterDefinition * parameterDefinition() const
Returns the parameter definition associated with this wrapper.
Abstract interface for generating an expression context.
Stores information about constraints which may be present on a field.
@ ConstraintNotNull
Field may not be null.
@ ConstraintUnique
Field must have a unique value.
@ ConstraintExpression
Field has an expression constraint set. See constraintExpression().
void setConstraint(Constraint constraint, ConstraintOrigin origin=ConstraintOriginLayer)
Sets a constraint on the field.
QFlags< Constraint > Constraints
bool removeSelectedFields()
Removes the currently selected field from the model.
bool moveSelectedFieldsDown()
Moves down the currently selected field.
bool moveSelectedFieldsUp()
Moves up currently selected field.
void invertSelection()
Invert the field selection state.
void changed()
Emitted when the fields defined in the widget are changed.
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
Container of fields for a vector layer.
Definition qgsfields.h:46
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:70
int size() const
Returns number of items.
QString id
Definition qgsmaplayer.h:80
Base class for any widget that can be shown as an inline panel.
Abstract base class for widgets which allow users to specify the properties of a Processing parameter...
Abstract base class for processing algorithms.
Contains information about the context in which a processing algorithm is executed.
QgsMapLayer * takeResultLayer(const QString &id)
Takes the result map layer with matching id from the context and transfers ownership of it back to th...
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.
An input feature source (such as vector layers) parameter for processing algorithms.
A parameter for "field mapping" configurations, which consist of a definition of desired output field...
static QString typeName()
Returns the type name for the parameter class.
A vector layer (with or without geometry) parameter for processing algorithms.
Contains settings which reflect the context in which a Processing parameter widget is shown.
QgsProcessingModelAlgorithm * model() const
Returns the model which the parameter widget is associated with.
static QgsVectorLayer * parameterAsVectorLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a vector layer.
static QVariant createNullVariant(QMetaType::Type metaType)
Helper method to properly create a null QVariant from a metaType Returns the created QVariant.
Represents a vector layer which manages a vector based dataset.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into allowing algorithms to be written in pure substantial changes are required in order to port existing x Processing algorithms for QGIS x The most significant changes are outlined not GeoAlgorithm For algorithms which operate on features one by consider subclassing the QgsProcessingFeatureBasedAlgorithm class This class allows much of the boilerplate code for looping over features from a vector layer to be bypassed and instead requires implementation of a processFeature method Ensure that your algorithm(or algorithm 's parent class) implements the new pure virtual createInstance(self) call
The Field struct holds information about a mapped field.