qgsmodeldesignerdialog.cpp

Go to the documentation of this file.

/***************************************************************************
                             qgsmodeldesignerdialog.cpp
                             ------------------------
    Date                 : March 2020
    Copyright            : (C) 2020 Nyall Dawson
    Email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsmodeldesignerdialog.h"
 
#include "processing/models/qgsmodelinputreorderwidget.h"
#include "processing/models/qgsmodeloutputreorderwidget.h"
#include "processing/models/qgsprocessingmodelgroupbox.h"
#include "qgsapplication.h"
#include "qgscodeeditorpython.h"
#include "qgsfileutils.h"
#include "qgsgui.h"
#include "qgsmessagebar.h"
#include "qgsmessagebaritem.h"
#include "qgsmessagelog.h"
#include "qgsmessageviewer.h"
#include "qgsmodelcomponentgraphicitem.h"
#include "qgsmodeldesignerconfigdockwidget.h"
#include "qgsmodeldesignerconfigwidget.h"
#include "qgsmodelgraphicsscene.h"
#include "qgsmodelundocommand.h"
#include "qgsmodelviewtoolpan.h"
#include "qgsmodelviewtoolselect.h"
#include "qgspanelwidget.h"
#include "qgsprocessingalgorithm.h"
#include "qgsprocessingalgorithmwidgetbase.h"
#include "qgsprocessingguiregistry.h"
#include "qgsprocessinghelpeditorwidget.h"
#include "qgsprocessingmodelalgorithm.h"
#include "qgsprocessingmodelfeedback.h"
#include "qgsprocessingmultipleselectiondialog.h"
#include "qgsprocessingparameterdefinitionwidget.h"
#include "qgsprocessingparametertype.h"
#include "qgsprocessingprojectmodelprovider.h"
#include "qgsprocessingregistry.h"
#include "qgsprocessingscripteditordialog.h"
#include "qgsprocessingwidgetwrapper.h"
#include "qgsproject.h"
#include "qgsscreenhelper.h"
#include "qgssettings.h"
 
#include <QActionGroup>
#include <QCloseEvent>
#include <QFileDialog>
#include <QKeySequence>
#include <QMessageBox>
#include <QPdfWriter>
#include <QPushButton>
#include <QShortcut>
#include <QString>
#include <QSvgGenerator>
#include <QTextStream>
#include <QTimer>
#include <QToolButton>
#include <QUndoView>
#include <QUrl>
 
#include "moc_qgsmodeldesignerdialog.cpp"
 
using namespace Qt::StringLiterals;

 
 
QgsModelerToolboxModel::QgsModelerToolboxModel( QObject *parent )
  : QgsProcessingToolboxProxyModel( parent )
{}
 
Qt::ItemFlags QgsModelerToolboxModel::flags( const QModelIndex &index ) const
{
  Qt::ItemFlags f = QgsProcessingToolboxProxyModel::flags( index );
  const QModelIndex sourceIndex = mapToSource( index );
  if ( toolboxModel()->isAlgorithm( sourceIndex ) || toolboxModel()->isParameter( sourceIndex ) )
  {
    f = f | Qt::ItemIsDragEnabled;
  }
  return f;
}
 
Qt::DropActions QgsModelerToolboxModel::supportedDragActions() const
{
  return Qt::CopyAction;
}
 
QgsModelDesignerDialog::QgsModelDesignerDialog( QWidget *parent, Qt::WindowFlags flags )
  : QMainWindow( parent, flags )
  , mContext( QgsGui::processingGuiRegistry()->contextFactory() ? QgsGui::processingGuiRegistry()->contextFactory()->createContext() : new QgsProcessingContext() )
  , mToolsActionGroup( new QActionGroup( this ) )
{
  setupUi( this );
 
  mToolbar->setIconSize( QgsGui::iconSize() );
  setStyleSheet( QgsGui::applicationStyleSheet() );
  connect( QgsGui::instance(), &QgsGui::applicationStyleSheetChanged, this, &QgsModelDesignerDialog::setStyleSheet );
 
  mLayerStore.setProject( QgsProject::instance() );
 
  mScreenHelper = new QgsScreenHelper( this );
 
  setAttribute( Qt::WA_DeleteOnClose );
  setDockOptions( dockOptions() | QMainWindow::GroupedDragging );
  setWindowFlags( Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint );
 
  QgsGui::enableAutoGeometryRestore( this );
 
  mModel = std::make_unique<QgsProcessingModelAlgorithm>();
  mModel->setProvider( QgsApplication::processingRegistry()->providerById( QgsProcessing::MODEL_PROVIDER_ID ) );
 
  mUndoStack = new QUndoStack( this );
  connect( mUndoStack, &QUndoStack::indexChanged, this, [this] {
    if ( mIgnoreUndoStackChanges )
      return;
 
    mBlockUndoCommands++;
    updateVariablesGui();
    mGroupEdit->setText( mModel->group() );
    mNameEdit->setText( mModel->displayName() );
    mBlockUndoCommands--;
    repaintModel();
  } );
 
  mConfigWidgetDock = new QgsDockWidget( this );
  mConfigWidgetDock->setWindowTitle( tr( "Configuration" ) );
  mConfigWidgetDock->setObjectName( u"ModelConfigDock"_s );
 
  mConfigWidget = new QgsModelDesignerConfigDockWidget();
  mConfigWidgetDock->setWidget( mConfigWidget );
  mConfigWidgetDock->setFeatures( QDockWidget::NoDockWidgetFeatures );
  addDockWidget( Qt::RightDockWidgetArea, mConfigWidgetDock );
 
  mPropertiesDock->setFeatures( QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable );
  mInputsDock->setFeatures( QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable );
  mAlgorithmsDock->setFeatures( QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable );
  mVariablesDock->setFeatures( QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable );
 
  mToolboxTree->header()->setVisible( false );
  mToolboxSearchEdit->setShowSearchIcon( true );
  mToolboxSearchEdit->setPlaceholderText( tr( "Search…" ) );
  connect( mToolboxSearchEdit, &QgsFilterLineEdit::textChanged, mToolboxTree, &QgsProcessingToolboxTreeView::setFilterString );
 
  mInputsTreeWidget->header()->setVisible( false );
  mInputsTreeWidget->setAlternatingRowColors( true );
  mInputsTreeWidget->setDragDropMode( QTreeWidget::DragOnly );
  mInputsTreeWidget->setDropIndicatorShown( true );
 
  mNameEdit->setPlaceholderText( tr( "Enter model name here" ) );
  mGroupEdit->setPlaceholderText( tr( "Enter group name here" ) );
 
  mMessageBar = new QgsMessageBar();
  mMessageBar->setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed );
  mainLayout->insertWidget( 0, mMessageBar );
 
  mView->setAcceptDrops( true );
  QgsSettings settings;
 
  connect( mActionClose, &QAction::triggered, this, &QWidget::close );
  connect( mActionNew, &QAction::triggered, this, &QgsModelDesignerDialog::newModel );
  connect( mActionZoomIn, &QAction::triggered, this, &QgsModelDesignerDialog::zoomIn );
  connect( mActionZoomOut, &QAction::triggered, this, &QgsModelDesignerDialog::zoomOut );
  connect( mActionZoomActual, &QAction::triggered, this, &QgsModelDesignerDialog::zoomActual );
  connect( mActionZoomToItems, &QAction::triggered, this, &QgsModelDesignerDialog::zoomFull );
  connect( mActionExportImage, &QAction::triggered, this, &QgsModelDesignerDialog::exportToImage );
  connect( mActionExportPdf, &QAction::triggered, this, &QgsModelDesignerDialog::exportToPdf );
  connect( mActionExportSvg, &QAction::triggered, this, &QgsModelDesignerDialog::exportToSvg );
  connect( mActionExportPython, &QAction::triggered, this, &QgsModelDesignerDialog::exportAsPython );
  connect( mActionOpen, &QAction::triggered, this, &QgsModelDesignerDialog::openModel );
  connect( mActionSave, &QAction::triggered, this, [this] { saveModel( false ); } );
  connect( mActionSaveAs, &QAction::triggered, this, [this] { saveModel( true ); } );
  connect( mActionSaveInProject, &QAction::triggered, this, &QgsModelDesignerDialog::saveInProject );
  connect( mActionDeleteComponents, &QAction::triggered, this, &QgsModelDesignerDialog::deleteSelected );
  connect( mActionSnapSelected, &QAction::triggered, mView, &QgsModelGraphicsView::snapSelected );
  connect( mActionValidate, &QAction::triggered, this, &QgsModelDesignerDialog::validate );
  connect( mActionReorderInputs, &QAction::triggered, this, &QgsModelDesignerDialog::reorderInputs );
  connect( mActionReorderOutputs, &QAction::triggered, this, &QgsModelDesignerDialog::reorderOutputs );
  connect( mActionEditHelp, &QAction::triggered, this, &QgsModelDesignerDialog::editHelp );
  connect( mReorderInputsButton, &QPushButton::clicked, this, &QgsModelDesignerDialog::reorderInputs );
  connect( mActionRun, &QAction::triggered, this, [this] { run(); } );
  connect( mActionRunSelectedSteps, &QAction::triggered, this, &QgsModelDesignerDialog::runSelectedSteps );
 
  mActionSnappingEnabled->setChecked( settings.value( u"/Processing/Modeler/enableSnapToGrid"_s, false ).toBool() );
  connect( mActionSnappingEnabled, &QAction::toggled, this, [this]( bool enabled ) {
    mView->snapper()->setSnapToGrid( enabled );
    QgsSettings().setValue( u"/Processing/Modeler/enableSnapToGrid"_s, enabled );
  } );
  mView->snapper()->setSnapToGrid( mActionSnappingEnabled->isChecked() );
 
  connect( mView, &QgsModelGraphicsView::itemFocused, this, &QgsModelDesignerDialog::onItemFocused );
 
  connect( mActionSelectAll, &QAction::triggered, this, [this] { mScene->selectAll(); } );
 
  QStringList docksTitle = settings.value( u"ModelDesigner/hiddenDocksTitle"_s, QStringList(), QgsSettings::App ).toStringList();
  QStringList docksActive = settings.value( u"ModelDesigner/hiddenDocksActive"_s, QStringList(), QgsSettings::App ).toStringList();
  if ( !docksTitle.isEmpty() )
  {
    for ( const auto &title : docksTitle )
    {
      mPanelStatus.insert( title, PanelStatus( true, docksActive.contains( title ) ) );
    }
  }
  mActionHidePanels->setChecked( !docksTitle.isEmpty() );
  connect( mActionHidePanels, &QAction::toggled, this, &QgsModelDesignerDialog::setPanelVisibility );
 
  mUndoAction = mUndoStack->createUndoAction( this );
  mUndoAction->setIcon( QgsApplication::getThemeIcon( u"/mActionUndo.svg"_s ) );
  mUndoAction->setShortcuts( QKeySequence::Undo );
  mRedoAction = mUndoStack->createRedoAction( this );
  mRedoAction->setIcon( QgsApplication::getThemeIcon( u"/mActionRedo.svg"_s ) );
  mRedoAction->setShortcuts( QKeySequence::Redo );
 
  mMenuEdit->insertAction( mActionDeleteComponents, mRedoAction );
  mMenuEdit->insertAction( mActionDeleteComponents, mUndoAction );
  mMenuEdit->insertSeparator( mActionDeleteComponents );
  mToolbar->insertAction( mActionZoomIn, mUndoAction );
  mToolbar->insertAction( mActionZoomIn, mRedoAction );
  mToolbar->insertSeparator( mActionZoomIn );
 
  mGroupMenu = new QMenu( tr( "Zoom To" ), this );
  mMenuView->insertMenu( mActionZoomIn, mGroupMenu );
  connect( mGroupMenu, &QMenu::aboutToShow, this, &QgsModelDesignerDialog::populateZoomToMenu );
 
  //cut/copy/paste actions. Note these are not included in the ui file
  //as ui files have no support for QKeySequence shortcuts
  mActionCut = new QAction( tr( "Cu&t" ), this );
  mActionCut->setShortcuts( QKeySequence::Cut );
  mActionCut->setStatusTip( tr( "Cut" ) );
  mActionCut->setIcon( QgsApplication::getThemeIcon( u"/mActionEditCut.svg"_s ) );
  connect( mActionCut, &QAction::triggered, this, [this] { mView->copySelectedItems( QgsModelGraphicsView::ClipboardCut ); } );
 
  mActionCopy = new QAction( tr( "&Copy" ), this );
  mActionCopy->setShortcuts( QKeySequence::Copy );
  mActionCopy->setStatusTip( tr( "Copy" ) );
  mActionCopy->setIcon( QgsApplication::getThemeIcon( u"/mActionEditCopy.svg"_s ) );
  connect( mActionCopy, &QAction::triggered, this, [this] { mView->copySelectedItems( QgsModelGraphicsView::ClipboardCopy ); } );
 
  mActionPaste = new QAction( tr( "&Paste" ), this );
  mActionPaste->setShortcuts( QKeySequence::Paste );
  mActionPaste->setStatusTip( tr( "Paste" ) );
  mActionPaste->setIcon( QgsApplication::getThemeIcon( u"/mActionEditPaste.svg"_s ) );
  connect( mActionPaste, &QAction::triggered, this, [this] { mView->pasteItems( QgsModelGraphicsView::PasteModeCursor ); } );
  mMenuEdit->insertAction( mActionDeleteComponents, mActionCut );
  mMenuEdit->insertAction( mActionDeleteComponents, mActionCopy );
  mMenuEdit->insertAction( mActionDeleteComponents, mActionPaste );
  mMenuEdit->insertSeparator( mActionDeleteComponents );
 
  mAlgorithmsModel = new QgsModelerToolboxModel( this );
  mToolboxTree->setToolboxProxyModel( mAlgorithmsModel );
 
  QgsProcessingToolboxProxyModel::Filters filters = QgsProcessingToolboxProxyModel::Filter::Modeler;
  if ( settings.value( u"Processing/Configuration/SHOW_ALGORITHMS_KNOWN_ISSUES"_s, false ).toBool() )
  {
    filters |= QgsProcessingToolboxProxyModel::Filter::ShowKnownIssues;
  }
  mToolboxTree->setFilters( filters );
  mToolboxTree->setDragDropMode( QTreeWidget::DragOnly );
  mToolboxTree->setDropIndicatorShown( true );
 
  connect( mView, &QgsModelGraphicsView::algorithmDropped, this, [this]( const QString &algorithmId, const QPointF &pos ) { addAlgorithm( algorithmId, pos ); } );
  connect( mView, &QgsModelGraphicsView::inputDropped, this, &QgsModelDesignerDialog::addInput );
 
  connect( mToolboxTree, &QgsProcessingToolboxTreeView::doubleClicked, this, [this]( const QModelIndex & ) {
    if ( mToolboxTree->selectedAlgorithm() )
      addAlgorithm( mToolboxTree->selectedAlgorithm()->id(), QPointF() );
    if ( mToolboxTree->selectedParameterType() )
      addInput( mToolboxTree->selectedParameterType()->id(), QPointF() );
  } );
 
  connect( mInputsTreeWidget, &QgsModelDesignerInputsTreeWidget::doubleClicked, this, [this]( const QModelIndex & ) {
    const QString parameterType = mInputsTreeWidget->currentItem()->data( 0, Qt::UserRole ).toString();
    addInput( parameterType, QPointF() );
  } );
 
  // Ctrl+= should also trigger a zoom in action
  QShortcut *ctrlEquals = new QShortcut( QKeySequence( u"Ctrl+="_s ), this );
  connect( ctrlEquals, &QShortcut::activated, this, &QgsModelDesignerDialog::zoomIn );
 
  mUndoDock = new QgsDockWidget( tr( "Undo History" ), this );
  mUndoDock->setObjectName( u"UndoDock"_s );
  mUndoView = new QUndoView( mUndoStack, this );
  mUndoDock->setWidget( mUndoView );
  mUndoDock->setFeatures( QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable );
  addDockWidget( Qt::DockWidgetArea::LeftDockWidgetArea, mUndoDock );
 
  tabifyDockWidget( mUndoDock, mPropertiesDock );
  tabifyDockWidget( mVariablesDock, mPropertiesDock );
  mPropertiesDock->raise();
  tabifyDockWidget( mInputsDock, mAlgorithmsDock );
  mInputsDock->raise();
 
  connect( mVariablesEditor, &QgsVariableEditorWidget::scopeChanged, this, [this] {
    if ( mModel )
    {
      beginUndoCommand( tr( "Change Model Variables" ) );
      mModel->setVariables( mVariablesEditor->variablesInActiveScope() );
      endUndoCommand();
    }
  } );
  connect( mNameEdit, &QLineEdit::textChanged, this, [this]( const QString &name ) {
    if ( mModel )
    {
      beginUndoCommand( tr( "Change Model Name" ), QString(), QgsModelUndoCommand::CommandOperation::NameChanged );
      mModel->setName( name );
      endUndoCommand();
      updateWindowTitle();
    }
  } );
  connect( mGroupEdit, &QLineEdit::textChanged, this, [this]( const QString &group ) {
    if ( mModel )
    {
      beginUndoCommand( tr( "Change Model Group" ), QString(), QgsModelUndoCommand::CommandOperation::GroupChanged );
      mModel->setGroup( group );
      endUndoCommand();
      updateWindowTitle();
    }
  } );
 
  fillInputsTree();
 
  QToolButton *toolbuttonExportToScript = new QToolButton();
  toolbuttonExportToScript->setPopupMode( QToolButton::InstantPopup );
  toolbuttonExportToScript->addAction( mActionExportAsScriptAlgorithm );
  toolbuttonExportToScript->setDefaultAction( mActionExportAsScriptAlgorithm );
  mToolbar->insertWidget( mActionExportImage, toolbuttonExportToScript );
  connect( mActionExportAsScriptAlgorithm, &QAction::triggered, this, &QgsModelDesignerDialog::exportAsScriptAlgorithm );
 
  mActionShowComments->setChecked( settings.value( u"/Processing/Modeler/ShowComments"_s, true ).toBool() );
  connect( mActionShowComments, &QAction::toggled, this, &QgsModelDesignerDialog::toggleComments );
 
  mActionShowFeatureCount->setChecked( settings.value( u"/Processing/Modeler/ShowFeatureCount"_s, true ).toBool() );
  connect( mActionShowFeatureCount, &QAction::toggled, this, &QgsModelDesignerDialog::toggleFeatureCount );
 
  mPanTool = new QgsModelViewToolPan( mView );
  mPanTool->setAction( mActionPan );
 
  mToolsActionGroup->addAction( mActionPan );
  connect( mActionPan, &QAction::triggered, mPanTool, [this] { mView->setTool( mPanTool ); } );
 
  // We use a QObjectUniquePtr here because we want to delete QgsModelViewToolSelect
  // mouse handles before everything else and don't want to wait for QObject destructor to destroy it
  mSelectTool = make_qobject_unique<QgsModelViewToolSelect>( mView );
  mSelectTool->setAction( mActionSelectMoveItem );
 
  mToolsActionGroup->addAction( mActionSelectMoveItem );
  connect( mActionSelectMoveItem, &QAction::triggered, mSelectTool, [this] { mView->setTool( mSelectTool ); } );
 
  mView->setTool( mSelectTool );
  mView->setFocus();
 
  connect( mView, &QgsModelGraphicsView::macroCommandStarted, this, [this]( const QString &text ) {
    mIgnoreUndoStackChanges++;
    mUndoStack->beginMacro( text );
    mIgnoreUndoStackChanges--;
  } );
  connect( mView, &QgsModelGraphicsView::macroCommandEnded, this, [this] {
    mIgnoreUndoStackChanges++;
    mUndoStack->endMacro();
    mIgnoreUndoStackChanges--;
  } );
  connect( mView, &QgsModelGraphicsView::commandBegun, this, [this]( const QString &text ) { beginUndoCommand( text ); } );
  connect( mView, &QgsModelGraphicsView::commandEnded, this, [this] { endUndoCommand(); } );
  connect( mView, &QgsModelGraphicsView::commandAborted, this, [this] { abortUndoCommand(); } );
  connect( mView, &QgsModelGraphicsView::deleteSelectedItems, this, [this] { deleteSelected(); } );
 
  connect( mActionAddGroupBox, &QAction::triggered, this, [this] {
    const QPointF viewCenter = mView->mapToScene( mView->viewport()->rect().center() );
    QgsProcessingModelGroupBox group;
    group.setPosition( viewCenter );
    group.setDescription( tr( "New Group" ) );
 
    beginUndoCommand( tr( "Add Group Box" ) );
    model()->addGroupBox( group );
    repaintModel();
    endUndoCommand();
  } );
 
  updateWindowTitle();
 
  // restore the toolbar and dock widgets positions using Qt settings API
  restoreState( settings.value( u"ModelDesigner/state"_s, QByteArray(), QgsSettings::App ).toByteArray() );
}
 
QgsModelDesignerDialog::~QgsModelDesignerDialog()
{
  if ( mAlgorithmWidget )
  {
    delete mAlgorithmWidget;
  }
  for ( const QPointer<QgsProcessingAlgorithmWidget> &widget : std::as_const( mAlgorithmWidgetsToCleanUp ) )
  {
    // this is a work around for the MESSY ownership issues associated with the python subclass
    // of QgsProcessingAlgorithmWidget. We have to FORCE all widgets to be deleted prior
    // to destruction of this window, and we can't be sure that python will have actually
    // deleted the widget when we asked...
    if ( widget )
    {
      delete widget;
    }
  }
 
  QgsSettings settings;
  if ( !mPanelStatus.isEmpty() )
  {
    QStringList docksTitle;
    QStringList docksActive;
 
    for ( const auto &panel : mPanelStatus.toStdMap() )
    {
      if ( panel.second.isVisible )
        docksTitle << panel.first;
      if ( panel.second.isActive )
        docksActive << panel.first;
    }
    settings.setValue( u"ModelDesigner/hiddenDocksTitle"_s, docksTitle, QgsSettings::App );
    settings.setValue( u"ModelDesigner/hiddenDocksActive"_s, docksActive, QgsSettings::App );
  }
  else
  {
    settings.remove( u"ModelDesigner/hiddenDocksTitle"_s, QgsSettings::App );
    settings.remove( u"ModelDesigner/hiddenDocksActive"_s, QgsSettings::App );
  }
 
  // store the toolbar/dock widget settings using Qt settings API
  settings.setValue( u"ModelDesigner/state"_s, saveState(), QgsSettings::App );
 
  mIgnoreUndoStackChanges++;
}
 
void QgsModelDesignerDialog::closeEvent( QCloseEvent *event )
{
  if ( checkForUnsavedChanges() )
    event->accept();
  else
    event->ignore();
}
 
void QgsModelDesignerDialog::beginUndoCommand( const QString &text, const QString &id, QgsModelUndoCommand::CommandOperation operation )
{
  if ( mBlockUndoCommands || !mUndoStack )
    return;
 
  if ( mActiveCommand )
    endUndoCommand();
 
  if ( !id.isEmpty() )
  {
    mActiveCommand = std::make_unique<QgsModelUndoCommand>( mModel.get(), text, id );
  }
  else
  {
    mActiveCommand = std::make_unique<QgsModelUndoCommand>( mModel.get(), text, operation );
  }
}
 
void QgsModelDesignerDialog::endUndoCommand()
{
  if ( mBlockUndoCommands || !mActiveCommand || !mUndoStack )
    return;
 
  mActiveCommand->saveAfterState();
  mIgnoreUndoStackChanges++;
  mUndoStack->push( mActiveCommand.release() );
  mIgnoreUndoStackChanges--;
  setDirty( true );
}
 
void QgsModelDesignerDialog::abortUndoCommand()
{
  if ( mActiveCommand )
    mActiveCommand->setObsolete( true );
}
 
QgsProcessingModelAlgorithm *QgsModelDesignerDialog::model()
{
  return mModel.get();
}
 
void QgsModelDesignerDialog::setModel( QgsProcessingModelAlgorithm *model )
{
  mModel.reset( model );
 
  mGroupEdit->setText( mModel->group() );
  mNameEdit->setText( mModel->displayName() );
  repaintModel( true );
  updateVariablesGui();
 
  setDirty( false );
 
  mIgnoreUndoStackChanges++;
  mUndoStack->clear();
  mIgnoreUndoStackChanges--;
 
  updateWindowTitle();
 
  // Delay zoom to the full model to ensure the scene has been properly set
  // and that the itemsBoundingRect returns the correct value.
  QTimer::singleShot( 100, this, [this] { zoomFull(); } );
}
 
void QgsModelDesignerDialog::loadModel( const QString &path )
{
  auto alg = std::make_unique<QgsProcessingModelAlgorithm>();
  if ( alg->fromFile( path ) )
  {
    alg->setProvider( QgsApplication::processingRegistry()->providerById( QgsProcessing::MODEL_PROVIDER_ID ) );
    alg->setSourceFilePath( path );
    setModel( alg.release() );
  }
  else
  {
    QgsMessageLog::logMessage( tr( "Could not load model %1" ).arg( path ), tr( "Processing" ), Qgis::MessageLevel::Critical );
    QMessageBox::critical(
      this,
      tr( "Open Model" ),
      tr(
        "The selected model could not be loaded.\n"
        "See the log for more information."
      )
    );
  }
}
 
void QgsModelDesignerDialog::setModelScene( QgsModelGraphicsScene *scene )
{
  QgsModelGraphicsScene *oldScene = mScene;
 
  mScene = scene;
  mScene->setParent( this );
  mScene->setLastRunResult( mLastResult, mLayerStore );
  mScene->setModel( mModel.get() );
  mScene->setMessageBar( mMessageBar );
  mScene->registerWidgetContextGenerator( this );
 
  QgsSettings settings;
  const bool showFeatureCount = settings.value( u"/Processing/Modeler/ShowFeatureCount"_s, true ).toBool();
  if ( !showFeatureCount )
    mScene->setFlag( QgsModelGraphicsScene::FlagHideFeatureCount );
 
  mView->setModelScene( mScene );
 
  mSelectTool->resetCache();
  mSelectTool->setScene( mScene );
 
  connect( mScene, &QgsModelGraphicsScene::rebuildRequired, this, [this] {
    if ( mBlockRepaints )
      return;
 
    repaintModel();
    mScene->flagChildrenAsOutdated( mOutdatedChildResults );
  } );
  connect( mScene, &QgsModelGraphicsScene::componentAboutToChange, this, [this]( const QString &description, const QString &id ) { beginUndoCommand( description, id ); } );
  connect( mScene, &QgsModelGraphicsScene::componentChanged, this, [this] { endUndoCommand(); } );
  connect( mScene, &QgsModelGraphicsScene::runFromChild, this, &QgsModelDesignerDialog::runFromChild );
  connect( mScene, &QgsModelGraphicsScene::runSelected, this, &QgsModelDesignerDialog::runSelectedSteps );
  connect( mScene, &QgsModelGraphicsScene::showChildAlgorithmOutputs, this, &QgsModelDesignerDialog::showChildAlgorithmOutputs );
  connect( mScene, &QgsModelGraphicsScene::showChildAlgorithmLog, this, &QgsModelDesignerDialog::showChildAlgorithmLog );
 
  if ( oldScene )
    oldScene->deleteLater();
}
 
QgsModelGraphicsScene *QgsModelDesignerDialog::modelScene()
{
  return mScene;
}
 
QgsProcessingFeedback *QgsModelDesignerDialog::createFeedback()
{
  auto result = std::make_unique< QgsProcessingModelFeedback >();
  mScene->setupFeedbackConnections( result.get() );
  connect( result.get(), &QgsProcessingModelFeedback::childResultReported, this, [this]( const QString &childId, const QgsProcessingModelChildAlgorithmResult & ) {
    mOutdatedChildResults.remove( childId );
  } );
 
  return result.release();
}
 
QgsProcessingParameterWidgetContext QgsModelDesignerDialog::createWidgetContext()
{
  QgsProcessingParameterWidgetContext context = QgsGui::processingGuiRegistry()->createWidgetContext();
  context.setModel( model() );
  context.setModelDesignerDialog( this );
  context.registerProcessingContextGenerator( this );
  return context;
}
 
void QgsModelDesignerDialog::activate()
{
  show();
  raise();
  setWindowState( windowState() & ~Qt::WindowMinimized );
  activateWindow();
}
 
QgsProcessingContext *QgsModelDesignerDialog::processingContext() const
{
  return mContext.get();
}
 
void QgsModelDesignerDialog::updateVariablesGui()
{
  mBlockUndoCommands++;
 
  auto variablesScope = std::make_unique<QgsExpressionContextScope>( tr( "Model Variables" ) );
  const QVariantMap modelVars = mModel->variables();
  for ( auto it = modelVars.constBegin(); it != modelVars.constEnd(); ++it )
  {
    variablesScope->setVariable( it.key(), it.value() );
  }
  QgsExpressionContext variablesContext;
  variablesContext.appendScope( variablesScope.release() );
  mVariablesEditor->setContext( &variablesContext );
  mVariablesEditor->setEditableScopeIndex( 0 );
 
  mBlockUndoCommands--;
}
 
void QgsModelDesignerDialog::setDirty( bool dirty )
{
  mHasChanged = dirty;
  updateWindowTitle();
  if ( mAlgorithmWidget )
  {
    if ( QgsMessageBar *messageBar = mAlgorithmWidget->messageBar() )
    {
      QgsMessageBarItem *messageBarItem = messageBar->createMessage( QString(), tr( "The model has changed, this panel should be reloaded." ) );
      auto reloadButton = new QPushButton( tr( "Reload Now" ) );
      connect( reloadButton, &QPushButton::clicked, reloadButton, [this] {
        if ( mAlgorithmWidget && mAlgorithmWidget->isRunning() )
        {
          QMessageBox messageBox;
          messageBox.setIcon( QMessageBox::Icon::Warning );
          messageBox.setWindowTitle( tr( "Run Model" ) );
          messageBox.setText( tr( "This model is currently running." ) );
          messageBox.setStandardButtons( QMessageBox::StandardButton::Cancel | QMessageBox::StandardButton::RestoreDefaults );
 
          QAbstractButton *buttonReRun = messageBox.button( QMessageBox::StandardButton::RestoreDefaults );
          buttonReRun->setText( tr( "Terminate and Reload" ) );
 
          int r = messageBox.exec();
 
          switch ( r )
          {
            case QMessageBox::StandardButton::Cancel:
              return;
            case QMessageBox::StandardButton::RestoreDefaults:
              break;
            default:
              break;
          }
        }
        cancelRunningModel();
        run();
      } );
      messageBarItem->layout()->addWidget( reloadButton );
      messageBar->pushWidget( messageBarItem, Qgis::MessageLevel::Warning );
    }
  }
}
 
bool QgsModelDesignerDialog::validateSave( SaveAction action )
{
  switch ( action )
  {
    case QgsModelDesignerDialog::SaveAction::SaveAsFile:
      break;
    case QgsModelDesignerDialog::SaveAction::SaveInProject:
      if ( mNameEdit->text().trimmed().isEmpty() )
      {
        mMessageBar->pushWarning( QString(), tr( "Please enter a model name before saving" ) );
        return false;
      }
      break;
  }
 
  return true;
}
 
bool QgsModelDesignerDialog::checkForUnsavedChanges()
{
  if ( isDirty() )
  {
    QMessageBox::StandardButton ret = QMessageBox::
      question( this, tr( "Save Model?" ), tr( "There are unsaved changes in this model. Do you want to keep those?" ), QMessageBox::Save | QMessageBox::Cancel | QMessageBox::Discard, QMessageBox::Cancel );
    switch ( ret )
    {
      case QMessageBox::Save:
        return saveModel( false );
 
      case QMessageBox::Discard:
        return true;
 
      default:
        return false;
    }
  }
  else
  {
    return true;
  }
}
 
void QgsModelDesignerDialog::setLastRunResult( const QgsProcessingModelResult &result )
{
  mLastResult.mergeWith( result );
  if ( mScene )
    mScene->setLastRunResult( mLastResult, mLayerStore );
}
 
void QgsModelDesignerDialog::setModelName( const QString &name )
{
  mNameEdit->setText( name );
}
 
void QgsModelDesignerDialog::saveInProject()
{
  if ( !validateSave( SaveAction::SaveInProject ) )
    return;
 
  mModel->setSourceFilePath( QString() );
 
  auto projectProvider = qobject_cast< QgsProcessingProjectModelProvider * >( QgsApplication::processingRegistry()->providerById( QgsProcessing::PROJECT_PROVIDER_ID ) );
  if ( !projectProvider )
    return; // should not happen
 
  projectProvider->addModel( *mModel );
 
  emit modelUpdated();
 
  mMessageBar->pushMessage( QString(), tr( "Model was saved inside current project" ), Qgis::MessageLevel::Success, 5 );
 
  setDirty( false );
  QgsProject::instance()->setDirty( true );
}
 
bool QgsModelDesignerDialog::saveModel( bool saveAs )
{
  if ( !validateSave( SaveAction::SaveAsFile ) )
    return false;
 
  const bool modelNameMatchedFileName = mModel->modelNameMatchesFilePath();
  QString fileName;
  if ( !mModel->sourceFilePath().isEmpty() && !saveAs )
  {
    fileName = mModel->sourceFilePath();
  }
  else
  {
    QString initialPath;
    if ( !mModel->sourceFilePath().isEmpty() )
    {
      initialPath = mModel->sourceFilePath();
    }
    else if ( !mModel->name().isEmpty() )
    {
      initialPath = u"%1/%2.model3"_s.arg( QgsProcessingUtils::modelFolders()[0], mModel->name() );
    }
    else
    {
      initialPath = QgsProcessingUtils::modelFolders()[0];
    }
 
    fileName = QFileDialog::getSaveFileName( this, tr( "Save Model" ), initialPath, tr( "Processing models (*.model3 *.MODEL3)" ) );
    if ( fileName.isEmpty() )
    {
      return false;
    }
 
    fileName = QgsFileUtils::ensureFileNameHasExtension( fileName, { "model3" } );
    mModel->setSourceFilePath( fileName );
 
    if ( mModel->name().isEmpty() || mModel->name() == tr( "model" ) )
    {
      setModelName( QFileInfo( fileName ).baseName() );
    }
    else if ( saveAs && modelNameMatchedFileName )
    {
      // if saving as, and the model name used to match the filename, then automatically update the
      // model name to match the new file name
      setModelName( QFileInfo( fileName ).baseName() );
    }
  }
 
  if ( !mModel->toFile( fileName ) )
  {
    if ( saveAs )
    {
      QMessageBox::warning( this, tr( "Save Model" ), tr( "Unable to save edits (probably you do not have permission to write to this location)." ) );
    }
    else
    {
      QMessageBox::warning(
        this,
        tr( "Save Model" ),
        tr(
          "This model can't be saved in its original location (probably you do not "
          "have permission to do it). Please, use the 'Save as…' option."
        )
      );
    }
    return false;
  }
 
  emit modelUpdated();
  if ( saveAs )
  {
    mMessageBar->pushMessage( QString(), tr( "Model was saved to <a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( fileName ).toString(), QDir::toNativeSeparators( fileName ) ), Qgis::MessageLevel::Success, 5 );
  }
 
  setDirty( false );
  return true;
}
 
QPointF QgsModelDesignerDialog::getPositionForParameterItem() const
{
  constexpr double MARGIN = 20;
  constexpr double BOX_WIDTH = 200;
  constexpr double BOX_HEIGHT = 80;
 
  double newX = 0;
  const QMap<QString, QgsProcessingModelParameter> components = mModel->parameterComponents();
  if ( !components.isEmpty() )
  {
    double maxX = 0;
    for ( auto it = components.constBegin(); it != components.constEnd(); ++it )
    {
      maxX = std::max( maxX, it->position().x() );
    }
    newX = MARGIN + BOX_WIDTH + maxX;
  }
  else
  {
    newX = MARGIN + BOX_WIDTH / 2.0;
  }
  return QPointF( newX, MARGIN + BOX_HEIGHT / 2.0 );
}
 
QPointF QgsModelDesignerDialog::getPositionForAlgorithmItem() const
{
  constexpr double MARGIN = 20;
  constexpr double BOX_WIDTH = 200;
  constexpr double BOX_HEIGHT = 80;
 
  const QMap<QString, QgsProcessingModelChildAlgorithm> algorithms = mModel->childAlgorithms();
 
  double newX = 0;
  double newY = 0;
  if ( !algorithms.isEmpty() )
  {
    double maxX = 0;
    double maxY = 0;
    for ( auto it = algorithms.constBegin(); it != algorithms.constEnd(); ++it )
    {
      maxX = std::max( maxX, it->position().x() );
      maxY = std::max( maxY, it->position().y() );
    }
    newX = MARGIN + BOX_WIDTH + maxX;
    newY = MARGIN + BOX_HEIGHT + maxY;
  }
  else
  {
    newX = MARGIN + BOX_WIDTH / 2.0;
    newY = MARGIN * 2 + BOX_HEIGHT + BOX_HEIGHT / 2.0;
  }
  return QPointF( newX, newY );
}
 
void QgsModelDesignerDialog::autoGenerateParameterName( QgsProcessingParameterDefinition *parameter ) const
{
  const QString safeName = QgsProcessingModelAlgorithm::safeName( parameter->description() );
  QString name = safeName.toLower();
  int i = 2;
  while ( mModel->parameterDefinition( name ) )
  {
    name = safeName.toLower() + QString::number( i );
    i += 1;
  }
  parameter->setName( name );
}
 
void QgsModelDesignerDialog::addAlgorithm( const QString &algorithmId, const QPointF &pos )
{
  std::unique_ptr< QgsProcessingAlgorithm > alg( QgsApplication::processingRegistry()->createAlgorithmById( algorithmId ) );
  if ( !alg )
    return;
 
  QgsProcessingModelChildAlgorithm childAlg = QgsProcessingModelChildAlgorithm( algorithmId );
  childAlg.setDescription( alg->displayName() );
 
  if ( pos.isNull() )
  {
    childAlg.setPosition( getPositionForAlgorithmItem() );
  }
  else
  {
    childAlg.setPosition( pos );
  }
 
  childAlg.comment()->setPosition( childAlg.position() + QPointF( childAlg.size().width(), -1.5 * childAlg.size().height() ) );
 
  const double outputOffsetX = childAlg.size().width();
  double outputOffsetY = 1.5 * childAlg.size().height();
 
  const QMap<QString, QgsProcessingModelOutput> childOutputs = childAlg.modelOutputs();
  for ( auto out = childOutputs.constBegin(); out != childOutputs.constEnd(); ++out )
  {
    childAlg.modelOutput( out.key() ).setPosition( childAlg.position() + QPointF( outputOffsetX, outputOffsetY ) );
    outputOffsetY += 1.5 * childAlg.modelOutput( out.key() ).size().height();
  }
 
  beginUndoCommand( tr( "Add Algorithm" ) );
  mModel->addChildAlgorithm( childAlg );
  repaintModel();
  endUndoCommand();
}
 
void QgsModelDesignerDialog::addInput( const QString &parameterType, const QPointF &position )
{
  QPointF pos = position;
  if ( !QgsApplication::processingRegistry()->parameterType( parameterType ) )
    return;
 
  std::unique_ptr< QgsProcessingParameterDefinition > newParam;
  QString comment;
 
  QgsProcessingParameterWidgetContext widgetContext = createWidgetContext();
  QgsProcessingParameterDefinitionDialog dlg( parameterType, *mContext, widgetContext, nullptr, mModel.get() );
  dlg.registerProcessingContextGenerator( this );
  if ( !dlg.exec() )
    return;
 
  newParam.reset( dlg.createParameter() );
  if ( !newParam )
    return;
 
  autoGenerateParameterName( newParam.get() );
  dlg.comments();
  comment = dlg.comments();
 
  if ( pos.isNull() )
  {
    pos = getPositionForParameterItem();
  }
 
  QgsProcessingModelParameter component = QgsProcessingModelParameter( newParam->name() );
  component.setDescription( newParam->name() );
  component.setPosition( pos );
 
  component.comment()->setDescription( comment );
  component.comment()->setPosition( component.position() + QPointF( component.size().width(), -1.5 * component.size().height() ) );
 
  beginUndoCommand( tr( "Add Model Input" ) );
  mModel->addModelParameter( newParam.release(), component );
  repaintModel();
  endUndoCommand();
}
 
QgsProcessingAlgorithmWidget *QgsModelDesignerDialog::createExecutionWidget()
{
  QgsProcessingDialogFactory *dialogFactory = QgsGui::processingGuiRegistry()->dialogFactory();
  if ( !dialogFactory )
    return nullptr; // should never happen
 
  QgsProcessingAlgorithmWidget *widget = dialogFactory->createWidget( mModel->create(), false, this, QgsProcessingAlgorithmWidgetBase::WidgetFlags(), Qgis::DockableWidgetInitialState::ForceDocked );
  if ( !widget )
    return nullptr; // should never happen
 
  widget->registerProcessingFeedbackGenerator( this );
  return widget;
}
 
void QgsModelDesignerDialog::exportAsScriptAlgorithm()
{
  QgsProcessingDialogFactory *dialogFactory = QgsGui::processingGuiRegistry()->dialogFactory();
  if ( !dialogFactory )
    return; // should never happen
 
  QgsProcessingScriptEditorDialog *dialog = dialogFactory->createScriptEditorDialog();
  if ( !dialog )
    return; // should never happen
 
  const QStringList codeLines = mModel->asPythonCode( QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass, 4 );
 
  dialog->codeEditor()->setText( codeLines.join( '\n' ) );
 
  dialog->show();
}
 
void QgsModelDesignerDialog::zoomIn()
{
  mView->setTransformationAnchor( QGraphicsView::NoAnchor );
  QPointF point = mView->mapToScene( QPoint( mView->viewport()->width() / 2.0, mView->viewport()->height() / 2 ) );
  QgsSettings settings;
  const double factor = settings.value( u"/qgis/zoom_favor"_s, 2.0 ).toDouble();
  mView->scale( factor, factor );
  mView->centerOn( point );
}
 
void QgsModelDesignerDialog::zoomOut()
{
  mView->setTransformationAnchor( QGraphicsView::NoAnchor );
  QPointF point = mView->mapToScene( QPoint( mView->viewport()->width() / 2.0, mView->viewport()->height() / 2 ) );
  QgsSettings settings;
  const double factor = 1.0 / settings.value( u"/qgis/zoom_favor"_s, 2.0 ).toDouble();
  mView->scale( factor, factor );
  mView->centerOn( point );
}
 
void QgsModelDesignerDialog::zoomActual()
{
  QPointF point = mView->mapToScene( QPoint( mView->viewport()->width() / 2.0, mView->viewport()->height() / 2 ) );
  mView->resetTransform();
  mView->scale( mScreenHelper->screenDpi() / 96, mScreenHelper->screenDpi() / 96 );
  mView->centerOn( point );
}
 
void QgsModelDesignerDialog::zoomFull()
{
  QRectF totalRect = mView->scene()->itemsBoundingRect();
  totalRect.adjust( -10, -10, 10, 10 );
  mView->fitInView( totalRect, Qt::KeepAspectRatio );
}
 
void QgsModelDesignerDialog::newModel()
{
  if ( !checkForUnsavedChanges() )
    return;
 
  auto alg = std::make_unique<QgsProcessingModelAlgorithm>();
  alg->setProvider( QgsApplication::processingRegistry()->providerById( QgsProcessing::MODEL_PROVIDER_ID ) );
  setModel( alg.release() );
}
 
void QgsModelDesignerDialog::openModel()
{
  if ( !checkForUnsavedChanges() )
    return;
 
  QgsSettings settings;
  const QString lastModelDir = settings.value( u"Processing/lastModelsDir"_s, QDir::homePath() ).toString();
  const QString fileName = QFileDialog::getOpenFileName( this, tr( "Open Model" ), lastModelDir, tr( "Processing models (*.model3 *.MODEL3)" ) );
  if ( !fileName.isEmpty() )
  {
    settings.setValue( u"Processing/lastModelsDir"_s, QFileInfo( fileName ).absoluteDir().absolutePath() );
    loadModel( fileName );
  }
}
 
void QgsModelDesignerDialog::exportToImage()
{
  QgsSettings settings;
  QString lastExportDir = settings.value( u"lastModelDesignerExportDir"_s, QDir::homePath(), QgsSettings::App ).toString();
 
  QString filename = QFileDialog::getSaveFileName( this, tr( "Save Model as Image" ), lastExportDir, tr( "PNG files (*.png *.PNG)" ) );
  // return dialog focus on Mac
  activateWindow();
  raise();
  if ( filename.isEmpty() )
    return;
 
  filename = QgsFileUtils::ensureFileNameHasExtension( filename, QStringList() << u"png"_s );
 
  const QFileInfo saveFileInfo( filename );
  settings.setValue( u"lastModelDesignerExportDir"_s, saveFileInfo.absolutePath(), QgsSettings::App );
 
  repaintModel( false );
 
  QRectF totalRect = mView->scene()->itemsBoundingRect();
  totalRect.adjust( -10, -10, 10, 10 );
  const QRectF imageRect = QRectF( 0, 0, totalRect.width(), totalRect.height() );
 
  QImage img( totalRect.width(), totalRect.height(), QImage::Format_ARGB32_Premultiplied );
  img.fill( Qt::white );
  QPainter painter;
  painter.setRenderHint( QPainter::Antialiasing );
  painter.begin( &img );
  mView->scene()->render( &painter, imageRect, totalRect );
  painter.end();
 
  img.save( filename );
 
  mMessageBar
    ->pushMessage( QString(), tr( "Successfully exported model as image to <a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( filename ).toString(), QDir::toNativeSeparators( filename ) ), Qgis::MessageLevel::Success, 0 );
  repaintModel( true );
}
 
void QgsModelDesignerDialog::exportToPdf()
{
  QgsSettings settings;
  QString lastExportDir = settings.value( u"lastModelDesignerExportDir"_s, QDir::homePath(), QgsSettings::App ).toString();
 
  QString filename = QFileDialog::getSaveFileName( this, tr( "Save Model as PDF" ), lastExportDir, tr( "PDF files (*.pdf *.PDF)" ) );
  // return dialog focus on Mac
  activateWindow();
  raise();
  if ( filename.isEmpty() )
    return;
 
  filename = QgsFileUtils::ensureFileNameHasExtension( filename, QStringList() << u"pdf"_s );
 
  const QFileInfo saveFileInfo( filename );
  settings.setValue( u"lastModelDesignerExportDir"_s, saveFileInfo.absolutePath(), QgsSettings::App );
 
  repaintModel( false );
 
  QRectF totalRect = mView->scene()->itemsBoundingRect();
  totalRect.adjust( -10, -10, 10, 10 );
  const QRectF printerRect = QRectF( 0, 0, totalRect.width(), totalRect.height() );
 
  QPdfWriter pdfWriter( filename );
 
  const double scaleFactor = 96 / 25.4; // based on 96 dpi sizes
 
  QPageLayout pageLayout( QPageSize( totalRect.size() / scaleFactor, QPageSize::Millimeter ), QPageLayout::Portrait, QMarginsF( 0, 0, 0, 0 ) );
  pageLayout.setMode( QPageLayout::FullPageMode );
  pdfWriter.setPageLayout( pageLayout );
 
  QPainter painter( &pdfWriter );
  mView->scene()->render( &painter, printerRect, totalRect );
  painter.end();
 
  mMessageBar
    ->pushMessage( QString(), tr( "Successfully exported model as PDF to <a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( filename ).toString(), QDir::toNativeSeparators( filename ) ), Qgis::MessageLevel::Success, 0 );
  repaintModel( true );
}
 
void QgsModelDesignerDialog::exportToSvg()
{
  QgsSettings settings;
  QString lastExportDir = settings.value( u"lastModelDesignerExportDir"_s, QDir::homePath(), QgsSettings::App ).toString();
 
  QString filename = QFileDialog::getSaveFileName( this, tr( "Save Model as SVG" ), lastExportDir, tr( "SVG files (*.svg *.SVG)" ) );
  // return dialog focus on Mac
  activateWindow();
  raise();
  if ( filename.isEmpty() )
    return;
 
  filename = QgsFileUtils::ensureFileNameHasExtension( filename, QStringList() << u"svg"_s );
 
  const QFileInfo saveFileInfo( filename );
  settings.setValue( u"lastModelDesignerExportDir"_s, saveFileInfo.absolutePath(), QgsSettings::App );
 
  repaintModel( false );
 
  QRectF totalRect = mView->scene()->itemsBoundingRect();
  totalRect.adjust( -10, -10, 10, 10 );
  const QRectF svgRect = QRectF( 0, 0, totalRect.width(), totalRect.height() );
 
  QSvgGenerator svg;
  svg.setFileName( filename );
  svg.setSize( QSize( totalRect.width(), totalRect.height() ) );
  svg.setViewBox( svgRect );
  svg.setTitle( mModel->displayName() );
 
  QPainter painter( &svg );
  mView->scene()->render( &painter, svgRect, totalRect );
  painter.end();
 
  mMessageBar
    ->pushMessage( QString(), tr( "Successfully exported model as SVG to <a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( filename ).toString(), QDir::toNativeSeparators( filename ) ), Qgis::MessageLevel::Success, 0 );
  repaintModel( true );
}
 
void QgsModelDesignerDialog::exportAsPython()
{
  QgsSettings settings;
  QString lastExportDir = settings.value( u"lastModelDesignerExportDir"_s, QDir::homePath(), QgsSettings::App ).toString();
 
  QString filename = QFileDialog::getSaveFileName( this, tr( "Save Model as Python Script" ), lastExportDir, tr( "Processing scripts (*.py *.PY)" ) );
  // return dialog focus on Mac
  activateWindow();
  raise();
  if ( filename.isEmpty() )
    return;
 
  filename = QgsFileUtils::ensureFileNameHasExtension( filename, QStringList() << u"py"_s );
 
  const QFileInfo saveFileInfo( filename );
  settings.setValue( u"lastModelDesignerExportDir"_s, saveFileInfo.absolutePath(), QgsSettings::App );
 
  const QString text = mModel->asPythonCode( QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass, 4 ).join( '\n' );
 
  QFile outFile( filename );
  if ( !outFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
  {
    return;
  }
  QTextStream fout( &outFile );
  fout << text;
  outFile.close();
 
  mMessageBar
    ->pushMessage( QString(), tr( "Successfully exported model as Python script to <a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( filename ).toString(), QDir::toNativeSeparators( filename ) ), Qgis::MessageLevel::Success, 0 );
}
 
void QgsModelDesignerDialog::repaintModel( bool showControls )
{
  auto scene = new QgsModelGraphicsScene( this );
  if ( !showControls )
  {
    scene->setFlag( QgsModelGraphicsScene::Flag::FlagHideControls );
  }
 
  const bool showComments = QgsSettings().value( "/Processing/Modeler/ShowComments", true ).toBool();
  if ( !showComments )
  {
    scene->setFlag( QgsModelGraphicsScene::Flag::FlagHideComments );
  }
 
  setModelScene( scene );
  scene->createItems( mModel.get(), *mContext );
  scene->updateBounds();
}
 
void QgsModelDesignerDialog::toggleComments( bool show )
{
  QgsSettings().setValue( u"/Processing/Modeler/ShowComments"_s, show );
 
  repaintModel( true );
}
 
void QgsModelDesignerDialog::toggleFeatureCount( bool show )
{
  QgsSettings().setValue( u"/Processing/Modeler/ShowFeatureCount"_s, show );
 
  repaintModel( true );
}
 
void QgsModelDesignerDialog::updateWindowTitle()
{
  QString title = tr( "Model Designer" );
  if ( !mModel->name().isEmpty() )
    title = mModel->group().isEmpty() ? u"%1: %2"_s.arg( title, mModel->name() ) : u"%1: %2 - %3"_s.arg( title, mModel->group(), mModel->name() );
 
  if ( isDirty() )
    title.prepend( '*' );
 
  setWindowTitle( title );
}
 
void QgsModelDesignerDialog::deleteSelected()
{
  QList<QgsModelComponentGraphicItem *> items = mScene->selectedComponentItems();
  if ( items.empty() )
    return;
 
  if ( items.size() == 1 )
  {
    items.at( 0 )->deleteComponent();
    return;
  }
 
  std::sort( items.begin(), items.end(), []( QgsModelComponentGraphicItem *p1, QgsModelComponentGraphicItem *p2 ) {
    // try to delete the easy stuff first, so comments, then outputs, as nothing will depend on these...
    // NOLINTBEGIN(bugprone-branch-clone)
 
    // 1. comments
    if ( dynamic_cast<QgsModelCommentGraphicItem *>( p1 ) && dynamic_cast<QgsModelCommentGraphicItem *>( p2 ) )
      return false;
    else if ( dynamic_cast<QgsModelCommentGraphicItem *>( p1 ) )
      return true;
    else if ( dynamic_cast<QgsModelCommentGraphicItem *>( p2 ) )
      return false;
    // 2. group boxes
    else if ( dynamic_cast<QgsModelGroupBoxGraphicItem *>( p1 ) && dynamic_cast<QgsModelGroupBoxGraphicItem *>( p2 ) )
      return false;
    else if ( dynamic_cast<QgsModelGroupBoxGraphicItem *>( p1 ) )
      return true;
    else if ( dynamic_cast<QgsModelGroupBoxGraphicItem *>( p2 ) )
      return false;
    // 3. outputs
    else if ( dynamic_cast<QgsModelOutputGraphicItem *>( p1 ) && dynamic_cast<QgsModelOutputGraphicItem *>( p2 ) )
      return false;
    else if ( dynamic_cast<QgsModelOutputGraphicItem *>( p1 ) )
      return true;
    else if ( dynamic_cast<QgsModelOutputGraphicItem *>( p2 ) )
      return false;
    // 4. child algorithms
    else if ( dynamic_cast<QgsModelChildAlgorithmGraphicItem *>( p1 ) && dynamic_cast<QgsModelChildAlgorithmGraphicItem *>( p2 ) )
      return false;
    else if ( dynamic_cast<QgsModelChildAlgorithmGraphicItem *>( p1 ) )
      return true;
    else if ( dynamic_cast<QgsModelChildAlgorithmGraphicItem *>( p2 ) )
      return false;
    return false;
    // NOLINTEND(bugprone-branch-clone)
  } );
 
 
  beginUndoCommand( tr( "Delete Components" ) );
 
  QVariant prevState = mModel->toVariant();
  mBlockUndoCommands++;
  mBlockRepaints = true;
  bool failed = false;
  while ( !items.empty() )
  {
    QgsModelComponentGraphicItem *toDelete = nullptr;
    for ( QgsModelComponentGraphicItem *item : items )
    {
      if ( item->canDeleteComponent() )
      {
        toDelete = item;
        break;
      }
    }
 
    if ( !toDelete )
    {
      failed = true;
      break;
    }
 
    toDelete->deleteComponent();
    items.removeAll( toDelete );
  }
 
  if ( failed )
  {
    mModel->loadVariant( prevState );
    QMessageBox::warning(
      nullptr,
      QObject::tr( "Could not remove components" ),
      QObject::tr(
        "Components depend on the selected items.\n"
        "Try to remove them before trying deleting these components."
      )
    );
    mBlockUndoCommands--;
    mActiveCommand.reset();
  }
  else
  {
    mBlockUndoCommands--;
    endUndoCommand();
  }
 
  mBlockRepaints = false;
  repaintModel();
}
 
void QgsModelDesignerDialog::populateZoomToMenu()
{
  mGroupMenu->clear();
  for ( const QgsProcessingModelGroupBox &box : model()->groupBoxes() )
  {
    if ( QgsModelComponentGraphicItem *item = mScene->groupBoxItem( box.uuid() ) )
    {
      QAction *zoomAction = new QAction( box.description(), mGroupMenu );
      connect( zoomAction, &QAction::triggered, this, [this, item] {
        QRectF groupRect = item->mapToScene( item->boundingRect() ).boundingRect();
        groupRect.adjust( -10, -10, 10, 10 );
        mView->fitInView( groupRect, Qt::KeepAspectRatio );
        mView->centerOn( item );
      } );
      mGroupMenu->addAction( zoomAction );
    }
  }
}
 
void QgsModelDesignerDialog::setPanelVisibility( bool hidden )
{
  const QList<QDockWidget *> docks = findChildren<QDockWidget *>();
  const QList<QTabBar *> tabBars = findChildren<QTabBar *>();
 
  if ( hidden )
  {
    mPanelStatus.clear();
    //record status of all docks
    for ( QDockWidget *dock : docks )
    {
      mPanelStatus.insert( dock->windowTitle(), PanelStatus( dock->isVisible(), false ) );
      dock->setVisible( false );
    }
 
    //record active dock tabs
    for ( QTabBar *tabBar : tabBars )
    {
      QString currentTabTitle = tabBar->tabText( tabBar->currentIndex() );
      mPanelStatus[currentTabTitle].isActive = true;
    }
  }
  else
  {
    //restore visibility of all docks
    for ( QDockWidget *dock : docks )
    {
      if ( mPanelStatus.contains( dock->windowTitle() ) )
      {
        dock->setVisible( mPanelStatus.value( dock->windowTitle() ).isVisible );
      }
    }
 
    //restore previously active dock tabs
    for ( QTabBar *tabBar : tabBars )
    {
      //loop through all tabs in tab bar
      for ( int i = 0; i < tabBar->count(); ++i )
      {
        QString tabTitle = tabBar->tabText( i );
        if ( mPanelStatus.contains( tabTitle ) && mPanelStatus.value( tabTitle ).isActive )
        {
          tabBar->setCurrentIndex( i );
        }
      }
    }
    mPanelStatus.clear();
  }
}
 
void QgsModelDesignerDialog::editHelp()
{
  QgsProcessingHelpEditorDialog dialog( this );
  dialog.setWindowTitle( tr( "Edit Model Help" ) );
  dialog.setAlgorithm( mModel.get() );
  if ( dialog.exec() )
  {
    beginUndoCommand( tr( "Edit Model Help" ) );
    mModel->setHelpContent( dialog.helpContent() );
    endUndoCommand();
  }
}
 
void QgsModelDesignerDialog::runSelectedSteps()
{
  QSet<QString> children;
  const QList<QgsModelComponentGraphicItem *> items = mScene->selectedComponentItems();
  for ( QgsModelComponentGraphicItem *item : items )
  {
    if ( QgsProcessingModelChildAlgorithm *childAlgorithm = dynamic_cast<QgsProcessingModelChildAlgorithm *>( item->component() ) )
    {
      children.insert( childAlgorithm->childId() );
    }
  }
 
  if ( children.isEmpty() )
  {
    mMessageBar->pushWarning( QString(), tr( "No steps are selected" ) );
    return;
  }
 
  run( children );
}
 
void QgsModelDesignerDialog::runFromChild( const QString &id )
{
  QSet<QString> children = mModel->dependentChildAlgorithms( id );
  children.insert( id );
  run( children );
}
 
void QgsModelDesignerDialog::cancelRunningModel()
{
  if ( !mAlgorithmWidget )
    return;
 
  // these checks are wrong - mAlgorithmWidget is a QPointer, and we explicitly want to check
  // if it gets deleted in the cancel/forceClose dance!
  // cppcheck-suppress nullPointerRedundantCheck
  mAlgorithmWidget->cancel();
  // cppcheck-suppress nullPointerRedundantCheck
  mAlgorithmWidget->forceClose();
 
  //Stop tracking change to the previous dialog in the QPointer
  if ( mAlgorithmWidget )
  {
    // this is a work around for the MESSY ownership issues associated with the python subclass
    // of QgsProcessingAlgorithmWidget. We have to FORCE all widgets to be deleted prior
    // to destruction of this window, and we can't be sure that python will have actually
    // deleted the widget when we asked...
    mAlgorithmWidgetsToCleanUp << mAlgorithmWidget;
  }
  mAlgorithmWidget.clear();
}
 
void QgsModelDesignerDialog::run( const QSet<QString> &childAlgorithmSubset )
{
  QStringList errors;
  const bool isValid = model()->validate( errors );
  if ( !isValid )
  {
    QMessageBox messageBox;
    messageBox.setWindowTitle( tr( "Model is Invalid" ) );
    messageBox.setIcon( QMessageBox::Icon::Warning );
    messageBox.setText( tr( "This model is not valid and contains one or more issues. Are you sure you want to run it in this state?" ) );
    messageBox.setStandardButtons( QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::Cancel );
    messageBox.setDefaultButton( QMessageBox::StandardButton::Cancel );
 
    QString errorString;
    for ( const QString &error : std::as_const( errors ) )
    {
      QString cleanedError = error;
      const thread_local QRegularExpression re( u"<[^>]*>"_s );
      cleanedError.replace( re, QString() );
      errorString += u"• %1\n"_s.arg( cleanedError );
    }
 
    messageBox.setDetailedText( errorString );
    if ( messageBox.exec() == QMessageBox::StandardButton::Cancel )
      return;
  }
 
  if ( !childAlgorithmSubset.isEmpty() )
  {
    for ( const QString &child : childAlgorithmSubset )
    {
      // has user previously run all requirements for this step?
      const QSet<QString> requirements = mModel->dependsOnChildAlgorithms( child );
      for ( const QString &requirement : requirements )
      {
        if ( !mLastResult.executedChildIds().contains( requirement ) )
        {
          QMessageBox messageBox;
          messageBox.setWindowTitle( tr( "Run Model" ) );
          messageBox.setIcon( QMessageBox::Icon::Warning );
          messageBox.setText( tr( "Prerequisite parts of this model have not yet been run (try running the full model first)." ) );
          messageBox.setStandardButtons( QMessageBox::StandardButton::Ok );
          messageBox.exec();
          return;
        }
      }
    }
  }
 
  if ( mAlgorithmWidget && mAlgorithmWidget->isRunning() )
  {
    QMessageBox messageBox;
    messageBox.setIcon( QMessageBox::Icon::Warning );
    messageBox.setWindowTitle( tr( "Run Model" ) );
    messageBox.setText( tr( "This model is already running." ) );
    messageBox.setStandardButtons( QMessageBox::StandardButton::Cancel | QMessageBox::StandardButton::RestoreDefaults | QMessageBox::StandardButton::Ok );
 
    QAbstractButton *buttonShowRunningAlg = messageBox.button( QMessageBox::StandardButton::Ok );
    buttonShowRunningAlg->setText( tr( "Show Progress" ) );
 
    QAbstractButton *buttonReRun = messageBox.button( QMessageBox::StandardButton::RestoreDefaults );
    buttonReRun->setText( tr( "Cancel and Restart Model" ) );
 
    int r = messageBox.exec();
 
    switch ( r )
    {
      case QMessageBox::StandardButton::Cancel:
        return;
      case QMessageBox::StandardButton::RestoreDefaults:
        cancelRunningModel();
        break;
      case QMessageBox::StandardButton::Ok:
        mAlgorithmWidget->showWidget();
        return;
      default:
        break;
    }
  }
  else if ( mAlgorithmWidget )
  {
    // Close and create a new one
    mAlgorithmWidget->close();
    if ( mAlgorithmWidget )
    {
      // this is a work around for the MESSY ownership issues associated with the python subclass
      // of QgsProcessingAlgorithmWidget. We have to FORCE all widgets to be deleted prior
      // to destruction of this window, and we can't be sure that python will have actually
      // deleted the widget when we asked...
      mAlgorithmWidgetsToCleanUp << mAlgorithmWidget;
    }
    //Stop tracking change to the previous widget in the QPointer
    mAlgorithmWidget.clear();
  }
 
  if ( !mAlgorithmWidget )
  {
    mAlgorithmWidget = createExecutionWidget();
    if ( !mAlgorithmWidget )
      return; // should not happen
 
    mAlgorithmWidget->hideShortHelp();
    mAlgorithmWidget->setTitle( tr( "Run Model" ) );
 
    mAlgorithmWidget->setLogLevel( Qgis::ProcessingLogLevel::ModelDebug );
    mAlgorithmWidget->setParameters( mModel->designerParameterValues() );
 
    if ( !childAlgorithmSubset.isEmpty() )
    {
      mAlgorithmWidget->runButton()->setText( tr( "Run Subset" ) );
      mAlgorithmWidget->runButton()->setToolTip( tr( "Runs a subset of the child algorithms from this model" ) );
    }
 
    connect( mAlgorithmWidget.get(), &QgsProcessingAlgorithmWidgetBase::algorithmAboutToRun, this, [this, childAlgorithmSubset]( QgsProcessingContext *context ) {
      if ( !childAlgorithmSubset.empty() )
      {
        // start from previous state
        auto modelConfig = std::make_unique<QgsProcessingModelInitialRunConfig>();
        modelConfig->setChildAlgorithmSubset( childAlgorithmSubset );
        modelConfig->setPreviouslyExecutedChildAlgorithms( mLastResult.executedChildIds() );
        modelConfig->setInitialChildInputs( mLastResult.rawChildInputs() );
        modelConfig->setInitialChildOutputs( mLastResult.rawChildOutputs() );
 
        // add copies of layers from previous runs to context's layer store, so that they can be used
        // when running the subset
        const QMap<QString, QgsMapLayer *> previousOutputLayers = mLayerStore.temporaryLayerStore()->mapLayers();
        auto previousResultStore = std::make_unique<QgsMapLayerStore>();
        for ( auto it = previousOutputLayers.constBegin(); it != previousOutputLayers.constEnd(); ++it )
        {
          std::unique_ptr<QgsMapLayer> clone( it.value()->clone() );
          clone->setId( it.value()->id() );
          previousResultStore->addMapLayer( clone.release() );
        }
        previousResultStore->moveToThread( nullptr );
        modelConfig->setPreviousLayerStore( std::move( previousResultStore ) );
        context->setModelInitialRunConfig( std::move( modelConfig ) );
 
        mScene->resetChildAlgorithmItems( childAlgorithmSubset );
 
        // for all algorithms downstream of the subset which won't be re-run, flag their old results as outdated.
        for ( const QString &child : childAlgorithmSubset )
        {
          const QSet< QString > outdated = mModel->dependentChildAlgorithms( child );
          mScene->flagChildrenAsOutdated( outdated );
          mOutdatedChildResults.unite( outdated );
        }
      }
      else
      {
        // reset all child algorithm results
        mScene->resetChildAlgorithmItems();
      }
    } );
 
    connect( mAlgorithmWidget, &QgsProcessingAlgorithmWidgetBase::algorithmFinished, this, [this]( bool, const QVariantMap & ) {
      QgsProcessingContext *context = mAlgorithmWidget->processingContext();
      // take child output layers
      mLayerStore.temporaryLayerStore()->removeAllMapLayers();
      mLayerStore.takeResultsFrom( *context );
 
      mModel->setDesignerParameterValues( mAlgorithmWidget->createProcessingParameters( QgsProcessingParametersGenerator::Flag::SkipDefaultValueParameters ) );
      setLastRunResult( context->modelResult() );
    } );
  }
}
 
void QgsModelDesignerDialog::showChildAlgorithmOutputs( const QString &childId )
{
  const bool isOutdated = mOutdatedChildResults.contains( childId );
  const QString childDescription = mModel->childAlgorithm( childId ).description();
 
  const QgsProcessingModelChildAlgorithmResult result = mLastResult.childResults().value( childId );
  const QVariantMap childAlgorithmOutputs = result.outputs();
  if ( childAlgorithmOutputs.isEmpty() )
  {
    mMessageBar->pushWarning( QString(), tr( "No results are available for %1" ).arg( childDescription ) );
    return;
  }
 
  const QgsProcessingAlgorithm *algorithm = mModel->childAlgorithm( childId ).algorithm();
  if ( !algorithm )
  {
    mMessageBar->pushCritical( QString(), tr( "Results cannot be shown for an invalid model component" ) );
    return;
  }
 
  const QList<const QgsProcessingParameterDefinition *> outputParams = algorithm->destinationParameterDefinitions();
  if ( outputParams.isEmpty() )
  {
    // this situation should not arise in normal use, we don't show the action in this case
    QgsDebugError( "Cannot show results for algorithms with no outputs" );
    return;
  }
 
  bool foundResults = false;
  for ( const QgsProcessingParameterDefinition *outputParam : outputParams )
  {
    const QVariant output = childAlgorithmOutputs.value( outputParam->name() );
    if ( !output.isValid() )
      continue;
 
    if ( output.type() == QVariant::String )
    {
      if ( QgsMapLayer *resultLayer = QgsProcessingUtils::mapLayerFromString( output.toString(), mLayerStore ) )
      {
        QgsDebugMsgLevel( u"Loading previous result for %1: %2"_s.arg( outputParam->name(), output.toString() ), 2 );
 
        std::unique_ptr<QgsMapLayer> layer( resultLayer->clone() );
 
        QString baseName;
        if ( outputParams.size() > 1 )
          baseName = tr( "%1 — %2" ).arg( childDescription, outputParam->name() );
        else
          baseName = childDescription;
 
        // make name unique, so that's it's easy to see which is the most recent result.
        // (this helps when running the model multiple times.)
        QString name = baseName;
        int counter = 1;
        while ( !QgsProject::instance()->mapLayersByName( name ).empty() )
        {
          counter += 1;
          name = tr( "%1 (%2)" ).arg( baseName ).arg( counter );
        }
 
        layer->setName( name );
 
        QgsProject::instance()->addMapLayer( layer.release() );
        foundResults = true;
      }
      else
      {
        // should not happen in normal operation
        QgsDebugError( u"Could not load previous result for %1: %2"_s.arg( outputParam->name(), output.toString() ) );
      }
    }
  }
 
  if ( !foundResults )
  {
    mMessageBar->pushWarning( QString(), tr( "No results are available for %1" ).arg( childDescription ) );
    return;
  }
  else if ( isOutdated )
  {
    mMessageBar->pushWarning( QString(), tr( "These results are outdated, and may not reflect the most recent model execution" ) );
    return;
  }
}
 
void QgsModelDesignerDialog::showChildAlgorithmLog( const QString &childId )
{
  const QString childDescription = mModel->childAlgorithm( childId ).description();
 
  QgsProcessingModelChildAlgorithmResult result;
  // prefer to fetch the log from the item itself -- if we are currently mid-way through
  // running the model, it will have the LATEST log available
  if ( QgsModelChildAlgorithmGraphicItem *item = mScene->childAlgorithmItem( childId ) )
  {
    result = item->results();
  }
  if ( result.htmlLog().isEmpty() )
  {
    result = mLastResult.childResults().value( childId );
  }
 
  if ( result.htmlLog().isEmpty() )
  {
    mMessageBar->pushWarning( QString(), tr( "No log is available for %1" ).arg( childDescription ) );
    return;
  }
 
  QgsMessageViewer m( this, QgsGuiUtils::ModalDialogFlags, false );
  m.setWindowTitle( childDescription );
  m.setCheckBoxVisible( false );
  m.setMessageAsHtml( result.htmlLog() );
  m.exec();
}
 
void QgsModelDesignerDialog::onItemFocused( QgsModelComponentGraphicItem *item )
{
  QgsProcessingParameterWidgetContext widgetContext = createWidgetContext();
  widgetContext.registerProcessingContextGenerator( this );
  widgetContext.setModelDesignerDialog( this );
 
  if ( !item || !item->component() )
  {
    mConfigWidget->showComponentConfig( nullptr, *mContext, widgetContext );
  }
  else
  {
    mConfigWidget->showComponentConfig( item->component(), *mContext, widgetContext );
 
    if ( auto childAlgorithmItem = qobject_cast< QgsModelChildAlgorithmGraphicItem * >( item ) )
    {
      connect( childAlgorithmItem, &QgsModelChildAlgorithmGraphicItem::rebuildConfigurationDockWidget, childAlgorithmItem, [this] {
        QgsProcessingParameterWidgetContext widgetContext = createWidgetContext();
        widgetContext.registerProcessingContextGenerator( this );
        widgetContext.setModelDesignerDialog( this );
        mConfigWidget->showComponentConfig( nullptr, *mContext, widgetContext );
      } );
    }
  }
}
 
void QgsModelDesignerDialog::validate()
{
  QStringList issues;
  if ( model()->validate( issues ) )
  {
    mMessageBar->pushSuccess( QString(), tr( "Model is valid!" ) );
  }
  else
  {
    QgsMessageBarItem *messageWidget = QgsMessageBar::createMessage( QString(), tr( "Model is invalid!" ) );
    QPushButton *detailsButton = new QPushButton( tr( "Details" ) );
    connect( detailsButton, &QPushButton::clicked, detailsButton, [detailsButton, issues] {
      QgsMessageViewer *dialog = new QgsMessageViewer( detailsButton );
      dialog->setTitle( tr( "Model is Invalid" ) );
 
      QString longMessage = tr( "<p>This model is not valid:</p>" ) + u"<ul>"_s;
      for ( const QString &issue : issues )
      {
        longMessage += u"<li>%1</li>"_s.arg( issue );
      }
      longMessage += "</ul>"_L1;
 
      dialog->setMessage( longMessage, Qgis::StringFormat::Html );
      dialog->showMessage();
    } );
    messageWidget->layout()->addWidget( detailsButton );
    mMessageBar->clearWidgets();
    mMessageBar->pushWidget( messageWidget, Qgis::MessageLevel::Warning, 0 );
  }
}
 
void QgsModelDesignerDialog::reorderInputs()
{
  QgsModelInputReorderDialog dlg( this );
  dlg.setModel( mModel.get() );
  if ( dlg.exec() )
  {
    const QStringList inputOrder = dlg.inputOrder();
    beginUndoCommand( tr( "Reorder Inputs" ) );
    mModel->setParameterOrder( inputOrder );
    endUndoCommand();
  }
}
 
void QgsModelDesignerDialog::reorderOutputs()
{
  QgsModelOutputReorderDialog dlg( this );
  dlg.setModel( mModel.get() );
  if ( dlg.exec() )
  {
    const QStringList outputOrder = dlg.outputOrder();
    beginUndoCommand( tr( "Reorder Outputs" ) );
    mModel->setOutputOrder( outputOrder );
    mModel->setOutputGroup( dlg.outputGroup() );
    endUndoCommand();
  }
}
 
bool QgsModelDesignerDialog::isDirty() const
{
  return mHasChanged && mUndoStack->index() != -1;
}
 
void QgsModelDesignerDialog::fillInputsTree()
{
  const QIcon icon = QgsApplication::getThemeIcon( u"mIconModelInput.svg"_s );
  auto parametersItem = std::make_unique<QTreeWidgetItem>();
  parametersItem->setText( 0, tr( "Parameters" ) );
  QList<QgsProcessingParameterType *> available = QgsApplication::processingRegistry()->parameterTypes();
  std::sort( available.begin(), available.end(), []( const QgsProcessingParameterType *a, const QgsProcessingParameterType *b ) -> bool {
    return QString::localeAwareCompare( a->name(), b->name() ) < 0;
  } );
 
  for ( QgsProcessingParameterType *param : std::as_const( available ) )
  {
    if ( param->flags() & Qgis::ProcessingParameterTypeFlag::ExposeToModeler )
    {
      auto paramItem = std::make_unique<QTreeWidgetItem>();
      paramItem->setText( 0, param->name() );
      paramItem->setData( 0, Qt::UserRole, param->id() );
      paramItem->setIcon( 0, icon );
      paramItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled );
      paramItem->setToolTip( 0, param->description() );
      parametersItem->addChild( paramItem.release() );
    }
  }
  mInputsTreeWidget->addTopLevelItem( parametersItem.release() );
  mInputsTreeWidget->topLevelItem( 0 )->setExpanded( true );
}
 
 
//
// QgsModelChildDependenciesWidget
//
 
QgsModelChildDependenciesWidget::QgsModelChildDependenciesWidget( QWidget *parent, QgsProcessingModelAlgorithm *model, const QString &childId )
  : QWidget( parent )
  , mModel( model )
  , mChildId( childId )
{
  QHBoxLayout *hl = new QHBoxLayout();
  hl->setContentsMargins( 0, 0, 0, 0 );
 
  mLineEdit = new QLineEdit();
  mLineEdit->setEnabled( false );
  hl->addWidget( mLineEdit, 1 );
 
  mToolButton = new QToolButton();
  mToolButton->setText( QString( QChar( 0x2026 ) ) );
  hl->addWidget( mToolButton );
 
  setLayout( hl );
 
  mLineEdit->setText( tr( "%1 dependencies selected" ).arg( 0 ) );
 
  connect( mToolButton, &QToolButton::clicked, this, &QgsModelChildDependenciesWidget::showDialog );
}
 
void QgsModelChildDependenciesWidget::setValue( const QList<QgsProcessingModelChildDependency> &value )
{
  const bool hasChanged = value != mValue;
  mValue = value;
 
  updateSummaryText();
  if ( hasChanged )
  {
    emit changed();
  }
}
 
void QgsModelChildDependenciesWidget::showDialog()
{
  const QList<QgsProcessingModelChildDependency> available = mModel->availableDependenciesForChildAlgorithm( mChildId );
 
  QVariantList availableOptions;
  for ( const QgsProcessingModelChildDependency &dep : available )
    availableOptions << QVariant::fromValue( dep );
  QVariantList selectedOptions;
  for ( const QgsProcessingModelChildDependency &dep : mValue )
    selectedOptions << QVariant::fromValue( dep );
 
  QgsPanelWidget *panel = QgsPanelWidget::findParentPanel( this );
  if ( panel )
  {
    QgsProcessingMultipleSelectionPanelWidget *widget = new QgsProcessingMultipleSelectionPanelWidget( availableOptions, selectedOptions );
    widget->setPanelTitle( tr( "Algorithm Dependencies" ) );
 
    widget->setValueFormatter( [this]( const QVariant &v ) -> QString {
      const QgsProcessingModelChildDependency dep = v.value<QgsProcessingModelChildDependency>();
 
      const QString description = mModel->childAlgorithm( dep.childId ).description();
      if ( dep.conditionalBranch.isEmpty() )
        return description;
      else
        return tr( "Condition “%1” from algorithm “%2”" ).arg( dep.conditionalBranch, description );
    } );
 
    connect( widget, &QgsProcessingMultipleSelectionPanelWidget::selectionChanged, this, [this, widget]() {
      QList<QgsProcessingModelChildDependency> res;
      for ( const QVariant &v : widget->selectedOptions() )
      {
        res << v.value<QgsProcessingModelChildDependency>();
      }
      setValue( res );
    } );
    connect( widget, &QgsProcessingMultipleSelectionPanelWidget::acceptClicked, widget, &QgsPanelWidget::acceptPanel );
    panel->openPanel( widget );
  }
}
 
void QgsModelChildDependenciesWidget::updateSummaryText()
{
  mLineEdit->setText( tr( "%n dependencies selected", nullptr, mValue.count() ) );
}