QGIS API Documentation  3.21.0-Master (5b68dc587e)
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 
23 #include "qgsexpressioncontext.h"
24 #include "models/qgsprocessingmodelalgorithm.h"
27 #include <QLabel>
28 #include <QHBoxLayout>
29 
30 //
31 // QgsProcessingParameterWidgetContext
32 //
33 
35 {
36  mMapCanvas = canvas;
37 }
38 
40 {
41  return mMapCanvas;
42 }
43 
45 {
46  mMessageBar = bar;
47 }
48 
50 {
51  return mMessageBar;
52 }
53 
55 {
56  mBrowserModel = model;
57 }
58 
60 {
61  return mBrowserModel;
62 }
63 
65 {
66  mProject = project;
67 }
68 
70 {
71  return mProject;
72 }
73 
75 {
76  return mModelChildAlgorithmId;
77 }
78 
79 void QgsProcessingParameterWidgetContext::setModelChildAlgorithmId( const QString &modelChildAlgorithmId )
80 {
81  mModelChildAlgorithmId = modelChildAlgorithmId;
82 }
83 
85 {
86  return mActiveLayer;
87 }
88 
90 {
91  mActiveLayer = activeLayer;
92 }
93 
94 QgsProcessingModelAlgorithm *QgsProcessingParameterWidgetContext::model() const
95 {
96  return mModel;
97 }
98 
99 void QgsProcessingParameterWidgetContext::setModel( QgsProcessingModelAlgorithm *model )
100 {
101  mModel = model;
102 }
103 
104 
105 //
106 // QgsAbstractProcessingParameterWidgetWrapper
107 //
108 
110  : QObject( parent )
111  , mType( type )
112  , mParameterDefinition( parameter )
113 {
114 }
115 
117 {
118  return mType;
119 }
120 
122 {
123  mWidgetContext = context;
124 }
125 
127 {
128  return mWidgetContext;
129 }
130 
132 {
133  if ( mWidget )
134  return mWidget;
135 
136  mWidget = createWidget();
137  QWidget *wrappedWidget = mWidget;
138  if ( mParameterDefinition->isDynamic() )
139  {
140  QHBoxLayout *hLayout = new QHBoxLayout();
141  hLayout->setContentsMargins( 0, 0, 0, 0 );
142  hLayout->addWidget( mWidget, 1 );
143  mPropertyButton = new QgsPropertyOverrideButton();
144  hLayout->addWidget( mPropertyButton );
145  mPropertyButton->init( 0, QgsProperty(), mParameterDefinition->dynamicPropertyDefinition() );
146  mPropertyButton->registerEnabledWidget( mWidget, false );
147  mPropertyButton->registerExpressionContextGenerator( this );
148 
149  wrappedWidget = new QWidget();
150  wrappedWidget->setLayout( hLayout );
151  }
152 
153  if ( !dynamic_cast<const QgsProcessingDestinationParameter * >( mParameterDefinition ) )
154  {
155  // an exception -- output widgets handle this themselves
156  setWidgetValue( mParameterDefinition->defaultValueForGui(), context );
157  }
158 
159  return wrappedWidget;
160 }
161 
163 {
164  if ( mLabel )
165  return mLabel;
166 
167  mLabel = createLabel();
168  return mLabel;
169 }
170 
172 {
173  return mWidget;
174 }
175 
177 {
178  return mLabel;
179 }
180 
182 {
183  return mParameterDefinition;
184 }
185 
187 {
188  if ( mPropertyButton && value.canConvert< QgsProperty >() )
189  {
190  mPropertyButton->setToProperty( value.value< QgsProperty >() );
191  }
192  else
193  {
194  if ( mPropertyButton )
195  mPropertyButton->setToProperty( QgsProperty() );
196 
197  setWidgetValue( value, context );
198  }
199 }
200 
202 {
203  if ( mPropertyButton && mPropertyButton->isActive() )
204  return mPropertyButton->toProperty();
205  else
206  return widgetValue();
207 }
208 
210 {
211  return QVariantMap();
212 }
213 
215 {
216  mProcessingContextGenerator = generator;
217 }
218 
220 {
221  mParametersGenerator = generator;
222 }
223 
225 {
226  switch ( mType )
227  {
229  return nullptr;
230 
233  {
234  QString description = mParameterDefinition->description();
236  description = QObject::tr( "%1 [optional]" ).arg( description );
237  std::unique_ptr< QLabel > label = std::make_unique< QLabel >( description );
238  label->setToolTip( mParameterDefinition->toolTip() );
239  return label.release();
240  }
241  }
242  return nullptr;
243 }
244 
246 {
247  if ( mPropertyButton )
248  return mPropertyButton->vectorLayer();
249  return nullptr;
250 }
251 
252 void 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 
310 void QgsAbstractProcessingParameterWidgetWrapper::parentLayerChanged( QgsAbstractProcessingParameterWidgetWrapper *wrapper )
311 {
312  if ( wrapper )
313  {
314  setDynamicParentLayerParameter( wrapper );
315  }
316 }
317 
318 void 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.canConvert<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 
342  QgsVectorLayer *layer = QgsProcessingParameters::parameterAsVectorLayer( parentWrapper->parameterDefinition(), val, *context );
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() == QgsMapLayerType::VectorLayer )
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  return widget.release();
372 }
373 
376  const QgsProcessingAlgorithm * )
377 {
378  return nullptr;
379 }
380 
382 {
383  return QList< int >();
384 }
385 
387 {
388  return QString();
389 }
390 
391 //
392 // QgsProcessingGuiUtils
393 //
394 
396 QgsExpressionContext QgsProcessingGuiUtils::createExpressionContext( QgsProcessingContextGenerator *processingContextGenerator, const QgsProcessingParameterWidgetContext &widgetContext, const QgsProcessingAlgorithm *algorithm, const QgsVectorLayer *linkedLayer )
397 {
398  // Get a processing context to start with
399  QgsProcessingContext *context = nullptr;
400  std::unique_ptr< QgsProcessingContext > tmpContext;
401  if ( processingContextGenerator )
402  context = processingContextGenerator->processingContext();
403 
404  if ( !context )
405  {
406  tmpContext = std::make_unique< QgsProcessingContext >();
407  context = tmpContext.get();
408  }
409 
411 
412  if ( auto *lModel = widgetContext.model() )
413  {
414  c << QgsExpressionContextUtils::processingModelAlgorithmScope( lModel, QVariantMap(), *context );
415 
416  const QgsProcessingAlgorithm *alg = nullptr;
417  if ( lModel->childAlgorithms().contains( widgetContext.modelChildAlgorithmId() ) )
418  alg = lModel->childAlgorithm( widgetContext.modelChildAlgorithmId() ).algorithm();
419 
420  QgsExpressionContextScope *algorithmScope = QgsExpressionContextUtils::processingAlgorithmScope( alg ? alg : algorithm, QVariantMap(), *context );
421  c << algorithmScope;
422  QgsExpressionContextScope *childScope = lModel->createExpressionContextScopeForChildAlgorithm( widgetContext.modelChildAlgorithmId(), *context, QVariantMap(), QVariantMap() );
423  c << childScope;
424 
425  QStringList highlightedVariables = childScope->variableNames();
426  QStringList highlightedFunctions = childScope->functionNames();
427  highlightedVariables += algorithmScope->variableNames();
428  highlightedVariables += lModel->variables().keys();
429  highlightedFunctions += algorithmScope->functionNames();
430  c.setHighlightedVariables( highlightedVariables );
431  c.setHighlightedFunctions( highlightedFunctions );
432  }
433  else
434  {
435  if ( algorithm )
436  c << QgsExpressionContextUtils::processingAlgorithmScope( algorithm, QVariantMap(), *context );
437  }
438 
439  if ( linkedLayer )
440  c << QgsExpressionContextUtils::layerScope( linkedLayer );
441 
442  return c;
443 }
445 
447  : QgsAbstractProcessingParameterWidgetWrapper( parameter, type, parent )
448 {
449 
450 }
451 
453 {
454  if ( mValue == value )
455  return;
456 
457  mValue = value;
458  emit widgetValueHasChanged( this );
459 }
460 
462 {
463  return mValue;
464 }
465 
467 {
468  return mLayer;
469 }
470 
472 {
473  mLayer = layer;
474 }
475 
477 {
478  return nullptr;
479 
480 }
481 
483 {
484  return nullptr;
485 }
A widget wrapper for Processing parameter value widgets.
QVariant parameterValue() const
Returns the current value of the parameter.
virtual QWidget * createWidget()=0
Creates a new widget which allows customization of the parameter's value.
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 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:88
Base class for all map layer types.
Definition: qgsmaplayer.h:73
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.
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 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:101
A button for controlling property overrides which may apply to a widget.
A store for object properties.
Definition: qgsproperty.h:232
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