openswmmvislayer.h

Go to the documentation of this file.

 
#ifndef SWMMLAYER_H
#define SWMMLAYER_H
 
#include <QByteArray>
#include <QMap>
#include <QObject>
#include <QPaintDevice>
#include <QPainter>
#include <QPair>
#include <QRectF>
#include <QString>
#include <QVector>
#include <QUuid>
 
#include <cmath>
#include <memory>
#include <vector>
 
#include "map/mapextent.h"
// Slice Z.13-attach — per-layer temporal-animation config. Stored by
// value, so the header is required (forward-decl insufficient).
#include "render/temporalspec.h"
 
#include "render/labelconfig.h"   // VS.10 — base-class label configuration
// Slice Z.14-attach — per-layer polygon clip mask.
#include "render/maskspec.h"
// Slice Z.15-attach — per-layer auxiliary-storage (manual overrides DB).
#include "render/auxiliarystoragespec.h"
// Slice Z.16-attach — per-layer external-table joins (list — a layer
// can carry multiple joins keyed on different attributes / sources).
#include "render/joinspec.h"
// Slice Z.12-attach — per-layer embedded chart (pie/bar/time-series).
#include "render/diagramspec.h"
 
// Forward declarations for the unified style-dialog hook (Slice U-2).
namespace openswmmvis::ui { class ILayerStyleSubject; }
 
// Forward decl for renderer plumbing (Slice BI Phase 8.13.6.6).
// Most layers don't own a per-layer renderer; SWMMModelLayer and
// SWMM2DMeshLayer override the virtual accessors below.
namespace OpenSWMM::Render {
class IFeatureRenderer;
class RuleList;   // Slice B.1 — see ruleList() virtual below.
}
#include <memory>
 
inline QRectF snapTileRectToDevicePx(double pxLeft,  double pyTop,
                                     double pxRight, double pyBottom,
                                     qreal dpr)
{
    if (dpr <= 0.0) dpr = 1.0;
    const double l = std::round(pxLeft   * dpr) / dpr;
    const double t = std::round(pyTop    * dpr) / dpr;
    const double r = std::round(pxRight  * dpr) / dpr;
    const double b = std::round(pyBottom * dpr) / dpr;
    return QRectF(l, t, r - l, b - t);
}
 
inline qreal painterDevicePixelRatio(const QPainter *p)
{
    return (p && p->device()) ? p->device()->devicePixelRatioF() : 1.0;
}
 
// Forward-declare to avoid pulling the full basemapconnection.h into every
// translation unit that includes this header.
using BasemapHttpHeaders = QMap<QString, QString>;
 
class OpenSWMMVisWorkspace;
class SpatialReferenceSystem;
class QPainter;
class MapExtent;
class QGraphicsScene;
class QSize;
 
class OpenSWMMVisLayer : public QObject
{
    Q_OBJECT
    Q_ENUMS(SWMMLayerType)
    Q_PROPERTY(QString      Name       READ name       WRITE setName    NOTIFY nameChanged)
    Q_PROPERTY(bool         Visible    READ isVisible  WRITE setVisible NOTIFY visibilityChanged)
    Q_PROPERTY(double       Opacity    READ opacity    WRITE setOpacity NOTIFY opacityChanged)
    Q_PROPERTY(QString      LayerId    READ layerId    CONSTANT)
    Q_PROPERTY(OpenSWMMVisLayerType LayerType READ layerType NOTIFY layerTypeChanged FINAL)
    Q_PROPERTY(QVector<OpenSWMMVisLayer*> Children READ children NOTIFY childrenChanged FINAL)
    // Read-only CRS summary shown in the Properties window — e.g.
    // "EPSG:2926 - NAD83(HARN) / Washington South" or "(none)".
    Q_PROPERTY(QString      CRS        READ crsDescription NOTIFY srsChanged)
 
public:
 
    enum OpenSWMMVisLayerType
    {
        SWMMDefaultLayer          = 0,
        SWMMModelLayer            = 1,  
        SWMMResultsLayer          = 2,  
        SWMMGISLayer              = 3,  
        SWMMVectorLayer           = 4,  
        SWMMRasterLayer           = 5,  
        SWMMImageryLayer          = 6,  
        SWMMTabularDataLayer      = 7,  
        SWMMTabularyTimeSeriesLayer = 8, 
        SWMMSubProjectLayer       = 9,  
        SWMMWMSLayer              = 10, 
        SWMMWMTSLayer             = 11, 
        SWMM2DMeshLayer           = 12, 
        SWMM2DResultsLayer        = 13, 
        SWMMAnnotationLayer       = 14, 
        SWMMFeatureLayer          = 15, 
    };
 
    // ----- Constructors ----------------------------------------------------
 
    explicit OpenSWMMVisLayer(OpenSWMMVisWorkspace *parent);
 
    explicit OpenSWMMVisLayer(const QString &name = "Unlabeled Layer",
                          OpenSWMMVisWorkspace *parent = nullptr);
 
    virtual ~OpenSWMMVisLayer();
 
    // ----- Identity --------------------------------------------------------
 
    [[nodiscard]] QString layerId() const;
 
    [[nodiscard]] QString name() const;
 
    void setName(const QString &name);
 
    [[nodiscard]] OpenSWMMVisLayerType layerType() const;
 
    // ----- Visibility & rendering -----------------------------------------
 
    [[nodiscard]] bool isVisible() const;
 
    void setVisible(bool visible);
 
    [[nodiscard]] double opacity() const;
 
    void setOpacity(double opacity);
 
    // ----- Spatial reference & extent -------------------------------------
 
    [[nodiscard]] SpatialReferenceSystem *srs() const;
 
    void setSRS(SpatialReferenceSystem *srs, bool ownsSRS = false);
 
    [[nodiscard]] QString crsDescription() const;
 
    [[nodiscard]] MapExtent extent() const;
 
    void setExtent(const MapExtent &extent);
 
    // ----- Self-description for the Layer Properties dialog ----------------
    // MVC: the layer (model) describes its own source + type-specific
    // metadata; LayerStyleDialog (view) merely renders these. New layer types
    // add metadata by overriding these — no dialog edit required.
 
    [[nodiscard]] virtual QString sourceDescription() const { return {}; }
 
    [[nodiscard]] virtual QVector<QPair<QString, QString>>
        extendedMetadata() const { return {}; }
 
    // ----- Raster layer identification ------------------------------------
 
    [[nodiscard]] virtual bool isRasterLayer() const { return false; }
 
    [[nodiscard]] virtual bool isBasemapLayer() const { return false; }
 
    // ----- Direct QPainter rendering (QGIS-style buffer path) -------------
 
    virtual void render(QPainter *painter,
                        const MapExtent &extent,
                        const QSize &imageSize,
                        const SpatialReferenceSystem *srs);
 
    virtual void fetchCache(const MapExtent &extent,
                            const QSize &viewportSize,
                            const SpatialReferenceSystem *srs);
 
    // ----- Viewport size (set by MapCanvas before each refresh) -----------
 
    void setViewportSize(int w, int h) { m_vpW = w; m_vpH = h; }
 
    [[nodiscard]] int viewportWidth()  const { return m_vpW; }
    [[nodiscard]] int viewportHeight() const { return m_vpH; }
 
    // ----- Hierarchy -------------------------------------------------------
 
    [[nodiscard]] QVector<OpenSWMMVisLayer *> children() const;
 
    // ----- Scene item management -------------------------------------------
 
    virtual void populateScene(QGraphicsScene *scene,
                               const MapExtent &canvasExtent,
                               const SpatialReferenceSystem *canvasSRS) = 0;
 
    virtual void depopulateScene(QGraphicsScene *scene);
 
    virtual void refreshScene(QGraphicsScene *scene,
                              const MapExtent &canvasExtent,
                              const SpatialReferenceSystem *canvasSRS);
 
    [[nodiscard]] double layerZValue() const;
 
    [[nodiscard]] virtual std::vector<std::unique_ptr<openswmmvis::ui::ILayerStyleSubject>>
        styleSubjects();
 
    void setLayerZValue(double z);
 
    virtual void onCanvasCRSChanged(const SpatialReferenceSystem *newCanvasSRS);
 
    // ----- Renderer plumbing (default: layer has no renderer) -------------
    //
    // Most layer kinds (basemaps, GIS rasters) don't own a per-layer
    // IFeatureRenderer. Subclasses that do (SWMMModelLayer,
    // SWMM2DMeshLayer) override these. stylefileio.cpp consults the
    // virtual surface so it stays layer-agnostic.
    [[nodiscard]] virtual OpenSWMM::Render::IFeatureRenderer *renderer() const { return nullptr; }
    // NOTE: body is out-of-line in openswmmvislayer.cpp. Destroying the
    // by-value unique_ptr param requires IFeatureRenderer to be a complete
    // type; MSVC instantiates that deleter in the callee, so an inline body
    // here would fail with C2027 ("use of undefined type") wherever this
    // header is included without ifeaturerenderer.h.
    virtual void setRenderer(std::unique_ptr<OpenSWMM::Render::IFeatureRenderer>);
 
    // ----- Rule Model (Phase B seam, Slice B.1) ---------------------------
    //
    // The Rule Model (RENDERING_RULE_MODEL_PLAN.md) is the user-facing
    // styling surface. A layer opts in by returning a non-null RuleList;
    // LayerStyleDialog detects this in a subsequent slice (B.2) and
    // mounts the Active Rule combo + Rule List in the Symbology tab.
    //
    // Default returns nullptr — every existing layer continues to use
    // the legacy styleSubjects() path unchanged. Subclasses migrate
    // one at a time (Slices B.3 → B.4 → B.5).
    [[nodiscard]] virtual OpenSWMM::Render::RuleList *ruleList() { return nullptr; }
    [[nodiscard]] virtual const OpenSWMM::Render::RuleList *ruleList() const { return nullptr; }
 
    // ----- Temporal animation (Slice Z.13-attach) -------------------------
    //
    // Per-layer animation config. Defaults to `enabled=false` so every
    // existing layer keeps painting at a static reference time and the
    // legacy status-bar animation toolbar continues to drive the canvas
    // unchanged. Layers opt in by writing a TemporalSpec via setTemporalSpec
    // (e.g. SWMMResultsLayer auto-enables on Single mode with the file's
    // full time range; vector layers leave it disabled until the user
    // assigns a datetime field through the Temporal tab).
    [[nodiscard]] const OpenSWMM::Render::TemporalSpec &temporalSpec() const
    { return m_temporalSpec; }
    void setTemporalSpec(const OpenSWMM::Render::TemporalSpec &spec);
 
    // ----- Optional labels (VS.10) ----------------------------------------
    //
    // Uniform, optional element labelling for every layer kind. Default
    // disabled (LabelConfig::enabled == false). Feature-bearing layers paint
    // labels per this config; subclasses that need extra bookkeeping on
    // change (e.g. SWMMModelLayer syncing its legacy m_showLabels flag)
    // override setLabelConfig() and chain to the base. Results / 2D layers
    // inherit the storage so the Labels tab applies to them too.
    [[nodiscard]] const OpenSWMM::Render::LabelConfig &labelConfig() const
    { return m_labelConfig; }
    virtual void setLabelConfig(const OpenSWMM::Render::LabelConfig &cfg);
 
    // ----- Polygon clip mask (Slice Z.14-attach) --------------------------
    //
    // Optional clip-by-polygon mask. Default-disabled, so every existing
    // layer keeps painting unmasked. Z.14-paint integration consumes the
    // spec at paint time; the data model + tab UI ship in the matching
    // slices.
    [[nodiscard]] const OpenSWMM::Render::MaskSpec &maskSpec() const
    { return m_maskSpec; }
    void setMaskSpec(const OpenSWMM::Render::MaskSpec &spec);
 
    // ----- Auxiliary storage (Slice Z.15-attach) --------------------------
    //
    // Per-feature manual style overrides persisted to a sidecar SQLite
    // DB. The spec is tiny — toggle + DB path; the override rows live
    // in the DB itself, managed by the Auxiliary Storage tab UI and
    // applied at paint time by Z.15-paint (separate slice).
    [[nodiscard]] const OpenSWMM::Render::AuxiliaryStorageSpec &
        auxStorageSpec() const { return m_auxStorageSpec; }
    void setAuxStorageSpec(const OpenSWMM::Render::AuxiliaryStorageSpec &spec);
 
    // ----- External-table joins (Slice Z.16-attach) -----------------------
    //
    // A layer may carry zero or more joins. The list is the unit of
    // change — replace the whole list to mutate. Z.16-paint integration
    // walks this list at attribute-access time, lazily building the
    // joined columns from each enabled JoinSpec's source.
    [[nodiscard]] const QVector<OpenSWMM::Render::JoinSpec> &joins() const
    { return m_joins; }
    void setJoins(const QVector<OpenSWMM::Render::JoinSpec> &joins);
 
    // ----- Embedded chart diagram (Slice Z.12-attach) ---------------------
    //
    // One DiagramSpec per layer — pie / bar / histogram / time-series
    // chart painted at each feature's anchor point. Default disabled;
    // the Z.12-paint follow-up consumes the spec at paint time.
    [[nodiscard]] const OpenSWMM::Render::DiagramSpec &diagramSpec() const
    { return m_diagramSpec; }
    void setDiagramSpec(const OpenSWMM::Render::DiagramSpec &spec);
 
    // ----- Workspace accessor ---------------------------------------------
    //
    // Returns the workspace that owns this layer (or its session). Used
    // by features that need to resolve sibling layers — e.g. Z.14-paint's
    // mask resolver, which looks up the polygon source layer by id.
    // May return nullptr for layers constructed without a workspace
    // (typically only in tests).
    [[nodiscard]] OpenSWMMVisWorkspace *workspace() const { return mParent; }
 
    // ----- HTTP authentication & headers ----------------------------------
 
    void setBasicAuth(const QString &username, const QString &password);
 
    void setHttpHeaders(const BasemapHttpHeaders &headers);
    [[nodiscard]] BasemapHttpHeaders httpHeaders() const { return m_httpHeaders; }
 
signals:
 
    void nameChanged(const QString &newName);
    void layerTypeChanged(OpenSWMMVisLayerType newType);
    void visibilityChanged(bool visible);
    void opacityChanged(double opacity);
    void srsChanged(SpatialReferenceSystem *newSRS);
    void extentChanged(const MapExtent &newExtent);
    void childrenChanged();
    void repaintRequested();
    void temporalSpecChanged(const OpenSWMM::Render::TemporalSpec &spec);
    void maskSpecChanged(const OpenSWMM::Render::MaskSpec &spec);
    void auxStorageSpecChanged(const OpenSWMM::Render::AuxiliaryStorageSpec &spec);
    void joinsChanged(const QVector<OpenSWMM::Render::JoinSpec> &joins);
    void diagramSpecChanged(const OpenSWMM::Render::DiagramSpec &spec);
    void labelConfigChanged();
 
protected:
 
    bool addChild(OpenSWMMVisLayer *child);
    bool removeChild(OpenSWMMVisLayer *child);
    void setLayerType(OpenSWMMVisLayerType type);
 
    QByteArray         m_authHeader;   
    BasemapHttpHeaders m_httpHeaders;  
 
private:
    QString              m_layerId;
    OpenSWMMVisWorkspace      *mParent      = nullptr;
    QString              mName;
    QVector<OpenSWMMVisLayer*> mChildren;
    OpenSWMMVisLayerType     mLayerType   = SWMMDefaultLayer;
    bool                 m_visible    = true;
    double               m_opacity    = 1.0;
    SpatialReferenceSystem *m_srs     = nullptr;
    bool                 m_ownsSRS    = false;
    MapExtent            m_extent;
    double               m_layerZValue = 0.0;
    int                  m_vpW         = 0;   
    int                  m_vpH         = 0;   
    // Slice Z.13-attach — per-layer animation config (default disabled).
    OpenSWMM::Render::TemporalSpec m_temporalSpec;
    // VS.10 — per-layer label configuration (default disabled).
    OpenSWMM::Render::LabelConfig  m_labelConfig;
    // Slice Z.14-attach — per-layer clip mask (default disabled).
    OpenSWMM::Render::MaskSpec     m_maskSpec;
    // Slice Z.15-attach — per-layer manual-overrides DB (default disabled).
    OpenSWMM::Render::AuxiliaryStorageSpec m_auxStorageSpec;
    // Slice Z.16-attach — per-layer external-table joins (default empty).
    QVector<OpenSWMM::Render::JoinSpec>    m_joins;
    // Slice Z.12-attach — per-feature embedded chart (default disabled).
    OpenSWMM::Render::DiagramSpec          m_diagramSpec;
};
 
Q_DECLARE_METATYPE(OpenSWMMVisLayer *)
Q_DECLARE_METATYPE(QVector<OpenSWMMVisLayer *>)
 
#endif // SWMMLAYER_H