swmmvisprojectwindow.h

Go to the documentation of this file.

 
#ifndef SWMMVISPROJECTWINDOW_H
#define SWMMVISPROJECTWINDOW_H
 
#include <QHash>
#include <QJsonArray>
#include <QMdiSubWindow>
#include <QList>
#include <QPointF>
#include <QPointer>
#include <QString>
#include <QVector>
 
#include "plot/plotattribute.h"   // PlotAttribute (edge flow vs flux relay)
#include "layers/swmmmodellayer.h"  // SWMMModelLayer::NewProjectSpec (nested)
 
class OpenSWMMVisWorkspace;
class MapCanvas;
class SWMMModelLayer;
class SWMMResultsLayer;
class SWMM2DResultsLayer;
class SelectionManager;
class UnitSystem;
class OpenSWMMVisMapTool;
class OpenSWMMVisMapToolPan;
class OpenSWMMVisMapToolZoom;
class OpenSWMMVisMapToolSelect;
class OpenSWMMVisMapToolSelectPolygon;
class OpenSWMMVisMapToolMeasure;
class OpenSWMMVisMapToolAddNode;
class OpenSWMMVisMapToolAddVirtualNode;
class OpenSWMMVisMapToolAddLink;
class OpenSWMMVisMapToolAddGage;
class OpenSWMMVisMapToolAddSubcatchment;
class OpenSWMMVisMapToolAddText;
class OpenSWMMVisAnnotationLayer;
class GISRasterLayer;
class QComboBox;
class QLabel;
class QFrame;
 
namespace openswmmvis { class OutputStatsRegistry; }    // Slice QA.2
 
class SWMMVisProjectWindow : public QMdiSubWindow
{
    Q_OBJECT
 
public:
    explicit SWMMVisProjectWindow(
        OpenSWMMVisWorkspace *workspace,
        const QString &filePath = QString(),
        QWidget *parent = nullptr
    );
    
    ~SWMMVisProjectWindow() override;
 
    MapCanvas        *canvas()           const;
    SWMMModelLayer   *modelLayer()       const;
    UnitSystem       *unitSystem()       const;
    SelectionManager *selectionManager() const;
 
    bool isElevationOffsetMode() const { return mElevationOffsetMode; }
    void setElevationOffsetMode(bool elevation);
 
    void convertLinkOffsets(bool toElevation, bool convertValues);
 
    void reloadElevationOffsetModeFromEngine();
 
    bool loadModel(QList<QString> &warnings, QList<QString> &errors);
 
    void attachMeshLayer(class SWMM2DMeshLayer *meshLayer, bool pristine = false);
 
    void importMeshFileAsync(const QString &srcPath);
 
    void loadModelAsync(class OpenProgressModel *progress = nullptr);
 
    bool initializeBlankModel(const SWMMModelLayer::NewProjectSpec &spec,
                              QList<QString> &warnings,
                              QList<QString> &errors);
 
    bool save(QString *errorOut = nullptr);
    bool saveAs(const QString &newPath, QString *errorOut = nullptr);
 
    QStringList lastSaveWarnings() const { return mLastSaveWarnings; }
 
    bool hasChanges() const { return mHasChanges; }
 
    void setHasChanges(bool dirty);
 
    bool isEditSessionActive() const { return mEditSessionActive; }
    void setEditSessionActive(bool active);
 
    bool isUntitled() const { return mUntitled; }
 
    bool isClosing() const { return mClosing; }
    void markUntitled();
 
    void activatePanTool();
    void activateZoomInTool();
    void activateZoomOutTool();
    void activateSelectTool();
    void activateSelectByPolygonTool();
    void activateMeasureTool();
    void activateSelectProfileTool();
 
    void activatePick2DCellsTool();
 
    void activateMeshProfileTool();
 
    void activateAnalysisMeshProfileTool();
 
    void activateTerrainProfileTool();
 
    [[nodiscard]] bool hasModelLayer() const;
    [[nodiscard]] bool hasMeshLayer() const;
 
    void activateMeshSelectVertexTool();
 
    void activateMeshSelectEdgeTool();
 
    class OpenSWMMVisMapToolSelect *selectTool() const { return mSelectTool; }
 
    class OpenSWMMVisMapToolSelectProfile *selectProfileTool() const
    { return mSelectProfileTool; }
 
    class OpenSWMMVisMapToolAddVirtualNode *addVirtualJunctionTool() const
    { return mAddVirtualJunctionTool; }
 
    QList<OpenSWMMVisMapToolAddNode *> addNodeTools() const
    { return { mAddJunctionTool, mAddOutfallTool, mAddStorageTool, mAddDividerTool }; }
 
    class OpenSWMMVisMapToolAddInletNode *addInletJunctionTool() const
    { return mAddInletJunctionTool; }
 
    class MapToolPick2DCells *pick2DCellsTool() const { return mPick2DCellsTool; }
 
    class MapToolMeshProfile *meshProfileTool() const { return mMeshProfileTool; }
 
    class openswmmvis::OutputStatsRegistry *statsRegistry() const
    { return mStatsRegistry; }
 
    // ── Active analysis layers (results-analysis demarcation) ────────────────
    //
    // A single model can have several loaded result sets. The "active" 1D and
    // 2D results layers are the ones every analysis/visualization tool targets
    // (Comparison plot, Profile plot, Tabular results, color-by-result, the
    // animation transport, 2D cell picking) instead of the old "first results
    // layer found on the canvas" guess. The user chooses them from the two
    // analysis-toolbar combos or the layer-tree "Set as Active Results Layer"
    // context action. State is per-project so each tab keeps its own choice.
 
    [[nodiscard]] SWMMResultsLayer *activeResultsLayer() const;
 
    [[nodiscard]] SWMM2DResultsLayer *active2DResultsLayer() const;
 
    void setActiveResultsLayer(SWMMResultsLayer *layer);
 
    void setActive2DResultsLayer(SWMM2DResultsLayer *layer);
 
    void setPending2DResultsRestore(const QJsonArray &entries)
    { mPending2DResultsRestore = entries; }
    [[nodiscard]] QJsonArray pending2DResultsRestore() const
    { return mPending2DResultsRestore; }
    void clearPending2DResultsRestore() { mPending2DResultsRestore = {}; }
 
    QHash<class OpenSWMMVisMapTool *, QString> toolActionKeys() const;
    void activateAddJunctionTool();
    void activateAddVirtualJunctionTool();
    void activateAddInletJunctionTool();
    void activateAddOutfallTool();
    void activateAddStorageTool();
    void activateAddDividerTool();
    void activateAddConduitTool();
    void activateAddPumpTool();
    void activateAddOrificeTool();
    void activateAddWeirTool();
    void activateAddOutletTool();
    void activateAddGageTool();
    void activateAddSubcatchmentTool();
    void activateAddTextTool();
    void zoomToFullExtent();
 
    OpenSWMMVisAnnotationLayer *annotationLayer() const { return mAnnotationLayer; }
 
    OpenSWMMVisAnnotationLayer *ensureAnnotationLayer();
 
    bool isAutoLengthEnabled() const { return mAutoLengthEnabled; }
    void setAutoLengthEnabled(bool enabled);
 
    QString engineVersion() const { return mEngineVersion; }
    void setEngineVersion(const QString &version);
 
    QString notesHtml() const { return mNotesHtml; }
    void setNotesHtml(const QString &html) { mNotesHtml = html; }
 
    // ── Terrain editing ──────────────────────────────────────────────────────
 
    [[nodiscard]] QString activeTerrainLayerPath() const;
 
    [[nodiscard]] GISRasterLayer *activeTerrain() const { return mActiveTerrain; }
 
    [[nodiscard]] double terrainVertFactor() const { return mTerrainVertFactor; }
 
    [[nodiscard]] double terrainNodeOffset() const { return mTerrainNodeOffset; }
 
    [[nodiscard]] double terrainLinkOffset() const { return mTerrainLinkOffset; }
 
    void setActiveTerrain(GISRasterLayer *layer);
 
    void setTerrainNodeOffset(double offset);
 
    void setTerrainLinkOffset(double offset);
 
    [[nodiscard]] QString terrainVerticalUnit() const { return mTerrainVertUnit; }
 
    void setTerrainVerticalUnit(const QString &unit);
 
    void restoreTerrainState(const QString &absoluteLayerPath,
                             double nodeOffset,
                             double linkOffset,
                             const QString &vertUnit = QString());
 
signals:
    void modelLoaded();
    void modelLoadError(const QString &msg);
 
    void modelLoadFinished(bool ok, const QList<QString> &warnings,
                           const QList<QString> &errors);
    void saveCompletedWithEngineWarnings(const QStringList &warnings);
    void meshImportFinished(bool ok, const QString &message,
                            const QString &meshPath);
 
    void hasChangesChanged(bool dirty);
    void editSessionChanged(bool active);
    void offsetModeChanged(bool elevation);
    void autoLengthChanged(bool enabled);
 
    void activeResultsLayerChanged(SWMMResultsLayer *layer);
    void active2DResultsLayerChanged(SWMM2DResultsLayer *layer);
 
    void pick2DCellsPicked(class SWMM2DResultsLayer *layer,
                            const QVector<int> &triIdxList,
                            const QVector<openswmmvis::plot::PlotAttribute> &attrs);
 
    void meshProfileTraced(const QVector<QPointF> &scenePolyline);
    void analysisMeshProfileTraced(const QVector<QPointF> &scenePolyline);
 
    void terrainProfileTraced(const QVector<QPointF> &scenePolyline);
 
    void meshEdgeFluxRequested(class SWMM2DMeshLayer *mesh, int triIdx, int edgeLocal,
                               openswmmvis::plot::PlotAttribute attr);
 
    void meshEdgeStatusMessage(const QString &message);
 
    void meshVertexSeriesRequested(class SWMM2DMeshLayer *mesh, const QVector<int> &vertexIdxList,
                                   const QVector<openswmmvis::plot::PlotAttribute> &attrs);
 
    void activeTerrainChanged(GISRasterLayer *newTerrain);
 
    void aboutToClose();
 
protected:
    void closeEvent(QCloseEvent *event) override;
    void changeEvent(QEvent *event) override;
    bool eventFilter(QObject *watched, QEvent *event) override;
 
private:
    void updateWindowTitle();
    void repositionMeasurePanel();
    void updateMeasureUnitCombo();
 
    bool finishModelLoad(QList<QString> &warnings, QList<QString> &errors);
 
    void refreshActive2DCellHighlight();
 
    OpenSWMMVisWorkspace *mWorkspace          = nullptr;
    MapCanvas            *mCanvas             = nullptr;
    SWMMModelLayer       *mModelLayer         = nullptr;
    UnitSystem           *mUnits              = nullptr;
    SelectionManager     *mSelectionManager   = nullptr;
    bool                 mCanvasCRSAdopted    = false;  // true after first successful loadModel
    bool                 mHasChanges          = false;
    bool                 mEditSessionActive   = false;
    bool                 mElevationOffsetMode = false;  // OPTIONS LINK_OFFSETS = ELEVATION
    bool                 mUntitled            = false;  // Slice Y — never saved
    bool                 mClosePromptActive   = false;  // re-entrancy guard for closeEvent's prompt
    bool                 mClosing             = false;  // see isClosing()
    QStringList          mLastSaveWarnings;   // delta across the last successful engine write
    QString              mEngineVersion       = "6.0.0";  // Default to newest version
    QString              mNotesHtml;                      // [TITLE] notes (rich HTML)
    QJsonArray           mPending2DResultsRestore;        // .oswp 2D results entries
 
    OpenSWMMVisMapToolPan         *mPanTool           = nullptr;
    OpenSWMMVisMapToolZoom        *mZoomInTool        = nullptr;
    OpenSWMMVisMapToolZoom        *mZoomOutTool       = nullptr;
    OpenSWMMVisMapToolSelect      *mSelectTool        = nullptr;
    OpenSWMMVisMapToolSelectPolygon *mSelectPolygonTool = nullptr;
    OpenSWMMVisMapToolMeasure     *mMeasureTool       = nullptr;
    class OpenSWMMVisMapToolSelectProfile *mSelectProfileTool = nullptr;
    OpenSWMMVisMapToolAddNode     *mAddJunctionTool   = nullptr;
    OpenSWMMVisMapToolAddVirtualNode *mAddVirtualJunctionTool = nullptr;
    class OpenSWMMVisMapToolAddInletNode *mAddInletJunctionTool = nullptr;
    OpenSWMMVisMapToolAddNode     *mAddOutfallTool    = nullptr;
    OpenSWMMVisMapToolAddNode     *mAddStorageTool    = nullptr;
    OpenSWMMVisMapToolAddNode     *mAddDividerTool    = nullptr;
    OpenSWMMVisMapToolAddLink     *mAddConduitTool    = nullptr;
    OpenSWMMVisMapToolAddLink     *mAddPumpTool       = nullptr;
    OpenSWMMVisMapToolAddLink     *mAddOrificeTool    = nullptr;
    OpenSWMMVisMapToolAddLink     *mAddWeirTool       = nullptr;
    OpenSWMMVisMapToolAddLink     *mAddOutletTool     = nullptr;
    OpenSWMMVisMapToolAddGage     *mAddGageTool       = nullptr;
    OpenSWMMVisMapToolAddSubcatchment *mAddSubcatchTool = nullptr;
    OpenSWMMVisMapToolAddText     *mAddTextTool      = nullptr;
    OpenSWMMVisAnnotationLayer    *mAnnotationLayer  = nullptr;  
    class MapToolPick2DCells          *mPick2DCellsTool = nullptr;  
    class MapToolMeshProfile          *mMeshProfileTool = nullptr;  
    class MapToolMeshProfile          *mAnalysisMeshProfileTool = nullptr; 
    class MapToolMeshProfile          *mTerrainProfileTool = nullptr; 
    class MapToolMeshSelectVertex     *mMeshSelectVertexTool = nullptr; 
    class MapToolMeshSelectEdge       *mMeshSelectEdgeTool   = nullptr; 
 
    // Measure tool floating panel (child of mCanvas)
    QFrame    *mMeasurePanel       = nullptr;
    QComboBox *mMeasureModeCombo   = nullptr;
    QComboBox *mMeasureUnitCombo   = nullptr;
    QLabel    *mMeasureTotalLabel  = nullptr;
 
    bool                           mAutoLengthEnabled = false;
 
    // Slice QA.2 — output identity registry. Owned via QObject parent
    // (constructed with `this` as parent in the .cpp constructor) so
    // it follows the project window's lifetime.
    openswmmvis::OutputStatsRegistry *mStatsRegistry = nullptr;
 
    // Active analysis layers (results-analysis demarcation). QPointer so a
    // layer destroyed/removed from the canvas auto-nulls the active pointer
    // without a dangling reference.
    QPointer<SWMMResultsLayer>   mActiveResultsLayer;
    QPointer<SWMM2DResultsLayer> mActive2DResultsLayer;
 
    // Terrain editing state (per-project, persisted to .oswp)
    GISRasterLayer *mActiveTerrain      = nullptr;
    double          mTerrainNodeOffset  = 0.0;
    double          mTerrainLinkOffset  = 0.0;
    QString         mTerrainVertUnit    = QStringLiteral("m"); // raster vertical unit
    double          mTerrainVertFactor  = 1.0;                 // rasterUnit → modelUnit
};
 
#endif // SWMMVISPROJECTWINDOW_H