QGIS API Documentation 3.37.0-Master (fdefdf9c27f)
qgsprocessingwidgetwrapper.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingwidgetwrapper.cpp
3 ---------------------
4 begin : August 2018
5 copyright : (C) 2018 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
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
26#include <QLabel>
27#include <QHBoxLayout>
28
29//
30// QgsProcessingParameterWidgetContext
31//
32
34{
35 mMapCanvas = canvas;
36}
37
39{
40 return mMapCanvas;
41}
42
44{
45 mMessageBar = bar;
46}
47
49{
50 return mMessageBar;
51}
52
54{
55 mBrowserModel = model;
56}
57
59{
60 return mBrowserModel;
61}
62
64{
65 mProject = project;
66}
67
69{
70 return mProject;
71}
72
74{
75 return mModelChildAlgorithmId;
76}
77
78void QgsProcessingParameterWidgetContext::setModelChildAlgorithmId( const QString &modelChildAlgorithmId )
79{
80 mModelChildAlgorithmId = modelChildAlgorithmId;
81}
82
84{
85 return mActiveLayer;
86}
87
89{
90 mActiveLayer = activeLayer;
91}
92
93QgsProcessingModelAlgorithm *QgsProcessingParameterWidgetContext::model() const
94{
95 return mModel;
96}
97
98void QgsProcessingParameterWidgetContext::setModel( QgsProcessingModelAlgorithm *model )
99{
100 mModel = model;
101}
102
103
104//
105// QgsAbstractProcessingParameterWidgetWrapper
106//
107
109 : QObject( parent )
110 , mType( type )
111 , mParameterDefinition( parameter )
112{
113}
114
116{
117 return mType;
118}
119
121{
122 mWidgetContext = context;
123}
124
126{
127 return mWidgetContext;
128}
129
131{
132 if ( mWidget )
133 return mWidget;
134
135 mWidget = createWidget();
136 QWidget *wrappedWidget = mWidget;
137 if ( mParameterDefinition->isDynamic() )
138 {
139 QHBoxLayout *hLayout = new QHBoxLayout();
140 hLayout->setContentsMargins( 0, 0, 0, 0 );
141 hLayout->addWidget( mWidget, 1 );
142 mPropertyButton = new QgsPropertyOverrideButton();
143 hLayout->addWidget( mPropertyButton );
144 mPropertyButton->init( 0, QgsProperty(), mParameterDefinition->dynamicPropertyDefinition() );
145 mPropertyButton->registerEnabledWidget( mWidget, false );
146 mPropertyButton->registerExpressionContextGenerator( this );
147
148 wrappedWidget = new QWidget();
149 wrappedWidget->setLayout( hLayout );
150 }
151
152 if ( !dynamic_cast<const QgsProcessingDestinationParameter * >( mParameterDefinition ) )
153 {
154 // an exception -- output widgets handle this themselves
155 setWidgetValue( mParameterDefinition->defaultValueForGui(), context );
156 }
157
158 return wrappedWidget;
159}
160
162{
163 if ( mLabel )
164 return mLabel;
165
166 mLabel = createLabel();
167 return mLabel;
168}
169
171{
172 return mWidget;
173}
174
176{
177 return mLabel;
178}
179
181{
182 return mParameterDefinition;
183}
184
186{
187 if ( mPropertyButton && value.userType() == QMetaType::type( "QgsProperty" ) )
188 {
189 mPropertyButton->setToProperty( value.value< QgsProperty >() );
190 }
191 else
192 {
193 if ( mPropertyButton )
194 mPropertyButton->setToProperty( QgsProperty() );
195
196 setWidgetValue( value, context );
197 }
198}
199
201{
202 if ( mPropertyButton && mPropertyButton->isActive() )
203 return mPropertyButton->toProperty();
204 else
205 return widgetValue();
206}
207
209{
210 return QVariantMap();
211}
212
214{
215 mProcessingContextGenerator = generator;
216}
217
219{
220 mParametersGenerator = generator;
221}
222
224{
225 switch ( mType )
226 {
228 return nullptr;
229
232 {
233 QString description = mParameterDefinition->description();
235 description = QObject::tr( "%1 [optional]" ).arg( description );
236 std::unique_ptr< QLabel > label = std::make_unique< QLabel >( description );
237 label->setToolTip( mParameterDefinition->toolTip() );
238 label->setWordWrap( true );
239 return label.release();
240 }
241 }
242 return nullptr;
243}
244
246{
247 if ( mPropertyButton )
248 return mPropertyButton->vectorLayer();
249 return nullptr;
250}
251
252void QgsAbstractProcessingParameterWidgetWrapper::postInitialize( const QList<QgsAbstractProcessingParameterWidgetWrapper *> &wrappers )
253{
254 switch ( mType )
255 {
258 {
259 if ( parameterDefinition()->isDynamic() )
260 {
261 for ( const QgsAbstractProcessingParameterWidgetWrapper *wrapper : wrappers )
262 {
263 if ( wrapper->parameterDefinition()->name() == parameterDefinition()->dynamicLayerParameterName() )
264 {
265 setDynamicParentLayerParameter( wrapper );
266 connect( wrapper, &QgsAbstractProcessingParameterWidgetWrapper::widgetValueHasChanged, this, &QgsAbstractProcessingParameterWidgetWrapper::parentLayerChanged );
267 break;
268 }
269 }
270 }
271 break;
272 }
273
275 break;
276 }
277}
278
280{
281 return 0;
282}
283
285{
286 QgsExpressionContext context = QgsProcessingGuiUtils::createExpressionContext( mProcessingContextGenerator, mWidgetContext, mParameterDefinition ? mParameterDefinition->algorithm() : nullptr, linkedVectorLayer() );
287 if ( mParameterDefinition && !mParameterDefinition->additionalExpressionContextVariables().isEmpty() )
288 {
289 std::unique_ptr< QgsExpressionContextScope > paramScope = std::make_unique< QgsExpressionContextScope >();
290 const QStringList additional = mParameterDefinition->additionalExpressionContextVariables();
291 for ( const QString &var : additional )
292 {
293 paramScope->setVariable( var, QVariant() );
294 }
295 context.appendScope( paramScope.release() );
296
297 // we always highlight additional variables for visibility
298 QStringList highlighted = context.highlightedVariables();
299 highlighted.append( additional );
300 context.setHighlightedVariables( highlighted );
301 }
302 return context;
303}
304
306{
307
308}
309
310void QgsAbstractProcessingParameterWidgetWrapper::parentLayerChanged( QgsAbstractProcessingParameterWidgetWrapper *wrapper )
311{
312 if ( wrapper )
313 {
314 setDynamicParentLayerParameter( wrapper );
315 }
316}
317
318void QgsAbstractProcessingParameterWidgetWrapper::setDynamicParentLayerParameter( const QgsAbstractProcessingParameterWidgetWrapper *parentWrapper )
319{
320 if ( mPropertyButton )
321 {
322 // evaluate value to layer
323 QgsProcessingContext *context = nullptr;
324 std::unique_ptr< QgsProcessingContext > tmpContext;
327
328 if ( !context )
329 {
330 tmpContext = std::make_unique< QgsProcessingContext >();
331 context = tmpContext.get();
332 }
333
334 QVariant val = parentWrapper->parameterValue();
335 if ( val.userType() == QMetaType::type( "QgsProcessingFeatureSourceDefinition" ) )
336 {
337 // input is a QgsProcessingFeatureSourceDefinition - get extra properties from it
338 const QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( val );
339 val = fromVar.source;
340 }
341
343 if ( !layer )
344 {
345 mPropertyButton->setVectorLayer( nullptr );
346 return;
347 }
348
349 // need to grab ownership of layer if required - otherwise layer may be deleted when context
350 // goes out of scope
351 std::unique_ptr< QgsMapLayer > ownedLayer( context->takeResultLayer( layer->id() ) );
352 if ( ownedLayer && ownedLayer->type() == Qgis::LayerType::Vector )
353 {
354 mDynamicLayer.reset( qobject_cast< QgsVectorLayer * >( ownedLayer.release() ) );
355 layer = mDynamicLayer.get();
356 }
357 else
358 {
359 // don't need ownership of this layer - it wasn't owned by context (so e.g. is owned by the project)
360 }
361
362 mPropertyButton->setVectorLayer( layer );
363 }
364}
365
367{
368 std::unique_ptr< QgsProcessingModelerParameterWidget > widget = std::make_unique< QgsProcessingModelerParameterWidget >( model, childId, parameter, context );
369 widget->populateSources( compatibleParameterTypes(), compatibleOutputTypes(), compatibleDataTypes( parameter ) );
370 widget->setExpressionHelpText( modelerExpressionFormatString() );
371
372 if ( parameter->isDestination() )
374 else
375 widget->setSourceType( defaultModelSource( parameter ) );
376
377 return widget.release();
378}
379
382 const QgsProcessingAlgorithm * )
383{
384 return nullptr;
385}
386
388{
389 return QList< int >();
390}
391
393{
394 return QString();
395}
396
398{
400}
401
402//
403// QgsProcessingGuiUtils
404//
405
407QgsExpressionContext QgsProcessingGuiUtils::createExpressionContext( QgsProcessingContextGenerator *processingContextGenerator, const QgsProcessingParameterWidgetContext &widgetContext, const QgsProcessingAlgorithm *algorithm, const QgsVectorLayer *linkedLayer )
408{
409 // Get a processing context to start with
410 QgsProcessingContext *context = nullptr;
411 std::unique_ptr< QgsProcessingContext > tmpContext;
412 if ( processingContextGenerator )
413 context = processingContextGenerator->processingContext();
414
415 if ( !context )
416 {
417 tmpContext = std::make_unique< QgsProcessingContext >();
418 context = tmpContext.get();
419 }
420
422
423 if ( auto *lModel = widgetContext.model() )
424 {
425 c << QgsExpressionContextUtils::processingModelAlgorithmScope( lModel, QVariantMap(), *context );
426
427 const QgsProcessingAlgorithm *alg = nullptr;
428 if ( lModel->childAlgorithms().contains( widgetContext.modelChildAlgorithmId() ) )
429 alg = lModel->childAlgorithm( widgetContext.modelChildAlgorithmId() ).algorithm();
430
431 QgsExpressionContextScope *algorithmScope = QgsExpressionContextUtils::processingAlgorithmScope( alg ? alg : algorithm, QVariantMap(), *context );
432 c << algorithmScope;
433 QgsExpressionContextScope *childScope = lModel->createExpressionContextScopeForChildAlgorithm( widgetContext.modelChildAlgorithmId(), *context, QVariantMap(), QVariantMap() );
434 c << childScope;
435
436 QStringList highlightedVariables = childScope->variableNames();
437 QStringList highlightedFunctions = childScope->functionNames();
438 highlightedVariables += algorithmScope->variableNames();
439 highlightedVariables += lModel->variables().keys();
440 highlightedFunctions += algorithmScope->functionNames();
441 c.setHighlightedVariables( highlightedVariables );
442 c.setHighlightedFunctions( highlightedFunctions );
443 }
444 else
445 {
446 if ( algorithm )
448 }
449
450 if ( linkedLayer )
452
453 return c;
454}
456
458 : QgsAbstractProcessingParameterWidgetWrapper( parameter, type, parent )
459{
460
461}
462
464{
465 if ( mValue == value )
466 return;
467
468 mValue = value;
469 emit widgetValueHasChanged( this );
470}
471
473{
474 return mValue;
475}
476
478{
479 return mLayer;
480}
481
483{
484 mLayer = layer;
485}
486
488{
489 return nullptr;
490
491}
492
494{
495 return nullptr;
496}
@ Vector
Vector layer.
ProcessingModelChildParameterSource
Processing model child parameter sources.
Definition: qgis.h:3136
@ ModelOutput
Parameter value is linked to an output parameter for the model.
@ StaticValue
Parameter value is a static value.
@ Optional
Parameter is optional.
A widget wrapper for Processing parameter value widgets.
QVariant parameterValue() const
Returns the current value of the parameter.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
virtual QVariantMap customProperties() const
Returns any custom properties set by the wrapper.
QgsAbstractProcessingParameterWidgetWrapper(const QgsProcessingParameterDefinition *parameter=nullptr, QgsProcessingGui::WidgetType type=QgsProcessingGui::Standard, QObject *parent=nullptr)
Constructor for QgsAbstractProcessingParameterWidgetWrapper, for the specified parameter definition a...
virtual void setWidgetValue(const QVariant &value, QgsProcessingContext &context)=0
Sets the current value for the parameter to show in the widget.
virtual QLabel * createLabel()
Creates a new label to accompany widgets created by the wrapper.
void registerProcessingParametersGenerator(QgsProcessingParametersGenerator *generator)
Registers a Processing parameters generator class that will be used to retrieve algorithm parameters ...
QgsProcessingParameterWidgetContext mWidgetContext
QgsProcessingGui::WidgetType type() const
Returns the dialog type for which widgets and labels will be created by this wrapper.
QgsProcessingParametersGenerator * mParametersGenerator
virtual void registerProcessingContextGenerator(QgsProcessingContextGenerator *generator)
Registers a Processing context generator class that will be used to retrieve a Processing context for...
const QgsProcessingParameterWidgetContext & widgetContext() const
Returns the context in which the Processing parameter widget is shown, e.g., the parent model algorit...
QLabel * createWrappedLabel()
Creates and returns a new label to accompany widgets created by the wrapper.
QWidget * createWrappedWidget(QgsProcessingContext &context)
Creates and return a new wrapped widget which allows customization of the parameter's value.
QgsProcessingContextGenerator * mProcessingContextGenerator
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 ...
QWidget * wrappedWidget()
Returns the current wrapped widget, if any.
const QgsProcessingParameterDefinition * parameterDefinition() const
Returns the parameter definition associated with this wrapper.
QLabel * wrappedLabel()
Returns the current wrapped label, if any.
virtual QVariant widgetValue() const =0
Returns the current value of the parameter.
virtual QWidget * createWidget()=0
Creates a new widget which allows customization of the parameter's value.
virtual int stretch() const
Returns the Qt layout "stretch" factor to use when adding this widget to a layout.
virtual void setDialog(QDialog *dialog)
Sets the parent dialog in which the wrapper is shown.
virtual void setWidgetContext(const QgsProcessingParameterWidgetContext &context)
Sets the context in which the Processing parameter widget is shown, e.g., the parent model algorithm,...
void setParameterValue(const QVariant &value, QgsProcessingContext &context)
Sets the current value for the parameter.
A model for showing available data sources and other items in a structured tree.
Single scope for storing variables and functions for use within a QgsExpressionContext.
QStringList variableNames() const
Returns a list of variable names contained within the scope.
static QgsExpressionContextScope * processingModelAlgorithmScope(const QgsProcessingModelAlgorithm *model, const QVariantMap &parameters, QgsProcessingContext &context)
Creates a new scope which contains variables and functions relating to a processing model algorithm,...
static QgsExpressionContextScope * processingAlgorithmScope(const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context)
Creates a new scope which contains variables and functions relating to a processing algorithm,...
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QStringList highlightedVariables() const
Returns the current list of variables highlighted within the context.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void setHighlightedVariables(const QStringList &variableNames)
Sets the list of variable names within the context intended to be highlighted to the user.
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:93
Base class for all map layer types.
Definition: qgsmaplayer.h:75
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
A bar for displaying non-blocking messages to the user.
Definition: qgsmessagebar.h:61
Abstract base class for widgets which allow users to specify the properties of a Processing parameter...
Abstract base class for processing algorithms.
An interface for objects which can create Processing contexts.
virtual QgsProcessingContext * processingContext()=0
This method needs to be reimplemented in all classes which implement this interface and return a Proc...
Contains information about the context in which a processing algorithm is executed.
QgsExpressionContext & expressionContext()
Returns the expression context.
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 all parameter definitions which represent file or layer destinations,...
Encapsulates settings relating to a feature source input to a processing algorithm.
WidgetType
Types of dialogs which Processing widgets can be created for.
@ Modeler
Modeler dialog.
@ Standard
Standard algorithm dialog.
@ Batch
Batch processing dialog.
QVariant widgetValue() const override
Returns the current value of the parameter.
QgsProcessingHiddenWidgetWrapper(const QgsProcessingParameterDefinition *parameter=nullptr, QgsProcessingGui::WidgetType type=QgsProcessingGui::Standard, QObject *parent=nullptr)
Constructor for QgsProcessingHiddenWidgetWrapper, for the specified parameter definition and dialog t...
QWidget * createWidget() override
Creates a new widget which allows customization of the parameter's value.
void setWidgetValue(const QVariant &value, QgsProcessingContext &context) override
Sets the current value for the parameter to show in the widget.
void setLinkedVectorLayer(const QgsVectorLayer *layer)
Sets the vector layer linked to the wrapper.
QLabel * createLabel() override
Creates a new label to accompany widgets created by the wrapper.
const QgsVectorLayer * linkedVectorLayer() const override
Returns the optional vector layer associated with this widget wrapper, or nullptr if no vector layer ...
A widget for customising the value of Processing algorithm parameter inside a Processing model.
Base class for the definition of processing parameters.
QStringList additionalExpressionContextVariables() const
Returns a list of additional expression context variables which are available for use when evaluating...
virtual QString toolTip() const
Returns a formatted tooltip for use with the parameter, which gives helpful information like paramete...
QgsProcessingAlgorithm * algorithm() const
Returns a pointer to the algorithm which owns this parameter.
QString description() const
Returns the description for the parameter.
QVariant defaultValueForGui() const
Returns the default value to use for the parameter in a GUI.
virtual bool isDestination() const
Returns true if this parameter represents a file or layer destination, e.g.
bool isDynamic() const
Returns true if the parameter supports is dynamic, and can support data-defined values (i....
QgsPropertyDefinition dynamicPropertyDefinition() const
Returns the property definition for dynamic properties.
Contains settings which reflect the context in which a Processing parameter widget is shown,...
QgsMapCanvas * mapCanvas() const
Returns the map canvas associated with the widget.
QgsProject * project() const
Returns the project associated with the widget.
QgsBrowserGuiModel * browserModel() const
Returns the browser model associated with the widget.
void setActiveLayer(QgsMapLayer *layer)
Sets the current active layer.
void setModelChildAlgorithmId(const QString &id)
Sets the child algorithm id within the model which the parameter widget is associated with.
void setProject(QgsProject *project)
Sets the project associated with the widget.
QgsMessageBar * messageBar() const
Returns the message bar associated with the widget.
void setMapCanvas(QgsMapCanvas *canvas)
Sets the map canvas associated with the widget.
void setBrowserModel(QgsBrowserGuiModel *model)
Sets the browser model associated with the widget.
QgsProcessingModelAlgorithm * model() const
Returns the model which the parameter widget is associated with.
void setMessageBar(QgsMessageBar *bar)
Sets the message bar associated with the widget.
QgsMapLayer * activeLayer() const
Returns the current active layer.
void setModel(QgsProcessingModelAlgorithm *model)
Sets the model which the parameter widget is associated with.
QString modelChildAlgorithmId() const
Returns the child algorithm ID within the model which the parameter widget is associated with.
virtual QList< int > compatibleDataTypes(const QgsProcessingParameterDefinition *parameter) const
Returns a list of compatible Processing data types for inputs for this widget for the specified param...
virtual QStringList compatibleOutputTypes() const =0
Returns a list of compatible Processing output types for inputs for this parameter.
virtual QgsProcessingAbstractParameterDefinitionWidget * createParameterDefinitionWidget(QgsProcessingContext &context, const QgsProcessingParameterWidgetContext &widgetContext, const QgsProcessingParameterDefinition *definition=nullptr, const QgsProcessingAlgorithm *algorithm=nullptr)
Creates a new parameter definition widget allowing for configuration of an instance of the parameter ...
virtual QgsProcessingModelerParameterWidget * createModelerWidgetWrapper(QgsProcessingModelAlgorithm *model, const QString &childId, const QgsProcessingParameterDefinition *parameter, QgsProcessingContext &context)
Creates a new modeler parameter widget for the given parameter.
virtual QStringList compatibleParameterTypes() const =0
Returns a list of compatible Processing parameter types for inputs for this parameter.
virtual Qgis::ProcessingModelChildParameterSource defaultModelSource(const QgsProcessingParameterDefinition *parameter) const
Returns the default source type to use for the widget for the specified parameter.
virtual QString modelerExpressionFormatString() const
Returns the expected expression format string for expression results for the parameter within model c...
An interface for objects which can create sets of parameter values for processing algorithms.
static QgsVectorLayer * parameterAsVectorLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a vector layer.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:107
A button for controlling property overrides which may apply to a widget.
A store for object properties.
Definition: qgsproperty.h:228
Represents a vector layer which manages a vector based data sets.
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
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 c