isublayerhost.h

Go to the documentation of this file.

 
#ifndef OPENSWMM_RENDER_ISUBLAYERHOST_H
#define OPENSWMM_RENDER_ISUBLAYERHOST_H
 
#include "render/isublayer.h"
#include "render/sublayerstyle.h"
 
#include <QHash>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonValue>
#include <QList>
#include <QString>
 
namespace OpenSWMM::Render
{
 
class ISublayerHost
{
public:
    virtual ~ISublayerHost() = default;
 
    [[nodiscard]] virtual QList<ISublayer *> sublayers() const = 0;
 
    virtual bool moveSublayer(int from, int to)
    {
        Q_UNUSED(from);
        Q_UNUSED(to);
        return false;
    }
 
    virtual void dispatchAnimationTick(int period)
    {
        Q_UNUSED(period);
        for (ISublayer *s : sublayers())
        {
            if (s && s->isDynamic())
                s->invalidate();
        }
    }
 
    virtual void onSublayersJsonLoaded(const QJsonObject &sublayersJson)
    {
        Q_UNUSED(sublayersJson);
    }
 
    // ── Slice S6.1 — JSON persistence helpers ──────────────────────────
    //
    // Layers call these at their `.oswp` save/load points to round-trip
    // every sublayer's visibility / opacity / style bag. Schema:
    //
    //   {
    //     "sublayers": [
    //       { "id": "...", "visible": true, "opacity": 1.0,
    //         "style": { ... per-sublayer style JSON ... } },
    //       ...
    //     ]
    //   }
    //
    // Free static functions because the host interface is non-QObject
    // and we want them callable from layer save/load without
    // instantiating anything. Forward-compatible: unknown sublayer ids
    // in the JSON are silently skipped (the layer ships with whatever
    // sublayers it constructed in its ctor).
 
    [[nodiscard]] static QJsonObject saveSublayersToJson(const ISublayerHost &host)
    {
        QJsonArray arr;
        for (const ISublayer *s : host.sublayers())
        {
            if (!s) continue;
            QJsonObject row;
            row.insert(QStringLiteral("id"),      s->id());
            row.insert(QStringLiteral("visible"), s->isVisible());
            row.insert(QStringLiteral("opacity"), s->opacity());
            if (auto *style = const_cast<ISublayer *>(s)->style())
                row.insert(QStringLiteral("style"), style->toJson());
            arr.append(row);
        }
        QJsonObject obj;
        obj.insert(QStringLiteral("sublayers"), arr);
        return obj;
    }
 
    [[nodiscard]] static QList<LegendSymbolItem>
        aggregatedLegendSymbolItems(const ISublayerHost &host)
    {
        QList<LegendSymbolItem> out;
        for (const ISublayer *s : host.sublayers())
        {
            if (!s || !s->isVisible()) continue;
            out.append(s->legendSymbolItems());
        }
        return out;
    }
 
    [[nodiscard]] static ISublayer *
        findSublayer(const ISublayerHost &host, const QString &id)
    {
        for (ISublayer *s : host.sublayers())
            if (s && s->id() == id) return s;
        return nullptr;
    }
 
    static void loadSublayersFromJson(ISublayerHost &host, const QJsonObject &j)
    {
        const QJsonArray arr = j.value(QStringLiteral("sublayers")).toArray();
        // Index host's current sublayers by id so we can apply rows out of order
        // and tolerate added/removed sublayers between schema versions.
        QHash<QString, ISublayer *> byId;
        for (ISublayer *s : host.sublayers())
            if (s) byId.insert(s->id(), s);
 
        for (const QJsonValue &val : arr)
        {
            const QJsonObject row = val.toObject();
            const QString id = row.value(QStringLiteral("id")).toString();
            auto it = byId.constFind(id);
            if (it == byId.constEnd()) continue; // unknown sublayer id — skip
 
            ISublayer *s = it.value();
            if (row.contains(QStringLiteral("visible")))
                s->setVisible(row.value(QStringLiteral("visible")).toBool());
            if (row.contains(QStringLiteral("opacity")))
                s->setOpacity(row.value(QStringLiteral("opacity")).toDouble());
            if (row.contains(QStringLiteral("style")))
                if (auto *style = s->style())
                    style->fromJson(row.value(QStringLiteral("style")).toObject());
        }
 
        // Replay the saved paint order — JSON array index 0 = bottom of
        // the paint stack.  For each known id, ensure it ends up at the
        // intended target index by calling moveSublayer().  Hosts that
        // don't implement reorder return false and the order silently
        // stays as constructed.
        int target = 0;
        for (const QJsonValue &val : arr)
        {
            const QString id = val.toObject()
                                  .value(QStringLiteral("id")).toString();
            const auto cur = host.sublayers();
            int found = -1;
            for (int i = 0; i < cur.size(); ++i)
                if (cur[i] && cur[i]->id() == id) { found = i; break; }
            if (found < 0) continue;          // not in this host — skip silently
            if (found != target)
                host.moveSublayer(found, target);
            ++target;
        }
 
        // Give the host a chance to migrate style data that moved between
        // sublayers across schema versions (see onSublayersJsonLoaded).
        host.onSublayersJsonLoaded(j);
    }
};
 
} // namespace OpenSWMM::Render
 
#endif // OPENSWMM_RENDER_ISUBLAYERHOST_H