layertreepanel.h

Go to the documentation of this file.

 
#ifndef LAYERTREEPANEL_H
#define LAYERTREEPANEL_H
 
#include <QAbstractItemModel>
#include <QHash>
#include <QList>
#include <QPointer>
#include <QSet>
#include <QVector>
#include <QWidget>
 
#include <array>
#include <vector>
 
class QTreeView;
class QToolBar;
class QLineEdit;
class QPoint;
class QSortFilterProxyModel;
class MapCanvas;
class OpenSWMMVisLayer;
class OpenSWMMVisWorkspace;
class SWMMResultsLayer;
class SWMM2DResultsLayer;
 
// Slice S3 — sublayer row type forward decl.
namespace OpenSWMM::Render { class ISublayer; }
 
class LayerTreeModel : public QAbstractItemModel
{
    Q_OBJECT
 
public:
 
    explicit LayerTreeModel(MapCanvas *canvas = nullptr, QObject *parent = nullptr);
    ~LayerTreeModel() override;
 
    void setCanvas(MapCanvas *canvas);
    [[nodiscard]] MapCanvas *canvas() const;
 
    // QAbstractItemModel interface
    QModelIndex  index(int row, int column, const QModelIndex &parent = {}) const override;
    QModelIndex  parent(const QModelIndex &child) const override;
    int          rowCount(const QModelIndex &parent = {}) const override;
    int          columnCount(const QModelIndex &parent = {}) const override;
    QVariant     data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    bool         setData(const QModelIndex &index, const QVariant &value, int role) override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QVariant     headerData(int section, Qt::Orientation orientation, int role) const override;
 
    // Drag-and-drop reordering (within a category only).
    Qt::DropActions supportedDropActions() const override;
    bool            canDropMimeData(const QMimeData *data, Qt::DropAction action,
                                    int row, int column, const QModelIndex &parent) const override;
    bool            dropMimeData(const QMimeData *data, Qt::DropAction action,
                                 int row, int column, const QModelIndex &parent) override;
    QMimeData      *mimeData(const QModelIndexList &indexes) const override;
    QStringList     mimeTypes() const override;
 
    [[nodiscard]] OpenSWMMVisLayer *layerForIndex(const QModelIndex &index) const;
 
    [[nodiscard]] bool isCategoryIndex(const QModelIndex &index) const;
 
    // ---- Slice BI-MK.LT: 3-level tree for multi-kind layers ----------------
    //
    // Under each `SWMMModelLayer` row the model exposes 11 sub-rows, one per
    // Category enum value (Junctions, Outfalls, ..., RainGages). The sub-row
    // surfaces a per-kind visibility checkbox and feeds the right-click
    // context menu's Style submenu.
 
    [[nodiscard]] bool isKindIndex(const QModelIndex &index) const;
 
    [[nodiscard]] OpenSWMMVisLayer *kindParentLayer(const QModelIndex &index) const;
 
    [[nodiscard]] int kindOrdinal(const QModelIndex &index) const;
 
    // ---- Slice S3 (RENDERING_OUTPUT_SUBLAYERS_PLAN.md §4.1) -----------------
    // 3rd-level sub-rows under any ISublayerHost layer that is NOT already
    // multi-kind. SWMM2DResultsLayer adopts this — SWMMResultsLayer keeps
    // its existing OUT.3 kind-row UX (the eligibility rule below avoids
    // dual sub-row schemes on the same layer; the kind-vs-sublayer
    // interaction on multi-kind hosts is a follow-up UX iteration).
 
    [[nodiscard]] bool isSublayerIndex(const QModelIndex &index) const;
 
    [[nodiscard]] OpenSWMMVisLayer *sublayerParentLayer(const QModelIndex &index) const;
 
    [[nodiscard]] OpenSWMM::Render::ISublayer *
        sublayerForIndex(const QModelIndex &index) const;
 
    bool reorderCategory(int categoryId, int dstTreeRow);
 
    [[nodiscard]] int categoryIdForIndex(const QModelIndex &index) const;
 
    // Index lookup for re-selecting a row after a model reset (every
    // reorder resets, which drops the view's selection).
    [[nodiscard]] QModelIndex indexForCategory(int categoryId) const;
    [[nodiscard]] QModelIndex indexForLayer(OpenSWMMVisLayer *layer) const;
    [[nodiscard]] QModelIndex indexForSublayer(OpenSWMMVisLayer *layer,
                                               OpenSWMM::Render::ISublayer *sublayer) const;
 
    void notifyHostSubOrderChanged();
 
private slots:
    void onLayerAdded(OpenSWMMVisLayer *layer);
    void onLayerRemoved(OpenSWMMVisLayer *layer);
    void onLayerOrderChanged();
    void onLayerDataChanged(OpenSWMMVisLayer *layer);
    void onSublayerOrderChanged(OpenSWMMVisLayer *host);
 
private:
    struct Category {
        int        id = -1;                   // openswmmvis::ui::CategoryId
        QString    name;
        QString    iconAlias;                 // Qt resource alias under :/swmmvis/
        QVector<OpenSWMMVisLayer *> layers;   // canvas-stack order, top first
    };
 
    // Slice BI-MK.LT — one KindRow per (multi-kind layer, kind ordinal).
    // Allocated in m_kindRowStorage, then std::array makes the addresses
    // stable across model lifetime so they're safe to use as QModelIndex
    // internalPointers. Hash is keyed on the parent layer pointer; entries
    // exist only for layers that support multi-kind styling (today: only
    // SWMMModelLayer with 11 kinds).
    struct KindRow {
        OpenSWMMVisLayer *layer       = nullptr;
        int               kindOrdinal = -1;
    };
    static constexpr int kKindsPerSwmmModelLayer = 11;
 
    // Slice S3 — one SublayerRow per (host layer, sublayer pointer).
    // Storage is a std::vector reserved to the final size at rebuild time
    // and never modified afterwards, so element addresses stay stable for
    // the model's lifetime — same stability contract as the KindRow
    // std::array storage.
    struct SublayerRow {
        OpenSWMMVisLayer                 *layer    = nullptr;
        OpenSWMM::Render::ISublayer      *sublayer = nullptr;
    };
 
    void rebuildCategories();
    void rebuildKindRows();
    void rebuildSublayerRows();
    int  categoryOf(OpenSWMMVisLayer *layer) const;
    int  sublayerRowIndex(const void *sublayerRowPtr) const;
 
    // QPointer, not a raw pointer: the canvas dies with its project window
    // while this dock outlives it, and setCanvas() disconnects from the OLD
    // canvas — on a raw pointer that was a use-after-free (SIGSEGV in
    // QObject::disconnect from onActiveSubWindowChanged).
    QPointer<MapCanvas>              m_canvas;
    QVector<Category>                m_categories;
    QHash<OpenSWMMVisLayer *, int>   m_layerToCategory;
    QHash<OpenSWMMVisLayer *, std::array<KindRow, kKindsPerSwmmModelLayer>>
                                     m_kindRowStorage;
    QSet<const void *>               m_kindRowPtrSet;   // O(1) kind-row discriminator
    // Slice S3 — sublayer-row storage. The std::vector inside each hash
    // node is sized once at rebuild time and never grown, so element
    // addresses (used as QModelIndex internalPointers) are stable for the
    // model's lifetime. m_sublayerRowPtrSet provides O(1) discrimination
    // between sublayer-row, kind-row, layer, and category indices.
    QHash<OpenSWMMVisLayer *, std::vector<SublayerRow>>
                                     m_sublayerRowStorage;
    QSet<const void *>               m_sublayerRowPtrSet;
 
    // Slice LTR-2026-09-19: no cached category order here. The displayed
    // category sequence is DERIVED from the canvas stack (first appearance,
    // top first) so the tree can never disagree with paint order — including
    // after undo/redo. The per-project preference that places a group whose
    // layers are all gone lives on the canvas (MapCanvas::layerGroupOrder).
};
 
// ---------------------------------------------------------------------------
 
class LayerTreePanel : public QWidget
{
    Q_OBJECT
 
public:
 
    explicit LayerTreePanel(MapCanvas *canvas = nullptr, QWidget *parent = nullptr);
    ~LayerTreePanel() override;
 
    [[nodiscard]] OpenSWMMVisLayer *selectedLayer() const;
 
    void setCanvas(MapCanvas *canvas);
 
    [[nodiscard]] LayerTreeModel *model() const { return m_model; }
 
signals:
 
    void layerSelected(OpenSWMMVisLayer *layer);
 
    void kindSelected(OpenSWMMVisLayer *layer, int kindOrdinal);
 
    void layerPropertiesRequested(OpenSWMMVisLayer *layer,
                                  const QString &routingId = QString());
 
    void attributeTableRequested(OpenSWMMVisLayer *layer);
 
    void layerStyleRequested(OpenSWMMVisLayer *layer);
 
    void layerKindStyleRequested(OpenSWMMVisLayer *layer,
                                 int kindOrdinal,
                                 const QString &rendererId);
 
    void plotKindObjectRequested(int kindOrdinal, const QString &objectName);
 
    void plotTimeSeriesFromOutputLayerRequested(class SWMMResultsLayer *layer);
 
    void setActiveResultsLayerRequested(class SWMMResultsLayer *layer);
    void setActive2DResultsLayerRequested(class SWMM2DResultsLayer *layer);
 
public slots:
    void setActiveResultsLayer(SWMMResultsLayer *layer);
    void setActive2DResultsLayer(SWMM2DResultsLayer *layer);
 
private slots:
    void onRemoveSelectedLayer();
    void onZoomToSelectedLayer();
    void onMoveLayerUp();
    void onMoveLayerDown();
    void onMoveCategoryUp();
    void onMoveCategoryDown();
    void onSelectionChanged();
    void onLayerDoubleClicked(const QModelIndex &index);
    void onContextMenuRequested(const QPoint &pos);
    void onSearchTextChanged(const QString &text);
 
private:
    void setupUi();
    void zoomToLayer(OpenSWMMVisLayer *layer);
    QModelIndex toSourceIndex(const QModelIndex &proxyIdx) const;
 
    // Slice LTR-2026-09-19 — reorder helpers. Layer moves are expressed in
    // tree rows within the layer's category (the canvas keeps the stack
    // grouped, so the sibling's canvas index is the exact target).
    void moveSelectedLayerToRow(int targetRow);
    void moveSelectedCategoryToRow(int targetRow);
    // Every reorder resets the model (and expandAll() follows), which drops
    // the selection. Remember what was current before the reset and put the
    // selection back on the same category / layer / sublayer afterwards.
    void rememberCurrentRow();
    void restoreRememberedRow();
 
    struct RememberedRow {
        int                          categoryId = -1;
        QPointer<OpenSWMMVisLayer>   layer;
        OpenSWMM::Render::ISublayer *sublayer   = nullptr;   // compared by address only
    };
    RememberedRow          m_remembered;
 
    QPointer<MapCanvas>    m_canvas;                 // see LayerTreeModel::m_canvas
    QTreeView             *m_treeView    = nullptr;
    QLineEdit             *m_searchEdit  = nullptr;
    LayerTreeModel        *m_model       = nullptr;
    QSortFilterProxyModel *m_proxy       = nullptr;
 
    // Cached active analysis layers (for the context-menu check-state only).
    QPointer<SWMMResultsLayer>   m_activeResults1D;
    QPointer<SWMM2DResultsLayer> m_activeResults2D;
};
 
#endif // LAYERTREEPANEL_H