mesheditingtoolbar.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_UI_TOOLBARS_MESHEDITINGTOOLBAR_H
#define OPENSWMMVIS_UI_TOOLBARS_MESHEDITINGTOOLBAR_H
 
#include <QPair>
#include <QPointF>
#include <QPointer>
#include <QToolBar>
#include <QVector>
 
#include <functional>
 
namespace openswmmvis::ui { class RibbonGroup; }
 
class MapCanvas;
class OpenSWMMVisLayer;
class SWMM2DMeshLayer;
 
class QAction;
class QActionGroup;
class QComboBox;
class QDoubleSpinBox;
class QLabel;
class QLineEdit;
class QStackedWidget;
class QToolButton;
 
namespace mesh { class MeshHoverProbe; }
 
class SelectionManager;
struct SWMMObjectRef;
 
class MeshEditingToolbar : public QToolBar
{
    Q_OBJECT
public:
    explicit MeshEditingToolbar(const QString &title, QWidget *parent = nullptr);
    ~MeshEditingToolbar() override;
 
protected:
    void showEvent(QShowEvent *event) override;
 
public:
 
    void rebindCanvas(MapCanvas *canvas);
 
    void rebindSelectionManager(SelectionManager *sel);
 
    using PickerFn = std::function<QString(const QString &currentName)>;
    void setStageTimeseriesPicker(PickerFn fn) { m_stageTSPicker = std::move(fn); }
    void setFlowTimeseriesPicker(PickerFn fn)  { m_flowTSPicker  = std::move(fn); }
    void setRatingCurvePicker(PickerFn fn)     { m_curvePicker   = std::move(fn); }
 
    using ListerFn = std::function<QStringList()>;
    void setTimeseriesLister(ListerFn fn) { m_tsLister    = std::move(fn); }
    void setCurveLister(ListerFn fn)      { m_curveLister = std::move(fn); }
    void setNodeLister(ListerFn fn)       { m_nodeLister = std::move(fn); }
    using NodeLocatorFn = std::function<QVector<QPair<QString, QPointF>>()>;
    void setNodeLocator(NodeLocatorFn fn) { m_nodeLocator = std::move(fn); }
    void refreshBCNameLists();    // re-query listers + repopulate combos
    void refreshNodeList();       // re-query node lister + repopulate the combo
 
    void addToolAction(QAction *action);
    void addToolSeparator();
 
    void addProfileAction(QAction *action);
 
    QAction *addToolWidget(QWidget *widget);
 
    [[nodiscard]] QLabel *cellInfoLabel() const { return m_cellInfoLbl; }
 
    [[nodiscard]] QWidget *cellParamEditorWidget() const;
    [[nodiscard]] QWidget *cellTagWidget() const;
    void setCellEditorActions(QAction *paramAct, QAction *tagAct);
 
    void addCellAction(QAction *action);
 
    [[nodiscard]] QByteArray currentCellParamKey() const;
 
    void setDepthUnitLabel(const QString &label);
 
    [[nodiscard]] SWMM2DMeshLayer *activeMesh() const { return m_activeMesh; }
 
signals:
    void editVertexToggled(bool active);
 
    void editEdgeToggled(bool active);
 
    void hoverElevationChanged(double z, bool finite);
 
private slots:
    void onActiveMeshComboChanged(int index);
    void onLayerAdded(OpenSWMMVisLayer *layer);
    void onLayerRemoved(OpenSWMMVisLayer *layer);
    void onActiveMeshFlagChanged(bool isActive);
    void onAttributeChanged(const QString &refName);
    void onHoverElevation(double z, bool finite);
    void onZSpinChanged(double z);
    void onVertexTagCommit();        // descriptive vertex tag → selected vertex
    void onVertexCoupledCommit();    // coupled SWMM node → selected vertex
    void onVertexCdCommit();         // coupling Cd → selected coupled vertices
    void onVertexAreaCommit();       // coupling area → selected coupled vertices
    void onAutoCoupleClicked();      // couple vertices to coincident SWMM nodes
    void onRemapClicked();           // Remap 1D↔2D: vertex + cell coupling (Plan C.4)
 
    [[nodiscard]] QString meshAreaUnitLabel() const;
    void onCellParamCommit();        // selected parameter → selected cells
    void onCellEnumCommit(int index); // Kind::Enum editor → selected cells
    void onCellParamChanged(int index); // reconfigure the value editor
    void onCellTagCommit();          // descriptive triangle tag → selected cell
    void onSelectionChanged();
    void onBCTypeChanged(int index);
    void commitBCParam();             // apply-as-you-go: write current param to selected edges
    void commitConveyance();          // apply-as-you-go: ψ → every selected edge (interior + boundary)
    void onBrowseBCObject();          // shared "…" → dispatches to right CRUD picker
    void onPickStageTseries();
    void onPickFlowTseries();
    void onPickRatingCurve();
 
private:
    bool m_bcListsStale = false;
 
    bool m_nodeListStale = false;
 
    void rebuildMeshCombo();
    void refreshGroupWidths();   // re-measure the ribbon groups after
                                 // contextual clusters show/hide
    void connectMeshLayer(SWMM2DMeshLayer *layer);
    void disconnectMeshLayer(SWMM2DMeshLayer *layer);
    void refreshVertexEditor();
    void refreshEdgeEditor();
    void refreshCellEditor();
    void updateEnabledState();
    void commitCellParam(double value);
 
    QList<int> currentSelectedVertices() const;          // all selected vertex indices
    QList<QPair<int,int>> currentSelectedEdges() const;  // (tri, eLocal) pairs
    QList<int> currentSelectedCells() const;             // all selected triangle indices
 
    // Iteration 3 — captioned ribbon groups, each hosting a mini
    // toolbar so the action-based show/hide machinery keeps working.
    QList<openswmmvis::ui::RibbonGroup *> m_groups;
    QToolBar *m_barMesh     = nullptr;
    QToolBar *m_barVertices = nullptr;
    QToolBar *m_barEdges    = nullptr;
    QToolBar *m_barCoupling = nullptr;
    QToolBar *m_barResults  = nullptr;   // Pick cells cluster (SWMMVis inserts)
    QToolBar *m_barProfile  = nullptr;   // standalone profile plotter
 
    QPointer<MapCanvas>           m_canvas;
    QPointer<SelectionManager>    m_selection;
    QPointer<SWMM2DMeshLayer>     m_activeMesh;
    mesh::MeshHoverProbe         *m_hover = nullptr;
 
    // Top row
    QComboBox     *m_meshCombo      = nullptr;
    QLabel        *m_hoverLabel     = nullptr;
    QAction       *m_spacerAction   = nullptr;   // trailing stretch; tool actions insert before it
 
    // Edit mode toggles
    QAction       *m_actEditVertex  = nullptr;
    QAction       *m_actEditEdge    = nullptr;
    QActionGroup  *m_editGroup      = nullptr;
 
    // Vertex Z editor
    QLabel        *m_vertexInfoLbl  = nullptr;
    QDoubleSpinBox*m_zSpin          = nullptr;
    QLineEdit     *m_vertexTagEdit  = nullptr;   // descriptive tag
    QComboBox     *m_vertexCoupledCombo = nullptr;// coupled SWMM node (dropdown)
    QAction       *m_actVertexTag     = nullptr; // embedding actions for hide
    QAction       *m_actVertexCoupled = nullptr;
    QDoubleSpinBox*m_vertexCdSpin   = nullptr;   // coupling Cd ([2D_VERTEX_NODE_MAP] CD)
    QDoubleSpinBox*m_vertexAreaSpin = nullptr;   // coupling exchange area, m² (AREA)
    QAction       *m_actVertexCd    = nullptr;   // embedding actions for hide
    QAction       *m_actVertexArea  = nullptr;
    QAction       *m_actAutoCouple  = nullptr;   // couple vertices to coincident nodes
    QAction       *m_actRemap       = nullptr;   // Remap 1D↔2D (Plan C.4)
 
    // BC controls (Slice §V.VC — fully wired for all 7 GUI BC types).
    QComboBox     *m_bcTypeCombo    = nullptr;
    QStackedWidget*m_bcParamStack   = nullptr;
    QAction       *m_actBrowseObj   = nullptr;   // launches TS / Curve CRUD dialog
    QLabel        *m_edgeInfoLbl    = nullptr;
    // addWidget() handles for the BC combo + param stack so they can be
    // shown/hidden contextually (hiding the QAction collapses the gap).
    QAction       *m_actBCTypeCombo  = nullptr;
    QAction       *m_actBCParamStack = nullptr;
 
    // Cell-selection info label (after the Select-2D-Cells tool).
    QLabel        *m_cellInfoLbl    = nullptr;
    // Cell parameter page: "<parameter> [value]" — one editor for every
    // per-cell attribute in mesh::cellParamSpecs().
    QWidget       *m_cellParamPage  = nullptr;
    QComboBox     *m_cellParamCombo = nullptr;
    QDoubleSpinBox*m_cellValueSpin  = nullptr;
    // Value editor for CellParamSpec::Kind::Enum parameters (infiltration
    // method). Shares the slot the spin box occupies — exactly one of the two
    // is visible, chosen by the selected parameter's kind. A −1…5 numeric
    // spinner for an enumeration is not an editor, it is a puzzle.
    QComboBox     *m_cellEnumCombo  = nullptr;
    QLineEdit     *m_cellTagEdit    = nullptr;   // descriptive triangle tag
    QAction       *m_actCellParam   = nullptr;   // embedding actions for hide
    QAction       *m_actCellTag     = nullptr;
    QAction       *m_actCellInfil   = nullptr;   // "Assign Infiltration to Selection…"
    // Project depth unit ("ft"/"m") shown on length-valued parameters.
    QString        m_depthUnitLabel = QStringLiteral("m");
 
    // Param-page widgets (held directly so the apply path reads values
    // without going through QStackedWidget::currentWidget casts).
    QDoubleSpinBox*m_slopeSpin      = nullptr;  // NormalFlow
    QDoubleSpinBox*m_stageSpin      = nullptr;  // SpecifiedStageConst
    QComboBox     *m_stageTSCombo   = nullptr;  // SpecifiedStageTS — editable combo over registry
    QDoubleSpinBox*m_flowSpin       = nullptr;  // SpecifiedFlowConst
    QComboBox     *m_flowTSCombo    = nullptr;  // SpecifiedFlowTS  — editable combo over registry
    QComboBox     *m_curveCombo     = nullptr;  // RatingCurve     — editable combo over registry
 
    // Engine §11A — per-edge flux attenuation (conveyance) widget. Lives
    // OUTSIDE the BC param stack because it applies to every edge (interior
    // and boundary), not just boundary edges. Visibility tracks edgeMode +
    // any selected edge (independent of haveBoundaryEdge).
    QDoubleSpinBox*m_conveySpin     = nullptr;
    QAction       *m_actConveySpin  = nullptr;
 
    bool           m_suppressZSignal = false;
    bool           m_refreshingEdgeEditor = false;
 
    PickerFn       m_stageTSPicker;
    PickerFn       m_flowTSPicker;
    PickerFn       m_curvePicker;
 
    ListerFn       m_tsLister;
    ListerFn       m_curveLister;
    ListerFn       m_nodeLister;
    NodeLocatorFn  m_nodeLocator;
};
 
#endif // OPENSWMMVIS_UI_TOOLBARS_MESHEDITINGTOOLBAR_H