guiextensionhost.h

Go to the documentation of this file.

 
#pragma once
#include "sdk/ExtensionHost.hpp"
#include "sdk/IModelEvents.hpp"
#include "sdk/ISessionEvents.hpp"
#include "sdk/IViewEvents.hpp"
#include "sdk/IViewControls.hpp"
#include "sdk/IActivityEvents.hpp"
#include "sdk/IActivityControls.hpp"
#include "sdk/ITimeSeriesLayers.hpp"
#include "sdk/IProgress.hpp"
#include "sdk/IPreviewLayers.hpp"
#include "sdk/IModelInstance.hpp"
#include "sdk/IProject.hpp"
#include <QHash>
#include <QJsonArray>
#include <QMainWindow>
#include <QMdiArea>
#include <QPointer>
#include <QSettings>
#include <QThreadPool>
#include <memory>
#include <vector>
 
class QDockWidget;
class QPlainTextEdit;
 
namespace openswmmvis
{
class ExtensionNetwork;
class ExtensionStateRegistry;
class ExtensionActivityUi;
struct ExtensionUiBridge {
    std::function<bool(const OpenSWMM::Sdk::RibbonTabSpec &,
                       const QHash<QString, QPointer<QAction>> &)>
        addTab;
    std::function<void(const QString &)> removeTab;
    std::function<void(const QString &, QAction *)> addAction;
    std::function<void(const QString &)> removeAction;
    std::function<QList<QVariantMap>()> runs; 
    std::function<int(OpenSWMM::Sdk::IModelInstance *, QString *)>
        startRun;                       
    std::function<void(int)> cancelRun; 
    std::function<QUuid(const QUuid &, quint64, QString *)>
        startRunAttempt; 
    std::function<bool(const QUuid &, QString *)>
        cancelRunAttempt; 
    std::function<QList<QVariantMap>(OpenSWMM::Sdk::IModelInstance *, const QString &)>
        plotVariables; 
    std::function<bool(OpenSWMM::Sdk::IModelInstance *, const QString &, const QString &,
                       const QString &)>
        timeSeries; 
    std::function<bool(OpenSWMM::Sdk::IModelInstance *, const QStringList &)>
        profile;                                     
    std::function<QStringList()> dialogIds;          
    std::function<bool(const QString &)> openDialog; 
    std::function<QAction *(const QString &)> dialogAction; 
    std::function<QMetaObject::Connection(QObject *, std::function<void()>)>
        watchDialogActions; 
    std::function<void(const QUuid &, const QString &, double, const QString &)>
        progressChanged; 
    std::function<void(const QUuid &)>
        progressFinished; 
    std::function<void(const QString &, const QString &)>
        logMessage; 
};
 
class GuiExtensionHost final : public QObject,
                               public OpenSWMM::Sdk::ExtensionHost,
                               public OpenSWMM::Sdk::IUiHost,
                               public OpenSWMM::Sdk::ISettings,
                               public OpenSWMM::Sdk::IConsole,
                               public OpenSWMM::Sdk::IRunRegistry,
                               public OpenSWMM::Sdk::IPlotService,
                               public OpenSWMM::Sdk::IDialogs,
                               public OpenSWMM::Sdk::IModelEvents,
                               public OpenSWMM::Sdk::ISessionEvents,
                               public OpenSWMM::Sdk::IViewEvents,
                               public OpenSWMM::Sdk::IViewControls,
                               public OpenSWMM::Sdk::IActivityEvents,
                               public OpenSWMM::Sdk::IActivityControls,
                               public OpenSWMM::Sdk::ITimeSeriesLayers,
                               public OpenSWMM::Sdk::IProgress,
                               public OpenSWMM::Sdk::IPreviewLayers
{
    Q_OBJECT
    Q_INTERFACES(OpenSWMM::Sdk::IModelEvents OpenSWMM::Sdk::ISessionEvents OpenSWMM::Sdk::IViewEvents OpenSWMM::Sdk::IViewControls OpenSWMM::Sdk::IActivityEvents OpenSWMM::Sdk::IActivityControls OpenSWMM::Sdk::ITimeSeriesLayers OpenSWMM::Sdk::IProgress OpenSWMM::Sdk::IPreviewLayers)
public:
    GuiExtensionHost(QString id, OpenSWMM::Sdk::CompatibilityManifest manifest, QMainWindow *window,
                     QMdiArea *mdi, ExtensionUiBridge bridge, QSettings *settings,
                     QObject *parent = nullptr, ExtensionStateRegistry *stateRegistry = nullptr);
    ~GuiExtensionHost() override;
    OpenSWMM::Sdk::CompatibilityManifest manifest() const override { return mManifest; }
    QString pluginId() const override { return mId; }
    QObject *lifetime() const override { return const_cast<GuiExtensionHost *>(this); }
    QList<OpenSWMM::Sdk::IProject *> projects() const override;
    OpenSWMM::Sdk::IProject *activeProject() const override;
    QList<OpenSWMM::Sdk::IModelInstance *> instances() const override;
    OpenSWMM::Sdk::IModelInstance *activeInstance() const override;
    OpenSWMM::Sdk::IUiHost *ui() override { return this; }
    OpenSWMM::Sdk::ISettings *settings() override { return this; }
    OpenSWMM::Sdk::IConsole *console() override { return this; }
    QUuid beginProgress(const QString &title, QObject *context) override;
    bool updateProgress(const QUuid &operationId, double fraction, const QString &stage) override;
    bool finishProgress(const QUuid &operationId, OpenSWMM::Sdk::ProgressOutcome outcome,
                        const QString &detail = {}) override;
    OpenSWMM::Sdk::INetworkPolicy *network() override;
    OpenSWMM::Sdk::IRunRegistry *runRegistry() override { return this; }
    OpenSWMM::Sdk::IPlotService *plots() override { return this; }
    OpenSWMM::Sdk::IDialogs *dialogs() override { return this; }
    QList<QVariantMap> runs() const override;
    int start(OpenSWMM::Sdk::IModelInstance *instance, QString *error = nullptr) override;
    void cancel(int id) override;
    QList<QVariantMap> variables(OpenSWMM::Sdk::IModelInstance *instance,
                                 const QString &category) const override;
    bool timeSeries(OpenSWMM::Sdk::IModelInstance *instance, const QString &category,
                    const QString &name, const QString &variableKey) override;
    bool profile(OpenSWMM::Sdk::IModelInstance *instance, const QStringList &nodes) override;
    QStringList ids() const override;
    bool open(const QString &id) override;
    bool isDark() const override;
    QColor themeColor(QPalette::ColorRole role) const override;
    QMetaObject::Connection
    observe(QObject *context,
            std::function<void(const QString &, const QVariantMap &)> callback) override;
    QMetaObject::Connection
    subscribe(QObject *context, const OpenSWMM::Sdk::EventFilter &filter,
              std::function<void(const OpenSWMM::Sdk::Event &)> callback) override;
    OpenSWMM::Sdk::StateSnapshot stateSnapshot() const override;
    OpenSWMM::Sdk::IJob *importTimeSeries(
        const OpenSWMM::Sdk::TimeSeriesImportRequest &request, QObject *context,
        std::function<void(const OpenSWMM::Sdk::TimeSeriesImportResult &)> finished,
        QString *error = nullptr) override;
    QList<OpenSWMM::Sdk::TimeSeriesLayerInfo> timeSeriesLayers(const QUuid &sessionId) const override;
    void setTimeSeriesControls(
        std::function<OpenSWMM::Sdk::IJob *(
            const OpenSWMM::Sdk::TimeSeriesImportRequest &, QObject *,
            std::function<void(const OpenSWMM::Sdk::TimeSeriesImportResult &)>, QString *)> importer,
        std::function<QList<OpenSWMM::Sdk::TimeSeriesLayerInfo>(const QUuid &)> layers);
    QUuid previewLayer(const QUuid &sessionId, QList<qint64> *featureIds = nullptr) const override;
    void setPreviewLayers(std::function<QUuid(const QUuid &, QList<qint64> *)> lookup);
    void setJobCancellationHook(OpenSWMM::Sdk::IJob *job, std::function<void()> hook);
    bool isStopping() const;
    OpenSWMM::Sdk::IModelInstance *resolveSession(const QUuid &sessionId) const override;
    QMetaObject::Connection observeState(
        QObject *context, const OpenSWMM::Sdk::StateEventFilter &filter,
        std::function<void(const OpenSWMM::Sdk::StateEvent &)> callback) override;
    QMetaObject::Connection observeBeforeSave(
        QObject *context, std::function<void(const OpenSWMM::Sdk::SaveRequest &)> callback) override;
    OpenSWMM::Sdk::ViewSnapshot viewSnapshot(const QUuid &sessionId) const override;
    QMetaObject::Connection observeViews(
        QObject *context, const OpenSWMM::Sdk::ViewEventFilter &filter,
        std::function<void(const OpenSWMM::Sdk::ViewEvent &)> callback) override;
    bool executeViewCommand(const OpenSWMM::Sdk::ViewCommand &command,
                             QString *error = nullptr) override;
    QList<qint64> selectedLayerFeatures(const QUuid &sessionId, const QUuid &layerSessionId,
                                        int offset = 0, int limit = 500) const override;
    OpenSWMM::Sdk::ActivitySnapshot activitySnapshot() const override;
    QMetaObject::Connection observeActivity(
        QObject *context, const OpenSWMM::Sdk::ActivityEventFilter &filter,
        std::function<void(const OpenSWMM::Sdk::ActivityEvent &)> callback) override;
    QUuid startRunAttempt(const QUuid &sessionId, quint64 loadGeneration,
                          QString *error = nullptr) override;
    QUuid jobOperationId(OpenSWMM::Sdk::IJob *job) const override;
    bool cancelOperation(const QUuid &operationId, QString *error = nullptr) override;
    bool executeActivityUiCommand(const OpenSWMM::Sdk::UiActivityCommand &command,
                                   QString *error = nullptr) override;
    QUuid activityOwnerId() const { return mActivityOwnerId; }
    QUuid activityWindowId() const { return mActivityWindowId; }
    OpenSWMM::Sdk::IJob *runJob(const QString &title,
                                std::function<void(OpenSWMM::Sdk::IJobContext &)> work,
                                std::function<void(bool, const QString &)> finished = {}) override;
    void prepareShutdown() override;
    QVariant value(const QString &key, const QVariant &fallback = {}) const override;
    void setValue(const QString &key, const QVariant &value) override;
    void remove(const QString &key) override;
    QStringList keys() const override;
    void append(const QString &level, const QString &text) override;
    void clear() override;
    void appendLocation(const QString &level, const QString &text, const QString &path,
                        int line) override;
    void setLocationHandler(QObject *context,
                            std::function<void(const QString &, int)> handler) override;
    bool registerAction(const QString &id, QAction *action) override;
    void unregisterAction(const QString &id) override;
    bool registerRibbonTab(const OpenSWMM::Sdk::RibbonTabSpec &tab) override;
    void unregisterRibbonTab(const QString &id) override;
    bool registerDockPanelFactory(OpenSWMM::Sdk::IDockPanelFactory *factory) override;
    void unregisterDockPanelFactory(const QString &id) override;
    bool registerDocumentViewFactory(OpenSWMM::Sdk::IDocumentViewFactory *factory) override;
    void unregisterDocumentViewFactory(const QString &kind) override;
    QWidget *openDocumentView(const QString &kind,
                              OpenSWMM::Sdk::IModelInstance *instance) override;
    bool registerPreferencesPage(OpenSWMM::Sdk::IPreferencesPageFactory *factory) override;
    void unregisterPreferencesPage(const QString &id) override;
    void showDock(const QString &id) override;
    void statusMessage(const QString &text, int milliseconds = 5000) override;
    void message(const QString &title, const QString &text) override;
    void postToMainThread(std::function<void()> callback) override;
    QWidget *mainWindow() const override { return mWindow; }
    void setModelAccess(std::function<QList<OpenSWMM::Sdk::IProject *>()> projects,
                        std::function<OpenSWMM::Sdk::IModelInstance *()> active);
    void setSessionResolver(
        std::function<OpenSWMM::Sdk::IModelInstance *(const QUuid &)> resolver);
    ExtensionStateRegistry *stateRegistry() const;
    void setViewControls(
        std::function<bool(const OpenSWMM::Sdk::ViewCommand &, QString *)> execute,
        std::function<QList<qint64>(const QUuid &, const QUuid &, int, int)> selection);
    void notify(const QString &event, const QVariantMap &data = {});
    void restoreViews(OpenSWMM::Sdk::IModelInstance *instance, const QJsonArray &views);
    QJsonArray saveViews(OpenSWMM::Sdk::IModelInstance *instance) const;
signals:
    void aboutToShutdown();
    void eventOccurred(const QString &event, const QVariantMap &data);
    void typedEventOccurred(const OpenSWMM::Sdk::Event &event);
 
protected:
    bool eventFilter(QObject *object, QEvent *event) override;
 
private:
    struct Job;
    struct ProgressOperation {
        QPointer<QObject> context; 
        QMetaObject::Connection destroyed; 
        QString title; 
        QString stage; 
        double fraction = -1.; 
        quint64 revision = 0; 
    };
    QUuid beginProgressOperation(const QString &title, QObject *context, const QUuid &operationId);
    bool releaseProgress(const QUuid &operationId, OpenSWMM::Sdk::ProgressOutcome outcome,
                         const QString &detail, bool writeLog);
    struct View {
        QString kind;
        OpenSWMM::Sdk::IModelInstance *instance;
        QPointer<QWidget> widget;
    };
    QString qualified(const QString &id) const;
    QString settingsKey(const QString &key) const;
    void checkThread() const;
    QString mId;
    OpenSWMM::Sdk::CompatibilityManifest mManifest;
    QPointer<QMainWindow> mWindow;
    QPointer<QMdiArea> mMdi;
    QSettings *mSettings;
    ExtensionUiBridge mBridge;
    QHash<QString, QPointer<QAction>> mActions;
    QStringList mTabs;
    QHash<QString, QPointer<QDockWidget>> mDocks;
    QHash<QString, OpenSWMM::Sdk::IDocumentViewFactory *> mFactories;
    QList<View> mViews;
    QHash<OpenSWMM::Sdk::IModelInstance *, QJsonArray> mPending;
    QPointer<QDockWidget> mOutput;
    QPointer<QPlainTextEdit> mText;
    QPointer<QObject> mLocationContext;
    std::function<void(const QString &, int)> mLocationHandler;
    QThreadPool mPool;
    ExtensionNetwork *mNetwork = nullptr;
    std::vector<std::unique_ptr<Job>> mJobs;
    QHash<QUuid, ProgressOperation> mProgress; 
    bool mStopping = false;
    QUuid mActivityOwnerId = QUuid::createUuid(); 
    QUuid mActivityWindowId; 
    std::unique_ptr<ExtensionActivityUi> mActivityUi; 
    quint64 mEventSequence = 0; 
    QPointer<ExtensionStateRegistry> mStateRegistry; 
    QList<QMetaObject::Connection> mStateConnections; 
    std::function<OpenSWMM::Sdk::IModelInstance *(const QUuid &)> mSessionResolver;
    std::function<bool(const OpenSWMM::Sdk::ViewCommand &, QString *)> mViewCommand;
    std::function<QList<qint64>(const QUuid &, const QUuid &, int, int)> mViewSelection;
    std::function<OpenSWMM::Sdk::IJob *(
        const OpenSWMM::Sdk::TimeSeriesImportRequest &, QObject *,
        std::function<void(const OpenSWMM::Sdk::TimeSeriesImportResult &)>, QString *)> mTimeSeriesImport;
    std::function<QList<OpenSWMM::Sdk::TimeSeriesLayerInfo>(const QUuid &)> mTimeSeriesLayers;
    std::function<QUuid(const QUuid &, QList<qint64> *)> mPreviewLayer;
    std::function<QList<OpenSWMM::Sdk::IProject *>()> mProjects;
    std::function<OpenSWMM::Sdk::IModelInstance *()> mActive;
    bool cancelOwnJobOperation(const QUuid &operationId, QString *error);
};
}