qgsmodeldesignerdialog.h

Go to the documentation of this file.

/***************************************************************************
                             qgsmodeldesignerdialog.h
                             ------------------------
    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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSMODELDESIGNERDIALOG_H
#define QGSMODELDESIGNERDIALOG_H
 
#include "ui_qgsmodeldesignerdialogbase.h"
 
#include "qgis.h"
#include "qgis_gui.h"
#include "qgsmodelundocommand.h"
#include "qgsprocessingalgorithmwidgetbase.h"
#include "qgsprocessingmodelchilddependency.h"
#include "qgsprocessingtoolboxmodel.h"
#include "qobjectuniqueptr.h"
 
class QgsMessageBar;
class QgsProcessingModelAlgorithm;
class QgsModelUndoCommand;
class QUndoView;
class QgsModelViewToolPan;
class QgsModelViewToolSelect;
class QgsScreenHelper;
class QgsProcessingAlgorithmWidgetBase;
class QgsModelDesignerConfigDockWidget;
class QgsProcessingParameterWidgetContext;
class QgsProcessingContextGenerator;

 
#ifndef SIP_RUN
 
class GUI_EXPORT QgsModelerToolboxModel : public QgsProcessingToolboxProxyModel
{
    Q_OBJECT
  public:
    explicit QgsModelerToolboxModel( QObject *parent = nullptr );
    Qt::ItemFlags flags( const QModelIndex &index ) const override;
    Qt::DropActions supportedDragActions() const override;
};
 
#endif

class GUI_EXPORT QgsModelDesignerDialog : public QMainWindow,
                                          public QgsProcessingFeedbackGenerator,
                                          public QgsProcessingContextGenerator,
                                          public QgsProcessingWidgetContextGenerator,
                                          public Ui::QgsModelDesignerDialogBase
{
    Q_OBJECT
  public:
    QgsModelDesignerDialog( QWidget *parent SIP_TRANSFERTHIS = nullptr, Qt::WindowFlags flags = Qt::WindowFlags() );
    ~QgsModelDesignerDialog() override;
 
    void closeEvent( QCloseEvent *event ) override;

    QgsProcessingModelAlgorithm *model();

    void setModel( QgsProcessingModelAlgorithm *model SIP_TRANSFER );

    void loadModel( const QString &path );
 
#ifndef SIP_RUN
    void setModelScene( QgsModelGraphicsScene *scene SIP_TRANSFER );

    QgsModelGraphicsScene *modelScene();
#endif
 
    QgsProcessingFeedback *createFeedback() override SIP_FACTORY;
    QgsProcessingParameterWidgetContext createWidgetContext() override;
 
  public slots:

    void activate();

    void saveInProject();
 
  signals:

    void modelUpdated();
 
  protected:
    QgsProcessingContext *processingContext() const override;
 
  private slots:
    void zoomIn();
    void zoomOut();
    void zoomActual();
    void zoomFull();
    void newModel();
    void openModel();
    void exportToImage();
    void exportToPdf();
    void exportToSvg();
    void exportAsPython();
    void toggleComments( bool show );
    void toggleFeatureCount( bool show );
    void updateWindowTitle();
    void deleteSelected();
    void populateZoomToMenu();
    void validate();
    void reorderInputs();
    void reorderOutputs();
    void setPanelVisibility( bool hidden );
    void editHelp();
    void runSelectedSteps();
    void runFromChild( const QString &id );
    void run( const QSet<QString> &childAlgorithmSubset = QSet<QString>() );
    void showChildAlgorithmOutputs( const QString &childId );
    void showChildAlgorithmLog( const QString &childId );
    void onItemFocused( QgsModelComponentGraphicItem *item );
 
    void cancelRunningModel();
 
  private:
    enum class SaveAction
    {
      SaveAsFile,    
      SaveInProject, 
    };

    void beginUndoCommand( const QString &text, const QString &id = QString(), QgsModelUndoCommand::CommandOperation operation = QgsModelUndoCommand::CommandOperation::Unknown );

    void endUndoCommand();

    void abortUndoCommand();
 
    void repaintModel( bool showControls = true );
 
    void setDirty( bool dirty );

    bool validateSave( SaveAction action );

    bool checkForUnsavedChanges();

    void setLastRunResult( const QgsProcessingModelResult &result );

    void setModelName( const QString &name );
 
    bool saveModel( bool saveAs = false );
 
    QPointF getPositionForParameterItem() const;
    QPointF getPositionForAlgorithmItem() const;

    void autoGenerateParameterName( QgsProcessingParameterDefinition *parameter ) const;
 
    void addAlgorithm( const QString &algorithmId, const QPointF &pos );
    void addInput( const QString &parameterType, const QPointF &pos );
 
    QgsProcessingAlgorithmWidget *createExecutionWidget();
 
    void exportAsScriptAlgorithm();
 
    std::unique_ptr< QgsProcessingContext > mContext;
 
    std::unique_ptr<QgsProcessingModelAlgorithm> mModel;
 
    QgsScreenHelper *mScreenHelper = nullptr;
 
    QgsMessageBar *mMessageBar = nullptr;
    QgsModelerToolboxModel *mAlgorithmsModel = nullptr;
 
    QPointer<QgsProcessingAlgorithmWidget> mAlgorithmWidget;
 
    QVector<QPointer<QgsProcessingAlgorithmWidget>> mAlgorithmWidgetsToCleanUp;
 
    QActionGroup *mToolsActionGroup = nullptr;
 
    QgsModelViewToolPan *mPanTool = nullptr;
    QObjectUniquePtr<QgsModelViewToolSelect> mSelectTool;
    QgsModelGraphicsScene *mScene = nullptr;
 
    bool mHasChanged = false;
    QUndoStack *mUndoStack = nullptr;
    std::unique_ptr<QgsModelUndoCommand> mActiveCommand;
 
    QAction *mUndoAction = nullptr;
    QAction *mRedoAction = nullptr;
    QUndoView *mUndoView = nullptr;
    QgsDockWidget *mUndoDock = nullptr;
 
    QMenu *mGroupMenu = nullptr;
 
    QAction *mActionCut = nullptr;
    QAction *mActionCopy = nullptr;
    QAction *mActionPaste = nullptr;
    int mBlockUndoCommands = 0;
    int mIgnoreUndoStackChanges = 0;
 
    QgsDockWidget *mConfigWidgetDock = nullptr;
    QgsModelDesignerConfigDockWidget *mConfigWidget = nullptr;
 
    QString mTitle;
 
    int mBlockRepaints = 0;
 
    QgsProcessingModelResult mLastResult;
    QSet< QString > mOutdatedChildResults;
 
    bool isDirty() const;
 
    void fillInputsTree();
    void updateVariablesGui();
 
    struct PanelStatus
    {
        PanelStatus( bool visible = true, bool active = false )
          : isVisible( visible )
          , isActive( active )
        {}
        bool isVisible;
        bool isActive;
    };
    QMap<QString, PanelStatus> mPanelStatus;
 
    QgsProcessingContext mLayerStore;
};
 
#ifndef SIP_RUN
 
class GUI_EXPORT QgsModelChildDependenciesWidget : public QWidget
{
    Q_OBJECT
 
  public:
    QgsModelChildDependenciesWidget( QWidget *parent, QgsProcessingModelAlgorithm *model, const QString &childId );
    QList<QgsProcessingModelChildDependency> value() const { return mValue; }
    void setValue( const QList<QgsProcessingModelChildDependency> &value );
 
  signals:

    void changed();
 
  private slots:
 
    void showDialog();
 
  private:
    void updateSummaryText();
 
    QLineEdit *mLineEdit = nullptr;
    QToolButton *mToolButton = nullptr;
 
    QgsProcessingModelAlgorithm *mModel = nullptr;
    QString mChildId;
 
    QList<QgsProcessingModelChildDependency> mValue;
 
    friend class TestProcessingGui;
};
#endif
 
#endif // QGSMODELDESIGNERDIALOG_H