rule.h

Go to the documentation of this file.

 
#ifndef OPENSWMM_RENDER_RULE_H
#define OPENSWMM_RENDER_RULE_H
 
#include "render/ifeaturerenderer.h"
 
#include <QJsonObject>
#include <QObject>
#include <QString>
 
#include <memory>
 
namespace OpenSWMM::Render
{
 
class Rule : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY ruleChanged)
    Q_PROPERTY(bool isVisible READ isVisible WRITE setVisible NOTIFY ruleChanged)
    Q_PROPERTY(QString filterExpression READ filterExpression WRITE setFilterExpression
                   NOTIFY ruleChanged)
    Q_PROPERTY(double minScale READ minScale WRITE setMinScale NOTIFY ruleChanged)
    Q_PROPERTY(double maxScale READ maxScale WRITE setMaxScale NOTIFY ruleChanged)
    Q_PROPERTY(QString blendMode READ blendMode WRITE setBlendMode NOTIFY ruleChanged)
    Q_PROPERTY(bool rebinPerFrame READ rebinPerFrame WRITE setRebinPerFrame
                   NOTIFY ruleChanged)
    Q_PROPERTY(bool symbolLevelsEnabled READ symbolLevelsEnabled
                   WRITE setSymbolLevelsEnabled NOTIFY ruleChanged)
 
public:
    explicit Rule(QObject *parent = nullptr);
    Rule(QString name,
         std::unique_ptr<IFeatureRenderer> renderer,
         QObject *parent = nullptr);
    ~Rule() override;
 
    // Non-copyable / non-movable: Rule has identity (signals, owned renderer).
    Rule(const Rule &) = delete;
    Rule &operator=(const Rule &) = delete;
    Rule(Rule &&) = delete;
    Rule &operator=(Rule &&) = delete;
 
    [[nodiscard]] QString name() const { return m_name; }
    void setName(const QString &name);
 
    [[nodiscard]] bool isVisible() const { return m_isVisible; }
    void setVisible(bool v);
 
    [[nodiscard]] QString filterExpression() const { return m_filterExpression; }
    void setFilterExpression(const QString &expr);
 
    [[nodiscard]] double minScale() const { return m_minScale; }
    void setMinScale(double s);
 
    [[nodiscard]] double maxScale() const { return m_maxScale; }
    void setMaxScale(double s);
 
    [[nodiscard]] QString blendMode() const { return m_blendMode; }
    void setBlendMode(const QString &m);
 
    [[nodiscard]] bool rebinPerFrame() const { return m_rebinPerFrame; }
    void setRebinPerFrame(bool v);
 
    [[nodiscard]] bool symbolLevelsEnabled() const { return m_symbolLevelsEnabled; }
    void setSymbolLevelsEnabled(bool v);
 
    [[nodiscard]] IFeatureRenderer *renderer() const { return m_renderer.get(); }
 
    void setRenderer(std::unique_ptr<IFeatureRenderer> r);
 
    bool setRendererById(const QString &id);
 
    void notifyRendererStateChanged();
 
    [[nodiscard]] QJsonObject toJson() const;
 
    [[nodiscard]] static std::unique_ptr<Rule> fromJson(const QJsonObject &j,
                                                        QObject *parent = nullptr);
 
    [[nodiscard]] std::unique_ptr<Rule> clone(QObject *parent = nullptr) const;
 
signals:
    void ruleChanged();          
    void rendererReplaced();     
private:
    QString                           m_name;
    bool                              m_isVisible = true;
    QString                           m_filterExpression;
    double                            m_minScale = 0.0;
    double                            m_maxScale = 0.0;
    QString                           m_blendMode = QStringLiteral("Normal");
    bool                              m_rebinPerFrame = false;
    bool                              m_symbolLevelsEnabled = false;
    std::unique_ptr<IFeatureRenderer> m_renderer;
};
 
} // namespace OpenSWMM::Render
 
#endif // OPENSWMM_RENDER_RULE_H