QWidget *QgsProcessingCrsWidgetWrapper::createWidget()
{
mProjectionSelectionWidget = new QgsProjectionSelectionWidget();
mProjectionSelectionWidget->setToolTip( parameterDefinition()->toolTip() );
if ( parameterDefinition()->flags() & QgsProcessingParameterDefinition::FlagOptional )
mProjectionSelectionWidget->setOptionVisible( QgsProjectionSelectionWidget::CrsNotSet, true );
else
mProjectionSelectionWidget->setOptionVisible( QgsProjectionSelectionWidget::CrsNotSet, false );
connect( mProjectionSelectionWidget, &QgsProjectionSelectionWidget::crsChanged, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
switch ( type() )
{
case QgsProcessingGui::Standard:
case QgsProcessingGui::Batch:
{
return mProjectionSelectionWidget;
};
case QgsProcessingGui::Modeler:
{
QWidget *w = new QWidget();
w->setToolTip( parameterDefinition()->toolTip() );
QVBoxLayout *vl = new QVBoxLayout();
vl->setMargin( 0 );
vl->setContentsMargins( 0, 0, 0, 0 );
w->setLayout( vl );
mUseProjectCrsCheckBox = new QCheckBox( tr( "Use project CRS" ) );
mUseProjectCrsCheckBox->setToolTip( tr( "Always use the current project CRS when running the model" ) );
vl->addWidget( mUseProjectCrsCheckBox );
connect( mUseProjectCrsCheckBox, &QCheckBox::toggled, mProjectionSelectionWidget, &QgsProjectionSelectionWidget::setDisabled );
connect( mUseProjectCrsCheckBox, &QCheckBox::toggled, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
vl->addWidget( mProjectionSelectionWidget );
return w;
}
}
return nullptr;
}
void QgsProcessingStringWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
const QString v = QgsProcessingParameters::parameterAsString( parameterDefinition(), value, context );
if ( mLineEdit )
mLineEdit->setText( v );
if ( mPlainTextEdit )
mPlainTextEdit->setPlainText( v );
}
QWidget *QgsProcessingStringWidgetWrapper::createWidget()
{
switch ( type() )
{
case QgsProcessingGui::Standard:
case QgsProcessingGui::Modeler:
{
if ( static_cast< const QgsProcessingParameterString * >( parameterDefinition() )->multiLine() )
{
mPlainTextEdit = new QPlainTextEdit();
mPlainTextEdit->setToolTip( parameterDefinition()->toolTip() );
connect( mPlainTextEdit, &QPlainTextEdit::textChanged, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mPlainTextEdit;
}
else
{
mLineEdit = new QLineEdit();
mLineEdit->setToolTip( parameterDefinition()->toolTip() );
connect( mLineEdit, &QLineEdit::textChanged, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mLineEdit;
}
};
case QgsProcessingGui::Batch:
{
mLineEdit = new QLineEdit();
mLineEdit->setToolTip( parameterDefinition()->toolTip() );
connect( mLineEdit, &QLineEdit::textChanged, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mLineEdit;
}
}
return nullptr;
}
void QgsProcessingAlgorithm::removeParameter( const QString &name )
{
const QgsProcessingParameterDefinition *def = parameterDefinition( name );
if ( def )
{
delete def;
mParameters.removeAll( def );
}
}
void QgsProcessingBooleanWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
switch ( type() )
{
case QgsProcessingGui::Standard:
{
const bool v = QgsProcessingParameters::parameterAsBool( parameterDefinition(), value, context );
mCheckBox->setChecked( v );
break;
}
case QgsProcessingGui::Batch:
case QgsProcessingGui::Modeler:
{
const bool v = QgsProcessingParameters::parameterAsBool( parameterDefinition(), value, context );
mComboBox->setCurrentIndex( mComboBox->findData( v ) );
break;
}
}
}
QWidget *QgsProcessingBooleanWidgetWrapper::createWidget()
{
switch ( type() )
{
case QgsProcessingGui::Standard:
{
QString description = parameterDefinition()->description();
if ( parameterDefinition()->flags() & QgsProcessingParameterDefinition::FlagOptional )
description = QObject::tr( "%1 [optional]" ).arg( description );
mCheckBox = new QCheckBox( description );
mCheckBox->setToolTip( parameterDefinition()->toolTip() );
connect( mCheckBox, &QCheckBox::toggled, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mCheckBox;
};
case QgsProcessingGui::Batch:
case QgsProcessingGui::Modeler:
{
mComboBox = new QComboBox();
mComboBox->addItem( tr( "Yes" ), true );
mComboBox->addItem( tr( "No" ), false );
mComboBox->setToolTip( parameterDefinition()->toolTip() );
connect( mComboBox, qgis::overload< int>::of( &QComboBox::currentIndexChanged ), this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mComboBox;
}
}
return nullptr;
}
void QgsProcessingNumericWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
if ( mDoubleSpinBox )
{
if ( mAllowingNull && !value.isValid() )
mDoubleSpinBox->clear();
else
{
const double v = QgsProcessingParameters::parameterAsDouble( parameterDefinition(), value, context );
mDoubleSpinBox->setValue( v );
}
}
else if ( mSpinBox )
{
if ( mAllowingNull && !value.isValid() )
mSpinBox->clear();
else
{
const int v = QgsProcessingParameters::parameterAsInt( parameterDefinition(), value, context );
mSpinBox->setValue( v );
}
}
}
void QgsProcessingRangeWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
const QList< double > v = QgsProcessingParameters::parameterAsRange( parameterDefinition(), value, context );
if ( v.empty() )
return;
mBlockChangedSignal++;
mMinSpinBox->setValue( v.at( 0 ) );
if ( v.count() >= 2 )
mMaxSpinBox->setValue( v.at( 1 ) );
mBlockChangedSignal--;
if ( !mBlockChangedSignal )
emit widgetValueHasChanged( this );
}
void QgsProcessingCrsWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
if ( mUseProjectCrsCheckBox )
{
if ( value.toString().compare( QLatin1String( "ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
{
mUseProjectCrsCheckBox->setChecked( true );
return;
}
else
{
mUseProjectCrsCheckBox->setChecked( false );
}
}
const QgsCoordinateReferenceSystem v = QgsProcessingParameters::parameterAsCrs( parameterDefinition(), value, context );
if ( mProjectionSelectionWidget )
mProjectionSelectionWidget->setCrs( v );
}
QWidget *QgsProcessingAuthConfigWidgetWrapper::createWidget()
{
switch ( type() )
{
case QgsProcessingGui::Standard:
case QgsProcessingGui::Modeler:
case QgsProcessingGui::Batch:
{
mAuthConfigSelect = new QgsAuthConfigSelect();
mAuthConfigSelect->setToolTip( parameterDefinition()->toolTip() );
connect( mAuthConfigSelect, &QgsAuthConfigSelect::selectedConfigIdChanged, this, [ = ]
{
emit widgetValueHasChanged( this );
} );
return mAuthConfigSelect;
};
}
return nullptr;
}
void QgsProcessingDistanceWidgetWrapper::setUnitParameterValue( const QVariant &value )
{
QgsUnitTypes::DistanceUnit units = QgsUnitTypes::DistanceUnknownUnit;
// evaluate value to layer
QgsProcessingContext *context = nullptr;
std::unique_ptr< QgsProcessingContext > tmpContext;
if ( mProcessingContextGenerator )
context = mProcessingContextGenerator->processingContext();
if ( !context )
{
tmpContext = qgis::make_unique< QgsProcessingContext >();
context = tmpContext.get();
}
QgsCoordinateReferenceSystem crs = QgsProcessingParameters::parameterAsCrs( parameterDefinition(), value, *context );
if ( crs.isValid() )
{
units = crs.mapUnits();
}
setUnits( units );
}
void QgsProcessingDistanceWidgetWrapper::postInitialize( const QList<QgsAbstractProcessingParameterWidgetWrapper *> &wrappers )
{
QgsProcessingNumericWidgetWrapper::postInitialize( wrappers );
switch ( type() )
{
case QgsProcessingGui::Standard:
{
for ( const QgsAbstractProcessingParameterWidgetWrapper *wrapper : wrappers )
{
if ( wrapper->parameterDefinition()->name() == static_cast< const QgsProcessingParameterDistance * >( parameterDefinition() )->parentParameterName() )
{
setUnitParameterValue( wrapper->parameterValue() );
connect( wrapper, &QgsAbstractProcessingParameterWidgetWrapper::widgetValueHasChanged, this, [ = ]
{
setUnitParameterValue( wrapper->parameterValue() );
} );
break;
}
}
break;
}
case QgsProcessingGui::Batch:
case QgsProcessingGui::Modeler:
break;
}
}
QWidget *QgsProcessingDistanceWidgetWrapper::createWidget()
{
const QgsProcessingParameterDistance *distanceDef = static_cast< const QgsProcessingParameterDistance * >( parameterDefinition() );
QWidget *spin = QgsProcessingNumericWidgetWrapper::createWidget();
switch ( type() )
{
case QgsProcessingGui::Standard:
{
mLabel = new QLabel();
mUnitsCombo = new QComboBox();
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::DistanceMeters ), QgsUnitTypes::DistanceMeters );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::DistanceKilometers ), QgsUnitTypes::DistanceKilometers );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::DistanceFeet ), QgsUnitTypes::DistanceFeet );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::DistanceMiles ), QgsUnitTypes::DistanceMiles );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::DistanceYards ), QgsUnitTypes::DistanceYards );
const int labelMargin = static_cast< int >( std::round( mUnitsCombo->fontMetrics().width( 'X' ) ) );
QHBoxLayout *layout = new QHBoxLayout();
layout->addWidget( spin, 1 );
layout->insertSpacing( 1, labelMargin / 2 );
layout->insertWidget( 2, mLabel );
layout->insertWidget( 3, mUnitsCombo );
// bit of fiddlyness here -- we want the initial spacing to only be visible
// when the warning label is shown, so it's embedded inside mWarningLabel
// instead of outside it
mWarningLabel = new QWidget();
QHBoxLayout *warningLayout = new QHBoxLayout();
warningLayout->setMargin( 0 );
warningLayout->setContentsMargins( 0, 0, 0, 0 );
QLabel *warning = new QLabel();
QIcon icon = QgsApplication::getThemeIcon( QStringLiteral( "mIconWarning.svg" ) );
const int size = static_cast< int >( std::max( 24.0, spin->minimumSize().height() * 0.5 ) );
warning->setPixmap( icon.pixmap( icon.actualSize( QSize( size, size ) ) ) );
warning->setToolTip( tr( "Distance is in geographic degrees. Consider reprojecting to a projected local coordinate system for accurate results." ) );
warningLayout->insertSpacing( 0, labelMargin / 2 );
warningLayout->insertWidget( 1, warning );
mWarningLabel->setLayout( warningLayout );
layout->insertWidget( 4, mWarningLabel );
setUnits( distanceDef->defaultUnit() );
QWidget *w = new QWidget();
layout->setMargin( 0 );
layout->setContentsMargins( 0, 0, 0, 0 );
w->setLayout( layout );
return w;
}
case QgsProcessingGui::Batch:
case QgsProcessingGui::Modeler:
return spin;
}
return nullptr;
}
QgsProcessingFeatureSource *QgsProcessingAlgorithm::parameterAsSource( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context ) const
{
return QgsProcessingParameters::parameterAsSource( parameterDefinition( name ), parameters, context );
}
QWidget *QgsProcessingNumericWidgetWrapper::createWidget()
{
const QgsProcessingParameterNumber *numberDef = static_cast< const QgsProcessingParameterNumber * >( parameterDefinition() );
const QVariantMap metadata = numberDef->metadata();
const int decimals = metadata.value( QStringLiteral( "widget_wrapper" ) ).toMap().value( QStringLiteral( "decimals" ), 6 ).toInt();
switch ( type() )
{
case QgsProcessingGui::Standard:
case QgsProcessingGui::Modeler:
case QgsProcessingGui::Batch:
{
// lots of duplicate code here -- but there's no common interface between QSpinBox/QDoubleSpinBox which would allow us to avoid this
QAbstractSpinBox *spinBox = nullptr;
switch ( numberDef->dataType() )
{
case QgsProcessingParameterNumber::Double:
mDoubleSpinBox = new QgsDoubleSpinBox();
mDoubleSpinBox->setExpressionsEnabled( true );
mDoubleSpinBox->setDecimals( decimals );
// guess reasonable step value for double spin boxes
if ( !qgsDoubleNear( numberDef->maximum(), std::numeric_limits<double>::max() ) &&
!qgsDoubleNear( numberDef->minimum(), std::numeric_limits<double>::lowest() + 1 ) )
{
double singleStep = calculateStep( numberDef->minimum(), numberDef->maximum() );
singleStep = std::max( singleStep, std::pow( 10, -decimals ) );
mDoubleSpinBox->setSingleStep( singleStep );
}
spinBox = mDoubleSpinBox;
break;
case QgsProcessingParameterNumber::Integer:
mSpinBox = new QgsSpinBox();
mSpinBox->setExpressionsEnabled( true );
spinBox = mSpinBox;
break;
}
spinBox->setToolTip( parameterDefinition()->toolTip() );
double max = 999999999;
if ( !qgsDoubleNear( numberDef->maximum(), std::numeric_limits<double>::max() ) )
{
max = numberDef->maximum();
}
double min = -999999999;
if ( !qgsDoubleNear( numberDef->minimum(), std::numeric_limits<double>::lowest() ) )
{
min = numberDef->minimum();
}
if ( mDoubleSpinBox )
{
mDoubleSpinBox->setMinimum( min );
mDoubleSpinBox->setMaximum( max );
}
else
{
mSpinBox->setMinimum( static_cast< int >( min ) );
mSpinBox->setMaximum( static_cast< int >( max ) );
}
if ( numberDef->flags() & QgsProcessingParameterDefinition::FlagOptional )
{
mAllowingNull = true;
if ( mDoubleSpinBox )
{
mDoubleSpinBox->setShowClearButton( true );
const double min = mDoubleSpinBox->minimum() - 1;
mDoubleSpinBox->setMinimum( min );
mDoubleSpinBox->setValue( min );
}
else
{
mSpinBox->setShowClearButton( true );
const int min = mSpinBox->minimum() - 1;
mSpinBox->setMinimum( min );
mSpinBox->setValue( min );
}
spinBox->setSpecialValueText( tr( "Not set" ) );
}
else
{
if ( numberDef->defaultValue().isValid() )
{
// if default value for parameter, we clear to that
bool ok = false;
if ( mDoubleSpinBox )
{
double defaultVal = numberDef->defaultValue().toDouble( &ok );
if ( ok )
mDoubleSpinBox->setClearValue( defaultVal );
}
else
{
int intVal = numberDef->defaultValue().toInt( &ok );
if ( ok )
mSpinBox->setClearValue( intVal );
}
}
else if ( !qgsDoubleNear( numberDef->minimum(), std::numeric_limits<double>::lowest() ) )
{
// otherwise we clear to the minimum, if it's set
if ( mDoubleSpinBox )
mDoubleSpinBox->setClearValue( numberDef->minimum() );
else
mSpinBox->setClearValue( static_cast< int >( numberDef->minimum() ) );
}
else
{
// last resort, we clear to 0
if ( mDoubleSpinBox )
{
mDoubleSpinBox->setValue( 0 );
mDoubleSpinBox->setClearValue( 0 );
}
else
{
mSpinBox->setValue( 0 );
mSpinBox->setClearValue( 0 );
}
}
}
if ( mDoubleSpinBox )
connect( mDoubleSpinBox, qgis::overload<double>::of( &QgsDoubleSpinBox::valueChanged ), this, [ = ] { emit widgetValueHasChanged( this ); } );
else if ( mSpinBox )
connect( mSpinBox, qgis::overload<int>::of( &QgsSpinBox::valueChanged ), this, [ = ] { emit widgetValueHasChanged( this ); } );
return spinBox;
};
}
return nullptr;
}
void QgsProcessingAuthConfigWidgetWrapper::setWidgetValue( const QVariant &value, QgsProcessingContext &context )
{
const QString v = QgsProcessingParameters::parameterAsString( parameterDefinition(), value, context );
if ( mAuthConfigSelect )
mAuthConfigSelect->setConfigId( v );
}
QStringList QgsProcessingAlgorithm::parameterAsFields( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context ) const
{
return QgsProcessingParameters::parameterAsFields( parameterDefinition( name ), parameters, context );
}
QgsFeatureSink *QgsProcessingAlgorithm::parameterAsSink( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context, QString &destinationIdentifier, const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs, QgsFeatureSink::SinkFlags sinkFlags ) const
{
return QgsProcessingParameters::parameterAsSink( parameterDefinition( name ), parameters, fields, geometryType, crs, context, destinationIdentifier, sinkFlags );
}
QgsVectorLayer *QgsProcessingAlgorithm::parameterAsVectorLayer( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context ) const
{
return QgsProcessingParameters::parameterAsVectorLayer( parameterDefinition( name ), parameters, context );
}
QgsGeometry QgsProcessingAlgorithm::parameterAsExtentGeometry( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs )
{
return QgsProcessingParameters::parameterAsExtentGeometry( parameterDefinition( name ), parameters, context, crs );
}
QgsCoordinateReferenceSystem QgsProcessingAlgorithm::parameterAsPointCrs( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context )
{
return QgsProcessingParameters::parameterAsPointCrs( parameterDefinition( name ), parameters, context );
}
QList<QgsMapLayer *> QgsProcessingAlgorithm::parameterAsLayerList( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context ) const
{
return QgsProcessingParameters::parameterAsLayerList( parameterDefinition( name ), parameters, context );
}
QVariantMap QgsBufferAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) const
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
return QVariantMap();
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT_LAYER" ), context, source->fields(), QgsWkbTypes::Polygon, source->sourceCrs(), dest ) );
if ( !sink )
return QVariantMap();
// fixed parameters
bool dissolve = parameterAsBool( parameters, QStringLiteral( "DISSOLVE" ), context );
int segments = parameterAsInt( parameters, QStringLiteral( "SEGMENTS" ), context );
QgsGeometry::EndCapStyle endCapStyle = static_cast< QgsGeometry::EndCapStyle >( 1 + parameterAsInt( parameters, QStringLiteral( "END_CAP_STYLE" ), context ) );
QgsGeometry::JoinStyle joinStyle = static_cast< QgsGeometry::JoinStyle>( 1 + parameterAsInt( parameters, QStringLiteral( "JOIN_STYLE" ), context ) );
double miterLimit = parameterAsDouble( parameters, QStringLiteral( "MITRE_LIMIT" ), context );
double bufferDistance = parameterAsDouble( parameters, QStringLiteral( "DISTANCE" ), context );
bool dynamicBuffer = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DISTANCE" ) );
const QgsProcessingParameterDefinition *distanceParamDef = parameterDefinition( QStringLiteral( "DISTANCE" ) );
long count = source->featureCount();
if ( count <= 0 )
return QVariantMap();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = 100.0 / count;
int current = 0;
QList< QgsGeometry > bufferedGeometriesForDissolve;
QgsAttributes dissolveAttrs;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( dissolveAttrs.isEmpty() )
dissolveAttrs = f.attributes();
QgsFeature out = f;
if ( out.hasGeometry() )
{
if ( dynamicBuffer )
{
context.expressionContext().setFeature( f );
bufferDistance = QgsProcessingParameters::parameterAsDouble( distanceParamDef, parameters, context );
}
QgsGeometry outputGeometry = f.geometry().buffer( bufferDistance, segments, endCapStyle, joinStyle, miterLimit );
if ( !outputGeometry )
{
QgsMessageLog::logMessage( QObject::tr( "Error calculating buffer for feature %1" ).arg( f.id() ), QObject::tr( "Processing" ), QgsMessageLog::WARNING );
}
if ( dissolve )
bufferedGeometriesForDissolve << outputGeometry;
else
out.setGeometry( outputGeometry );
}
if ( !dissolve )
sink->addFeature( out );
feedback->setProgress( current * step );
current++;
}
if ( dissolve )
{
QgsGeometry finalGeometry = QgsGeometry::unaryUnion( bufferedGeometriesForDissolve );
QgsFeature f;
f.setGeometry( finalGeometry );
f.setAttributes( dissolveAttrs );
sink->addFeature( f );
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT_LAYER" ), dest );
return outputs;
}
QgsLayoutItem *QgsProcessingAlgorithm::parameterAsLayoutItem( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context, QgsPrintLayout *layout )
{
return QgsProcessingParameters::parameterAsLayoutItem( parameterDefinition( name ), parameters, context, layout );
}
QWidget *QgsProcessingRangeWidgetWrapper::createWidget()
{
const QgsProcessingParameterRange *rangeDef = static_cast< const QgsProcessingParameterRange * >( parameterDefinition() );
switch ( type() )
{
case QgsProcessingGui::Standard:
case QgsProcessingGui::Modeler:
case QgsProcessingGui::Batch:
{
QHBoxLayout *layout = new QHBoxLayout();
mMinSpinBox = new QgsDoubleSpinBox();
mMaxSpinBox = new QgsDoubleSpinBox();
mMinSpinBox->setExpressionsEnabled( true );
mMinSpinBox->setShowClearButton( false );
mMaxSpinBox->setExpressionsEnabled( true );
mMaxSpinBox->setShowClearButton( false );
QLabel *minLabel = new QLabel( tr( "Min" ) );
layout->addWidget( minLabel );
layout->addWidget( mMinSpinBox, 1 );
QLabel *maxLabel = new QLabel( tr( "Max" ) );
layout->addWidget( maxLabel );
layout->addWidget( mMaxSpinBox, 1 );
QWidget *w = new QWidget();
layout->setMargin( 0 );
layout->setContentsMargins( 0, 0, 0, 0 );
w->setLayout( layout );
if ( rangeDef->dataType() == QgsProcessingParameterNumber::Double )
{
mMinSpinBox->setDecimals( 6 );
mMaxSpinBox->setDecimals( 6 );
}
else
{
mMinSpinBox->setDecimals( 0 );
mMaxSpinBox->setDecimals( 0 );
}
mMinSpinBox->setMinimum( -99999999.999999 );
mMaxSpinBox->setMinimum( -99999999.999999 );
mMinSpinBox->setMaximum( 99999999.999999 );
mMaxSpinBox->setMaximum( 99999999.999999 );
w->setToolTip( parameterDefinition()->toolTip() );
connect( mMinSpinBox, qgis::overload<double>::of( &QgsDoubleSpinBox::valueChanged ), this, [ = ]( const double v )
{
mBlockChangedSignal++;
if ( v > mMaxSpinBox->value() )
mMaxSpinBox->setValue( v );
mBlockChangedSignal--;
if ( !mBlockChangedSignal )
emit widgetValueHasChanged( this );
} );
connect( mMaxSpinBox, qgis::overload<double>::of( &QgsDoubleSpinBox::valueChanged ), this, [ = ]( const double v )
{
mBlockChangedSignal++;
if ( v < mMinSpinBox->value() )
mMinSpinBox->setValue( v );
mBlockChangedSignal--;
if ( !mBlockChangedSignal )
emit widgetValueHasChanged( this );
} );
return w;
};
}
return nullptr;
}
QString QgsProcessingAlgorithm::parameterAsCompatibleSourceLayerPath( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback )
{
return QgsProcessingParameters::parameterAsCompatibleSourceLayerPath( parameterDefinition( name ), parameters, context, compatibleFormats, preferredFormat, feedback );
}
QString QgsProcessingModelAlgorithm::asPythonCode() const
{
QStringList lines;
lines << QStringLiteral( "##%1=name" ).arg( name() );
QMap< QString, ModelParameter >::const_iterator paramIt = mParameterComponents.constBegin();
for ( ; paramIt != mParameterComponents.constEnd(); ++paramIt )
{
QString name = paramIt.value().parameterName();
if ( parameterDefinition( name ) )
{
lines << parameterDefinition( name )->asScriptCode();
}
}
auto safeName = []( const QString & name )->QString
{
QString n = name.toLower().trimmed();
QRegularExpression rx( "[^a-z_]" );
n.replace( rx, QString() );
return n;
};
QMap< QString, ChildAlgorithm >::const_iterator childIt = mChildAlgorithms.constBegin();
for ( ; childIt != mChildAlgorithms.constEnd(); ++childIt )
{
if ( !childIt->isActive() || !childIt->algorithm() )
continue;
// look through all outputs for child
QMap<QString, QgsProcessingModelAlgorithm::ModelOutput> outputs = childIt->modelOutputs();
QMap<QString, QgsProcessingModelAlgorithm::ModelOutput>::const_iterator outputIt = outputs.constBegin();
for ( ; outputIt != outputs.constEnd(); ++outputIt )
{
const QgsProcessingOutputDefinition *output = childIt->algorithm()->outputDefinition( outputIt->childOutputName() );
lines << QStringLiteral( "##%1=output %2" ).arg( safeName( outputIt->name() ), output->type() );
}
}
lines << QStringLiteral( "results={}" );
QSet< QString > toExecute;
childIt = mChildAlgorithms.constBegin();
for ( ; childIt != mChildAlgorithms.constEnd(); ++childIt )
{
if ( childIt->isActive() && childIt->algorithm() )
toExecute.insert( childIt->childId() );
}
QSet< QString > executed;
bool executedAlg = true;
while ( executedAlg && executed.count() < toExecute.count() )
{
executedAlg = false;
Q_FOREACH ( const QString &childId, toExecute )
{
if ( executed.contains( childId ) )
continue;
bool canExecute = true;
Q_FOREACH ( const QString &dependency, dependsOnChildAlgorithms( childId ) )
{
if ( !executed.contains( dependency ) )
{
canExecute = false;
break;
}
}
if ( !canExecute )
continue;
executedAlg = true;
const ChildAlgorithm &child = mChildAlgorithms[ childId ];
lines << child.asPythonCode();
executed.insert( childId );
}
}
lines << QStringLiteral( "return results" );
return lines.join( '\n' );
}
QList<double> QgsProcessingAlgorithm::parameterAsRange( const QVariantMap ¶meters, const QString &name, QgsProcessingContext &context ) const
{
return QgsProcessingParameters::parameterAsRange( parameterDefinition( name ), parameters, context );
}