qgsprocessingalgorithmwidgetbase.h

Go to the documentation of this file.

/***************************************************************************
                             qgsprocessingalgorithmwidgetbase.h
                             ----------------------------------
    Date                 : November 2017
    Copyright            : (C) 2017 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 QGSPROCESSINGALGORITHMWIDGETBASE_H
#define QGSPROCESSINGALGORITHMWIDGETBASE_H
 
#include "ui_qgsprocessingalgorithmdialogbase.h"
#include "ui_qgsprocessingalgorithmprogressdialogbase.h"
#include "ui_qgsprocessingcontextoptionsbase.h"
 
#include "qgis.h"
#include "qgis_gui.h"
#include "qgsprocessingcontext.h"
#include "qgsprocessingfeedback.h"
#include "qgsprocessingwidgetwrapper.h"
 
#include <QThread>

 
class QgsProcessingAlgorithm;
class QToolButton;
class QgsProcessingContextOptionsWidget;
class QgsMessageBar;
class QgsProcessingAlgRunnerTask;
class QgsTask;
class QgsDockableWidgetHelper;
class QMainWindow;
class QgsProcessingParametersWidget;

class GUI_EXPORT QgsProcessingFeedbackGenerator
{
  public:
    virtual ~QgsProcessingFeedbackGenerator();

    virtual QgsProcessingFeedback *createFeedback() = 0 SIP_FACTORY;
};
 

class GUI_EXPORT QgsProcessingAlgorithmWidgetBase : public QWidget, public QgsProcessingParametersGenerator, public QgsProcessingContextGenerator, private Ui::QgsProcessingDialogBase
{
    Q_OBJECT
 
  public:
    enum class LogFormat : int
    {
      FormatPlainText, 
      FormatHtml,      
    };
    Q_ENUM( QgsProcessingAlgorithmWidgetBase::LogFormat )
 
    
    enum class WidgetMode : int
    {
      Single, 
      Batch,  
    };
    Q_ENUM( QgsProcessingAlgorithmWidgetBase::WidgetMode )
 
    
    enum class WidgetFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoDocking = 1 << 0 
    };
    Q_ENUM( WidgetFlag )
 
    
    Q_DECLARE_FLAGS( WidgetFlags, WidgetFlag )
    Q_FLAG( WidgetFlags )
 
    
    QgsProcessingAlgorithmWidgetBase(
      QMainWindow *parentWindow SIP_TRANSFERTHIS,
      QgsProcessingAlgorithmWidgetBase::WidgetMode mode = QgsProcessingAlgorithmWidgetBase::WidgetMode::Single,
      QgsProcessingAlgorithmWidgetBase::WidgetFlags flags = QgsProcessingAlgorithmWidgetBase::WidgetFlags(),
      Qgis::DockableWidgetInitialState initialState = Qgis::DockableWidgetInitialState::RestorePreviousState
    );
    ~QgsProcessingAlgorithmWidgetBase() override;

    void setAlgorithm( QgsProcessingAlgorithm *algorithm SIP_TRANSFER );

    QgsProcessingAlgorithm *algorithm();

    void setMainWidget( QgsPanelWidget *widget SIP_TRANSFER );

    QgsPanelWidget *mainWidget();

    void showWidget();

    void showLog();

    bool wasExecuted() const { return mExecuted; }

    QVariantMap results() const { return mResults; }

    void registerProcessingFeedbackGenerator( QgsProcessingFeedbackGenerator *generator );

    QgsProcessingFeedback *createFeedback() SIP_FACTORY;

    void saveLogToFile( const QString &path, QgsProcessingAlgorithmWidgetBase::LogFormat format = QgsProcessingAlgorithmWidgetBase::LogFormat::FormatPlainText );

    Qgis::ProcessingLogLevel logLevel() const;

    void setLogLevel( Qgis::ProcessingLogLevel level );

    virtual void setParameters( const QVariantMap &values );

    void setTitle( const QString &title );
 
  public slots:

    void exec();

    void reportError( const QString &error, bool fatalError );

    void pushWarning( const QString &warning );

    void pushInfo( const QString &info );

    void pushFormattedMessage( const QString &html );

    void pushDebugInfo( const QString &message );

    void pushCommandInfo( const QString &info );

    void setPercentage( double percent );

    void setProgressText( const QString &text );

    void pushConsoleInfo( const QString &info );

    QDialog *createProgressDialog();

    void clearLog();

    void saveLog();

    void copyLogToClipboard();

    void showParameters();

    virtual bool isRunning();

    void cancel();

    void forceClose();
 
    void reject();

    void hideShortHelp();

    QgsMessageBar *messageBar();

    QPushButton *runButton();
 
  protected:
    void closeEvent( QCloseEvent *e ) override;

    QPushButton *cancelButton();

    QPushButton *changeParametersButton();

    QDialogButtonBox *buttonBox();

    QTabWidget *tabWidget();

    void clearProgress();

    void setExecuted( bool executed );

    void setExecutedAnyResult( bool executedAnyResult );

    void setResults( const QVariantMap &results );

    void setInfo( const QString &message, bool isError = false, bool escapeHtml = true, bool isWarning = false );

    void resetGui();

    virtual void resetAdditionalGui();

    void updateRunButtonVisibility();

    void blockControlsWhileRunning();

    virtual void blockAdditionalControlsWhileRunning();

    void setCurrentTask( QgsProcessingAlgRunnerTask *task SIP_TRANSFER );

    static QString formatStringForLog( const QString &string );

    virtual bool isFinalized();

    void applyContextOverrides( QgsProcessingContext *context );
 
  signals:

    void algorithmAboutToRun( QgsProcessingContext *context );

    void algorithmFinished( bool successful, const QVariantMap &result );

    SIP_SKIP void cancelRequested();
 
  protected slots:

    virtual void finished( bool successful, const QVariantMap &result, QgsProcessingContext &context, QgsProcessingFeedback *feedback );

    virtual void runAlgorithm();

    virtual void algExecuted( bool successful, const QVariantMap &results );
 
  private slots:
 
    void openHelp();
    void toggleCollapsed();
 
    void splitterChanged( int pos, int index );
    void mTabWidget_currentChanged( int index );
    void linkClicked( const QUrl &url );
    void taskTriggered( QgsTask *task );
    void closeClicked();
    void urlClicked( const QUrl &url );
 
  private:
    void disconnectCurrentTask();
 
    QgsDockableWidgetHelper *mDockableWidgetHelper = nullptr;
 
    WidgetMode mMode = WidgetMode::Single;
 
    QPushButton *mButtonRun = nullptr;
    QPushButton *mButtonClose = nullptr;
    QPushButton *mButtonChangeParameters = nullptr;
    QByteArray mSplitterState;
    QToolButton *mButtonCollapse = nullptr;
    QgsMessageBar *mMessageBar = nullptr;
    QPushButton *mAdvancedButton = nullptr;
    QMenu *mAdvancedMenu = nullptr;
    QAction *mCopyAsQgisProcessCommand = nullptr;
    QAction *mPasteJsonAction = nullptr;
    QAction *mContextSettingsAction = nullptr;
 
    bool mExecuted = false;
    bool mExecutedAnyResult = false;
    QVariantMap mResults;
    QgsPanelWidget *mMainWidget = nullptr;
    QgsProcessingFeedbackGenerator *mFeedbackFactory = nullptr;
    std::unique_ptr<QgsProcessingAlgorithm> mAlgorithm;
    QgsProcessingAlgRunnerTask *mAlgorithmTask = nullptr;
 
    bool mHelpCollapsed = false;
 
    int mMessageLoggedCount = 0;
 
    Qgis::ProcessingLogLevel mLogLevel = Qgis::ProcessingLogLevel::DefaultLevel;
 
    QPointer<QgsProcessingContextOptionsWidget> mContextOptionsWidget;
    bool mOverrideDefaultContextSettings = false;
    Qgis::InvalidGeometryCheck mGeometryCheck = Qgis::InvalidGeometryCheck::AbortOnInvalid;
    Qgis::DistanceUnit mDistanceUnits = Qgis::DistanceUnit::Unknown;
    Qgis::AreaUnit mAreaUnits = Qgis::AreaUnit::Unknown;
    QString mTemporaryFolderOverride;
    int mMaximumThreads = QThread::idealThreadCount();
 
    QString formatHelp( QgsProcessingAlgorithm *algorithm );
    void scrollToBottomOfLog();
    void processEvents();
};

class GUI_EXPORT QgsProcessingAlgorithmWidget : public QgsProcessingAlgorithmWidgetBase
{
    Q_OBJECT
 
  public:
    QgsProcessingAlgorithmWidget(
      QgsProcessingAlgorithm *algorithm SIP_TRANSFER,
      bool inPlace = false,
      QMainWindow *parentWindow SIP_TRANSFERTHIS = nullptr,
      QgsProcessingAlgorithmWidgetBase::WidgetFlags flags = QgsProcessingAlgorithmWidgetBase::WidgetFlags(),
      Qgis::DockableWidgetInitialState initialState = Qgis::DockableWidgetInitialState::RestorePreviousState
    );

    bool inPlace() const;
 
    void setParameters( const QVariantMap &values ) override;
    QVariantMap createProcessingParameters( QgsProcessingParametersGenerator::Flags flags = QgsProcessingParametersGenerator::Flags() ) override;
    QgsProcessingContext *processingContext() const override;
 
  protected:
    virtual QgsProcessingParametersWidget *createParametersPanel( bool inPlaceMode, QgsVectorLayer *activeLayer, QgsMessageBar *messageBar );

    QgsProcessingParametersWidget *parametersWidget();

    bool handleValidationResults( const QList< QgsProcessingParametersGenerator::ParameterValidationResult > &results );
 
  private:
    void flagInvalidParameterValue( const QString &message, QWidget *widget );

    void flagInvalidOutputExtension( const QString &message, QWidget *widget );
 
    mutable std::unique_ptr< QgsProcessingContext > mContext;
    mutable std::unique_ptr< QgsProcessingFeedback > mFeedback;
 
    bool mInPlace = false;
    QList< QWidget * > mWidgetsToResetPalette;
};
 
#ifndef SIP_RUN

class QgsProcessingAlgorithmProgressDialog : public QDialog, private Ui::QgsProcessingProgressDialogBase
{
    Q_OBJECT
 
  public:
    QgsProcessingAlgorithmProgressDialog( QWidget *parent = nullptr );

    QProgressBar *progressBar();

    QPushButton *cancelButton();

    QTextEdit *logTextEdit();
 
  public slots:
 
    void reject() override;
};

class GUI_EXPORT QgsProcessingContextOptionsWidget : public QgsPanelWidget, private Ui::QgsProcessingContextOptionsBase
{
    Q_OBJECT
 
  public:
    QgsProcessingContextOptionsWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr );

    void setFromContext( const QgsProcessingContext *context );

    Qgis::InvalidGeometryCheck invalidGeometryCheck() const;

    Qgis::DistanceUnit distanceUnit() const;

    Qgis::AreaUnit areaUnit() const;

    QString temporaryFolder();

    int maximumThreads() const;

    void setLogLevel( Qgis::ProcessingLogLevel level );

    Qgis::ProcessingLogLevel logLevel() const;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingAlgorithmWidgetBase::WidgetFlags )
 
#endif

 
#endif // QGSPROCESSINGALGORITHMWIDGETBASE_H