ActuatorOutputs.h

Go to the documentation of this file.

#pragma once
 
#include "Common.h"
#include "ActuatorActions.h"
#include "QmlObjectListModel.h"
 
#include <QtCore/QObject>
#include <QtCore/QString>
 
#include <functional>
 
namespace ActuatorOutputs {
 
class ConfigParameter : public QObject
{
    Q_OBJECT
public:
    enum class Function {
        Unspecified = 0,
        Enable,             
        Primary,            
    };
 
    ConfigParameter(QObject* parent, Fact* fact, const QString& label, Function function)
        : QObject(parent), _fact(fact), _label(label), _function(function) {}
 
    Q_PROPERTY(QString label          READ label       CONSTANT)
    Q_PROPERTY(Fact* fact             READ fact        CONSTANT)
 
    const QString& label() const { return _label; }
    Fact* fact() { return _fact; }
    Function function() const { return _function; }
 
private:
    Fact* _fact{nullptr};
    const QString _label;
    const Function _function;
};
 
class ChannelConfig : public QObject
{
    Q_OBJECT
public:
 
    enum class Function {
        Unspecified = 0,
        OutputFunction,
        Disarmed,
        Minimum,
        Maximum,
        Failsafe
    };
 
    ChannelConfig(QObject* parent, const Parameter& param, Function function,
            const Condition& visibilityCondition)
        : QObject(parent), _parameter(param), _function(function), _visibilityCondition(visibilityCondition) {}
 
    Q_PROPERTY(QString label      READ label      CONSTANT)
    Q_PROPERTY(bool advanced      READ advanced   CONSTANT)
    Q_PROPERTY(bool visible       READ visible    NOTIFY visibleChanged)
 
    const QString& label() const { return _parameter.label; }
    const QString& parameter() const { return _parameter.name; }
    Function function() const { return _function; }
    const Condition& visibilityCondition() const { return _visibilityCondition; }
    bool advanced() const { return _parameter.advanced; }
    bool visible() const { return _visibilityCondition.evaluate(); }
 
    Parameter::DisplayOption displayOption() const { return _parameter.displayOption; }
    int indexOffset() const { return _parameter.indexOffset; }
 
    void reevaluate();
 
signals:
    void visibleChanged();
private:
    const Parameter _parameter;
    const Function _function;
    const Condition _visibilityCondition;
};
 
class ChannelConfigInstance : public QObject
{
    Q_OBJECT
public:
    ChannelConfigInstance(QObject* parent, Fact* fact, ChannelConfig& config)
        : QObject(parent), _fact(fact), _config(config) {}
 
    Q_PROPERTY(ChannelConfig* config      READ channelConfig   CONSTANT)
    Q_PROPERTY(Fact* fact                 READ fact            CONSTANT)
 
    Fact* fact() { return _fact; }
 
    ChannelConfig* channelConfig() const { return &_config; }
 
private:
 
    Fact* _fact{nullptr};
    ChannelConfig& _config;
};
 
class ActuatorOutputChannel : public QObject
{
    Q_OBJECT
public:
    ActuatorOutputChannel(QObject* parent, const QString& label, int paramIndex, QmlObjectListModel& channelConfigs,
            ParameterManager* parameterManager, std::function<void(Fact*)> factAddedCb);
 
    Q_PROPERTY(QString label                            READ label               CONSTANT)
    Q_PROPERTY(QmlObjectListModel* configInstances      READ configInstances     NOTIFY configInstancesChanged)
 
    const QString& label() const { return _label; }
 
    QmlObjectListModel* configInstances() { return _configInstances; }
 
signals:
    void configInstancesChanged();
 
private:
    const QString _label;
    const int _paramIndex{};
 
    QmlObjectListModel* _configInstances = new QmlObjectListModel(this); 
};
 
class ActuatorOutputSubgroup : public QObject
{
    Q_OBJECT
public:
    ActuatorOutputSubgroup(QObject* parent, const QString& label)
        : QObject(parent), _label(label) {}
 
    Q_PROPERTY(QString label                        READ label            CONSTANT)
    Q_PROPERTY(QmlObjectListModel* channels         READ channels         NOTIFY channelsChanged)
    Q_PROPERTY(QmlObjectListModel* channelConfigs   READ channelConfigs   NOTIFY channelConfigsChanged)
    Q_PROPERTY(ConfigParameter* primaryParam        READ primaryParam     CONSTANT)
    Q_PROPERTY(QmlObjectListModel* configParams     READ configParams     CONSTANT)
 
    const QString& label() const { return _label; }
 
    // per-channel-params
    QmlObjectListModel* channelConfigs() { return _channelConfigs; }
    void addChannelConfig(ChannelConfig* channelConfig);
 
 
    QmlObjectListModel* channels() { return _channels; }
    void addChannel(ActuatorOutputChannel* channel);
 
    ConfigParameter* primaryParam() const { return _primaryParam; }
    void addConfigParam(ConfigParameter* param);
    QmlObjectListModel* configParams() { return _params; }
 
    const QList<ActuatorActions::Config>& actions() const { return _actions; }
    void addAction(const ActuatorActions::Config& action) { _actions.append(action); }
 
signals:
    void channelsChanged();
    void channelConfigsChanged();
private:
 
    const QString _label;
    QmlObjectListModel* _channels = new QmlObjectListModel(this); 
    QmlObjectListModel* _channelConfigs = new QmlObjectListModel(this); 
 
    ConfigParameter* _primaryParam{nullptr};
    QmlObjectListModel* _params  = new QmlObjectListModel(this); 
 
    QList<ActuatorActions::Config> _actions;
};
 
class ActuatorOutput : public QObject
{
    Q_OBJECT
public:
    ActuatorOutput(QObject* parent, const QString& label, const Condition& groupVisibilityCondition);
 
    Q_PROPERTY(QString label                     READ label              CONSTANT)
    Q_PROPERTY(bool groupsVisible                READ groupsVisible      NOTIFY groupsVisibleChanged)
    Q_PROPERTY(QmlObjectListModel* subgroups     READ subgroups          NOTIFY subgroupsChanged)
    Q_PROPERTY(ConfigParameter* enableParam      READ enableParam        CONSTANT)
    Q_PROPERTY(QmlObjectListModel* configParams  READ configParams       CONSTANT)
    Q_PROPERTY(QStringList notes                 READ notes              NOTIFY notesChanged)
 
    const QString& label() const { return _label; }
 
    QmlObjectListModel* subgroups() { return _subgroups; }
    bool groupsVisible() const { return _groupVisibilityCondition.evaluate(); }
    ConfigParameter* enableParam() const { return _enableParam; }
    QmlObjectListModel* configParams() { return _params; }
 
    void addSubgroup(ActuatorOutputSubgroup* subgroup);
 
    void addConfigParam(ConfigParameter* param);
 
    void getAllChannelFunctions(QList<Fact*>& allFunctions) const;
 
    bool hasExistingOutputFunctionParams() const;
 
    void addNote(const QString& note) { _notes.append(note); emit notesChanged(); }
    void clearNotes() { _notes.clear(); emit notesChanged(); }
    const QStringList& notes() const { return _notes; }
 
    void forEachOutputFunction(std::function<void(ActuatorOutputSubgroup*, ChannelConfigInstance*, Fact*)> callback) const;
 
signals:
    void subgroupsChanged();
    void groupsVisibleChanged();
    void notesChanged();
 
private:
    const QString _label;
    const Condition _groupVisibilityCondition;
    QmlObjectListModel* _subgroups = new QmlObjectListModel(this); 
 
    ConfigParameter* _enableParam{nullptr};
    QmlObjectListModel* _params  = new QmlObjectListModel(this); 
    QStringList _notes;
};
 
} // namespace ActuatorOutputs