swmmvis.h

Go to the documentation of this file.

 
#ifndef SWMMVIS_H
#define SWMMVIS_H
 
#include <QDateTime>   // 2026-07-19 — mPendingSeekTime (scrub coalescing)
#include <QHash>
#include <QMainWindow>
#include <QPointer>
#include <QSettings>
#include <functional>
#include <optional>
#include <utility>
 
#include "core/openswmmvislogmessage.h"
#include "layers/swmmmodellayer.h"        // NewProjectSpec (nested type)
#include "selection/selectionmanager.h"   // SWMMObjectRef
#include "plot/plotattribute.h"
#include "plot/resultdescriptor.h"           // PlotAttribute (AT.2)
#include "plot/profilerouter.h"           // ProfileRouter::Path
 
QT_BEGIN_NAMESPACE
namespace Ui { class SWMMVis; }
QT_END_NAMESPACE
 
namespace openswmmvis::ui { class CompactToolbarController; }
namespace openswmmvis::ui { class ComparisonPlotDialog; }
namespace openswmmvis::ui { class RainfallVisualizationDialog; }
namespace openswmmvis::ui { class RibbonGroup; }
namespace openswmmvis::project::examples { struct ExampleInfo; }
 
class QCheckBox;
class QLabel;
class QToolButton;
class QComboBox;
class QLineEdit;
class QSlider;
class QDoubleSpinBox;
class QDateTimeEdit;
class QProgressBar;
class QTimer;          // 2026-07-19 — mScrubCoalesceTimer (scrub coalescing)
class QStandardItemModel;
class QDragEnterEvent;
class QDragMoveEvent;
class QDropEvent;
class QMimeData;
class OpenSWMMVisLayer;   // Slice BI-MK.LT — onLayerKindStyleRequested signature
class QMdiSubWindow;
class QAction;
class QMenu;
class GISRasterLayer;
class OpenSWMMVisWorkspace;
class SpatialReferenceSystem;
class MapCanvas;
class SWMMVisProjectWindow;
class LayerTreePanel;
class ObjectBrowserPanel;
class PropertiesPanel;
namespace openswmmvis::ui { class SectionViewPanel; }
class AttributeTablePanel;
class SimulationStatusModel;
class ProfilePlotDialog;
 
namespace openswmmvis::ui { class CursorWindowSlider; }
namespace openswmmvis::ui { class LegendDock; }
namespace openswmmvis::ui { class LayerStylingDock; }
namespace openswmmvis::ui { class FeatureLayerPanel; }
class FeatureLayer;
class SWMMVisProjectWindow;
 
class AnimationController;
 
class SWMMVis : public QMainWindow
{
    Q_OBJECT
 
public:
    explicit SWMMVis(QWidget *parent = nullptr);
 
    virtual ~SWMMVis();
 
    bool saveProjectWindowAs(SWMMVisProjectWindow *pw);
 
    void logPortabilityPreflight(SWMMVisProjectWindow *pw,
                                 const QString &targetPath,
                                 bool isGpkg);
 
public slots:
    void onLogMessage(const QString &message,
                      OpenSWMMVisLogMessage::LogMessageType messageType
                          = OpenSWMMVisLogMessage::LogMessageType::Information);
 
private:
    void initializeWelcomeScreen();
 
    void openExampleCopy(const openswmmvis::project::examples::ExampleInfo &info);
 
    void initializeToolBars();
    void initializeAnimationToolBar();
    void initializeTerrainToolBar();
    void initializeMeshEditingToolBar();   // Slice §V.VB
 
    void initializeAnalysisLayerCombos();
 
    void refreshActiveResultsCombos();
    void initializeMapTools();
    void initializeStatusBar();
 
    void updateCoordinateReadout();
    void initializeDockWidgets();
    void initializeLayersDockWidget();
    void initializeObjectBrowserDockWidget();
    void initializePropertiesPanelDockWidget();
    void initializeSimulationStatusDockWidget();
    void initializeMessageLogDockWidget();
    void initializeLegendDockWidget();   // Slice BB Phase 8.6.11 / 8.6.16
 
    // ── Editable feature layers (MESH_DIALOG_TABS_AND_FEATURE_LAYERS_PLAN
    //    §5.1, §6.2) ────────────────────────────────────────────────────
    void initializeFeatureLayerDockWidget();
    void initializeFeatureLayerActions();
    [[nodiscard]] QString featureGpkgPathFor(SWMMVisProjectWindow *pw) const;
    void onNewFeatureLayer();
    void retargetFeatureTools(SWMMVisProjectWindow *pw, FeatureLayer *layer);
    void onDeleteSelectedFeatures();
    void syncFeatureEditState();
 
    void initializeMenus();
    void initializeSettings();
 
    void registerActions();
 
    void rebindUndoRedoActions(SWMMVisProjectWindow *pw);
    QMetaObject::Connection mUndoEnableConn;
    QMetaObject::Connection mRedoEnableConn;
 
    void initializeCompactToolbar();
 
    void updateContextualTabs();
 
    void saveSettings();
    void clearPreviousWelcomeScreenElements();
    void initializeDefaultWorkspaceSession();
    void applyEditSessionToActions(bool active);
    void applyProjectOpenToActions(bool open);
 
    void updateOffsetModeLabels(bool elevation);
 
private slots:
    void onLayerKindStyleRequested(OpenSWMMVisLayer *layer,
                                   int kindOrdinal,
                                   const QString &rendererId);
 
    void onPlotTimeSeriesFromOutputLayer(class SWMMResultsLayer *layer);
 
    void onNewProject();
 
    void openUntitledProject(const SWMMModelLayer::NewProjectSpec &spec);
 
    SWMMVisProjectWindow *createProjectWindow(const QString &filePath);
 
 
    void onOpenProject(const QString &path = QString());
 
    void openSingleINP(const QString &filePath);
 
    void finalizeSingleINPOpen(SWMMVisProjectWindow *window,
                               const QString &filePath,
                               bool ok,
                               const QList<QString> &warnings,
                               const QList<QString> &errors,
                               qint64 elapsedMs,
                               class OpenProgressModel *progress = nullptr);
 
    void attachMesh2DLayersAsync(SWMMVisProjectWindow *window,
                                 const QString &filePath,
                                 class OpenProgressModel *progress = nullptr);
 
    void maybeLoad2DResults(SWMMVisProjectWindow *window,
                            const QString &filePath,
                            const QString &h5Override = QString());
 
    void showMeshCellProperties(SWMMVisProjectWindow *window,
                                const SWMMObjectRef &ref);
 
    void beginFileOpen(const QString &path);
 
    void endFileOpen(const QString &path, bool ok,
                     const QString &summary, qint64 elapsedMs,
                     const QString &errorDetail = QString());
 
    void openProjectFile(const QString &oswpPath);
 
    void onOpenRecentFile(QAction *action);
 
    void onSaveProject();
 
    void onSaveAs();
 
    void onExportMap();
 
    void onClearRecentFiles();
 
    void onRecentFilesSizeChanged();
 
    void onShowWelcomeScreen();
 
    void onClose();
 
    void onSetProgressBarBusy(bool busy);
 
    void onAbout();
 
    void onModelLoaded();
 
    void onModelLoadError(const QString &msg);
 
    void onFlowUnitsChanged(int comboIndex);
 
    void onCursorPositionChanged(double mapX, double mapY);
 
    void onMeshHoverElevation(double z, bool finite);
 
    void onCanvasSRSChanged(SpatialReferenceSystem *srs);
 
    void onCRSButtonClicked();
 
    void onMapScaleEntered(const QString &text);
 
    void onCanvasScaleChanged(double denominator);
 
    void onAddBasemapLayer();
 
    void onAddWMSLayer();
 
    void onAddWFSLayer();
 
    void onAddVectorLayer();
 
    void onAddRasterLayer();
 
    void onAddSWMMResultsLayer();
 
    void onAddMesh2DLayer();
 
    void onAdd2DResultsLayer();
 
    void onSimulationOptions();
 
    void onClimatology(int tab);
 
    void onEditWaterAgeSources();
 
    void onEditInitialQuality();
 
    void onEditReactionSystem();
 
    void onEditHeatConfig(int tab = -1);
 
    // ── Toolbar quick-wins (Phase 2) ────────────────────────────────────────
    void onSearch();
    void onTabularView();
    void onAddDelimitedData();
    void onSummarizeResults();
 
    void onExport2DResults();
    void onCopyActiveView();
    void onPrintActiveView();
    void onInvertSelection();
 
    // ── Network analysis (Phase 3) ──────────────────────────────────────────
    void onSelectUpstream();
    void onSelectDownstream();
    void onStreamSelect(bool upstream);
    void onFlowBalance(bool upstream);
    void onTravelTime(bool upstream);
 
    void onUserFlags();
 
    void onRunSimulation();
 
    void onPlotTimeSeries();
 
    void onShowReport();
 
    void openTimeSeriesPlotFor(const SWMMObjectRef &ref);
 
    void openTimeSeriesPlotForOnLayer(const SWMMObjectRef &ref,
                                       SWMMResultsLayer *layer);
 
    openswmmvis::ui::ComparisonPlotDialog *ensureComparisonPlotDialog();
 
    openswmmvis::ui::RainfallVisualizationDialog *ensureRainfallVisualizationDialog();
 
    void openRainfallVisualization();
 
    void openRainfallVisualizationFor(const SWMMObjectRef &ref);
 
    void openComparisonPlotFor(const SWMMObjectRef &ref);
 
    void openComparisonPlotForOnLayer(const SWMMObjectRef &ref,
                                       SWMMResultsLayer *layer);
 
    void openComparisonPlotForAttribute(const SWMMObjectRef &ref,
                                        openswmmvis::plot::PlotAttribute attribute);
 
    void openComparisonPlotForAttributeOnLayer(const SWMMObjectRef &ref,
                                                openswmmvis::plot::PlotAttribute attribute,
                                                SWMMResultsLayer *layer);
 
    void openComparisonPlotForDescriptor(
        const SWMMObjectRef &ref,
        const openswmmvis::plot::ResultDescriptor &descriptor);
    void openComparisonPlotForDescriptorOnLayer(
        const SWMMObjectRef &ref,
        const openswmmvis::plot::ResultDescriptor &descriptor,
        SWMMResultsLayer *layer);
 
    void openComparisonPlotOverlayForProfile(
        ProfilePlotDialog *profileDlg,
        const SWMMObjectRef &ref,
        const openswmmvis::plot::ResultDescriptor &descriptor);
 
    void openComparisonPlotForSystemAttribute(openswmmvis::plot::PlotAttribute attribute);
 
    void openComparisonPlotForCells(class SWMM2DResultsLayer *layer,
                                    const QVector<int> &triIdxList,
                                    const QVector<openswmmvis::plot::PlotAttribute> &attrs);
 
    void onAddFromMapToggled(bool active);
 
    void openProfilePlotFor(const ProfileRouter::Path &path);
 
    void openMeshProfilePlotFor(const QVector<QPointF> &scenePolyline);
    void openMeshBedProfilePlotFor(const QVector<QPointF> &scenePolyline);
 
    void openTerrainProfilePlotFor(const QVector<QPointF> &scenePolyline);
 
    void onPlotProfileTriggered();
 
    void openMeshProfileDialog(const QVector<QPointF> &scenePolyline,
                               class SWMM2DResultsLayer *results,
                               const QString &title);
 
    void openMeshEdgeFluxPlotFor(class SWMM2DMeshLayer *mesh, int triIdx, int edgeLocal,
                                 openswmmvis::plot::PlotAttribute attr);
 
    void openMeshVertexSeriesFor(class SWMM2DMeshLayer *mesh, const QVector<int> &vertexIdxList,
                                 const QVector<openswmmvis::plot::PlotAttribute> &attrs);
 
    void onActiveSubWindowChanged(QMdiSubWindow *window);
 
    void rebuildWindowMenu();
 
    void resetWindowPositions();
 
protected:
    void closeEvent(QCloseEvent *event) override;
    bool eventFilter(QObject *watched, QEvent *event) override;
 
    QMenu *createPopupMenu() override;
 
    // Feature A — drag-and-drop of .inp / .oswp files onto the main window.
    // Accepted local paths are routed through onOpenProject().
    void dragEnterEvent(QDragEnterEvent *event) override;
    void dragMoveEvent(QDragMoveEvent *event) override;
    void dropEvent(QDropEvent *event) override;
 
    [[nodiscard]] QStringList acceptableDropPaths(const QMimeData *mime) const;
 
    QMdiSubWindow *welcomeSubWindow() const;
 
    void removeWelcomeSubWindow();
 
private:
    Ui::SWMMVis *ui;
    QStringList mRecentFiles;
    bool mShowSplashScreenOnStartUp  = true;
    bool mShowWelcomeScreenOnStartUp = true;
 
    // Status bar widgets
    QCheckBox    *mCheckBoxLevelOffsetMode             = nullptr;
    QLabel       *mLabelOffsetElevation                = nullptr;
    QLabel       *mLabelOffsetDepth                    = nullptr;
    QCheckBox    *mCheckBoxAutoLength                  = nullptr;
    QToolButton  *mToolButtonCoordinateReferenceSystem = nullptr;
    QLineEdit    *mLineEditCoordinates                 = nullptr;
    // Coordinate-readout state: last cursor position (canvas CRS) + the
    // mesh hover-Z mirrored from the Mesh Editing toolbar's probe, so
    // either input can rebuild the readout.
    double        mLastCursorMapX                      = 0.0;
    double        mLastCursorMapY                      = 0.0;
    bool          mHasCursorPos                        = false;
    std::optional<double> mMeshHoverZ;
    QComboBox    *mComboBoxMapScale                    = nullptr;
    QComboBox    *mComboBoxFlowUnits                   = nullptr;
    QComboBox    *mComboBoxEngineVersion               = nullptr;
    QProgressBar  *mProgressBar                       = nullptr;
    QLabel        *mProgressLabel                     = nullptr;
    QDateTimeEdit *mDateTimeEditAnimationTime         = nullptr;
    QLabel        *mLabelAnimationSpeed               = nullptr;
    QComboBox     *mComboAnimationSpeed               = nullptr;
    QCheckBox     *mCheckBoxAnimationCycle            = nullptr;  // loop playback at end-of-range (default on)
    // Causal "as-of within timespan" sync controls (look-back window).
    QLabel        *mLabelAnimationWindow              = nullptr;
    QDoubleSpinBox *mSpinAnimationWindow              = nullptr;
    // Issue 1 — single-thumb scrubber (cursor) + painted look-back window band.
    // Replaces the laggy two-thumb RangeSliderWidget; the window is driven by
    // mSpinAnimationWindow, not by a second thumb.
    openswmmvis::ui::CursorWindowSlider *mAnimationSlider = nullptr;
    // 2026-07-19 — scrub-seek coalescing (slider lag fix). cursorChanged
    // fires per drag pixel; each seek used to run the full synchronous
    // layer fetch + 2D frame load. Drag now stores the pending time and
    // restarts this ~40 ms single-shot timer (trailing edge, same idiom as
    // MapCanvas::m_refreshTimer); cursorReleased seeks immediately so the
    // final frame matches the thumb exactly.
    QTimer        *mScrubCoalesceTimer                = nullptr;
    QDateTime      mPendingSeekTime;
    // Active analysis-layer selectors on the Analysis toolbar. The user picks
    // which 1D / 2D results layer every analysis tool targets; "— none —"
    // returns to model editing. Populated from the active project window's
    // OutputStatsRegistry (1D) / canvas 2D results layers, kept in sync via
    // SWMMVisProjectWindow::activeResultsLayerChanged / active2DResultsLayerChanged.
    QLabel        *mLabelActiveResults1D              = nullptr;
    QComboBox     *mComboActiveResults1D              = nullptr;
    QLabel        *mLabelActiveResults2D              = nullptr;
    QComboBox     *mComboActiveResults2D              = nullptr;
    QCheckBox     *mCheckBoxLive2D                    = nullptr;  // live 2D render on/off (Issue 2)
    QCheckBox     *mCheckBoxLive1D                    = nullptr;  // live 1D results pref (LIVE_1D_RESULTS_PLAN_V2)
    class AnimationController *mAnimationController  = nullptr;
    class TerrainToolbar      *mTerrainToolbar       = nullptr;
    class MeshEditingToolbar  *mMeshEditingToolbar   = nullptr;   // Slice §V.VB
 
    // UI redesign P6 — tabbed compact toolbar (strip + per-tab rows).
    openswmmvis::ui::CompactToolbarController *mCompactToolbar = nullptr;
    class QToolBar            *mToolBarHome          = nullptr;
    class QToolBar            *mToolBarModel         = nullptr;
    class QToolBar            *mToolBarMesh2D        = nullptr;
    class QToolBar            *mToolBarView          = nullptr;
    class QToolBar            *mToolBarFeatures      = nullptr;
    // Iteration 2 (R3) — the two formerly .ui-authored bars, rebuilt in
    // code with the SAME objectNames so saved window state keeps working.
    class QToolBar            *mToolBarAnimation     = nullptr;
    class QToolBar            *mToolBarAnalysis      = nullptr;
    // Ribbon groups later phases re-anchor into: the analysis layer
    // combos, the animation timeline widgets, and the Plots group whose
    // Plot-Profile button carries the override dropdown.
    openswmmvis::ui::RibbonGroup *mGroupResultsLayers = nullptr;
    openswmmvis::ui::RibbonGroup *mGroupTimeline      = nullptr;
    openswmmvis::ui::RibbonGroup *mGroupPlots         = nullptr;
    QMetaObject::Connection    mMeshTabConnAdd;
    QMetaObject::Connection    mMeshTabConnRemove;
 
    QSettings          mSettings;
    QStandardItemModel *mLogMessagesModel   = nullptr;
    bool                mLogScrollPending   = false;
    LayerTreePanel        *mLayerTreePanel        = nullptr;
    ObjectBrowserPanel    *mObjectBrowserPanel    = nullptr;
    PropertiesPanel        *mPropertiesPanel        = nullptr;
    // Slice SP.4 — dockable vector section / profile view of the selection.
    openswmmvis::ui::SectionViewPanel *mSectionViewPanel = nullptr;
    AttributeTablePanel   *mAttributeTablePanel   = nullptr;
    // Editable feature layers — the Features dock and its host dock widget
    // (MESH_DIALOG_TABS_AND_FEATURE_LAYERS_PLAN §5.1). Tabified behind the
    // property browser; the panel picks which FeatureLayer the drawing tools
    // target.
    openswmmvis::ui::FeatureLayerPanel *mFeatureLayerPanel = nullptr;
    class QDockWidget     *mFeatureDock           = nullptr;
    SimulationStatusModel *mSimStatusModel        = nullptr;
    // Slice BB Phase 8.6.11 / 8.6.16 — dockable per-class legend / style editor.
    openswmmvis::ui::LegendDock *mLegendDock      = nullptr;
    // Slice Z.18 — always-open layer-styling editor dock.
    openswmmvis::ui::LayerStylingDock *mLayerStylingDock = nullptr;
 
    // Live simulation-progress tracker for the status-bar bottom bar.
    // Keyed by SimulationRunner jobId, value is the latest 0.0–1.0
    // fraction reported by the engine progress callback. The bar shows
    // min-across-running-jobs as a real percent (never busy).
    QHash<int, double> mRunningSimProgress;
 
    // Keyed map of active simulation runners by jobId so the Pause /
    // Cancel toolbar actions can reach any running runner. Entries are
    // removed on SimulationRunner::finished.
    QHash<int, class SimulationRunner *> mActiveRunners;
 
    // Slice CF.MVP — keyed map of in-flight 2D results layers so per-tick
    // twoDDepthsAvailable signals can find the layer to push into. Uses
    // QPointer so the entry is auto-cleared if the layer is destroyed (e.g.
    // the user closes the project window mid-run).
    QHash<int, QPointer<class SWMM2DResultsLayer>> mActive2DResultsLayers;
 
    void adoptFinished2DResults(int jobId, bool success, int errCode);
 
    bool                            mExport2DInFlight = false;
    QHash<int, std::pair<bool, int>> mDeferred2DFinish;
 
    QHash<int, QPointer<class SWMMResultsLayer>> mLive1DLayers;
 
    class SWMMResultsLayer *findOrCreateResultsLayer(SWMMVisProjectWindow *pw,
                                                     const QString &outPath,
                                                     const QString &rptPath);
 
    void tickLive1DResults(int jobId, SWMMVisProjectWindow *pw,
                           const QString &outPath, const QString &rptPath);
 
    // Per-job simulation start time captured from simulationDatesKnown so the
    // post-run HDF5Mesh2DSource can map its /time (days-since-start) to
    // calendar QDateTime for the global animation slider.
    QHash<int, QDateTime>                          mSimulationStarts;
 
    // Slice AT.2 — Add-from-Map mode state. When active, mPlotPickTool is
    // the canvas's active tool and mPrevMapTool holds whichever tool was
    // active when the user toggled "Add from Map…" on. Both cleared when
    // the user toggles back off / presses Esc.
    QPointer<class OpenSWMMVisMapToolPlotPick>     mPlotPickTool;
    QPointer<class OpenSWMMVisMapTool>             mPrevMapTool;
 
    // ── Status-bar progress arbitration (LOAD_PERF Phase 1c) ──────────────
    // One QProgressBar serves three producers: simulation runs (real
    // percent), project opens (real percent), and a handful of genuinely
    // unmeasurable operations (raster/table open) that still want a spinner.
    // They are mutually exclusive, so ownership is explicit and every writer
    // goes through applyProgressBarState().
 
    enum class ProgressOwner { None, Busy, Open, Simulation };
 
    QHash<int, class OpenProgressModel *> mRunningOpens;
    int  mNextOpenId       = 1;
    int  mBusyRefCount     = 0;   
 
    void applyProgressBarState();
 
    OpenProgressModel *beginOpenProgress();
 
    void endOpenProgress(int openId);
 
    void updateSimulationProgressBar();
 
    void logInheritedThreadEnvironment();
 
    void refreshSimulationDatesForProject(class SWMMVisProjectWindow *pw);
 
    void refreshOffsetModeViews();
 
    void clearSimulationStatusForProject(class SWMMVisProjectWindow *pw);
 
    // Phase 2 editing actions — declared for future programmatic wiring
    QAction           *mActionAddJunction  = nullptr;
    QAction           *mActionAddOutfall   = nullptr;
    QAction           *mActionAddStorage   = nullptr;
    QAction           *mActionAddConduit   = nullptr;
    QAction           *mActionDeleteObject = nullptr;
 
    // macOS-style Window menu (programmatically built — the .ui has no
    // menuWindow). Entries rebuild on every MDI subWindowActivated and on
    // each project window's windowTitleChanged so the list stays in sync.
    QMenu             *mMenuWindow              = nullptr;
    QAction           *mActionWindowMinimize    = nullptr;
    QAction           *mActionWindowZoom        = nullptr;
    QAction           *mActionWindowBringAllToFront = nullptr;
    QAction           *mActionWindowResetPositions  = nullptr;
 
    OpenSWMMVisWorkspace *mProject              = nullptr;
    SWMMVisProjectWindow *mActiveProjectWindow  = nullptr;  // last-bound project; survives transient focus loss
 
    SWMMVisProjectWindow *activeProjectWindow() const;
    MapCanvas            *activeCanvas()        const;
 
    bool                  zoomCanvasToSelection(MapCanvas *c) const;
};
 
#endif // SWMMVIS_H