Common.h

Go to the documentation of this file.

#pragma once
 
#include "Fact.h"
 
#include <QtCore/QString>
#include <QtCore/QJsonValue>
#include <QtGui/QVector3D>
 
class ParameterManager;
 
struct Parameter {
    enum class DisplayOption {
        Default,
        BoolTrueIfPositive, 
        Bitset,             
    };
 
    QString label{};
    QString name{};                                       
    int indexOffset{};                                    
    DisplayOption displayOption{DisplayOption::Default};
    bool advanced{false};                                 
 
    void parse(const QJsonValue& jsonValue);
};
 
class FactBitset : public Fact
{
    Q_OBJECT
public:
    FactBitset(QObject* parent, Fact* integerFact, int offset);
 
    virtual ~FactBitset() = default;
 
private slots:
    void onIntegerFactChanged();
    void onThisFactChanged();
private:
    Fact* _integerFact{nullptr};
    const int _offset;
    bool _ignoreChange{false};
};
 
class FactFloatAsBool : public Fact
{
    Q_OBJECT
public:
    FactFloatAsBool(QObject* parent, Fact* floatFact);
 
    virtual ~FactFloatAsBool() = default;
 
private slots:
    void onFloatFactChanged();
    void onThisFactChanged();
private:
    Fact* _floatFact{nullptr};
    bool _ignoreChange{false};
};
 
class Condition
{
public:
    enum class Operation {
        AlwaysTrue,
        AlwaysFalse,
        GreaterThan,  // >
        GreaterEqual, // >=
        Equal,        // ==
        NotEqual,     // !=
        LessThan,     // <
        LessEqual     // <=
    };
 
    Condition() = default;
 
    Condition(const QString& condition, ParameterManager* parameterManager, const QString& label = QString());
 
    bool evaluate() const;
 
    bool hasCondition() const { return _operation != Operation::AlwaysTrue; }
 
    Fact* fact() const { return _fact; }
 
private:
    QString _parameter{};
    QString _label{};
    QString _alwaysTrueReason{QStringLiteral("empty/default")};
    Operation _operation{Operation::AlwaysTrue};
    int32_t _value{0};
    Fact* _fact{nullptr};
};
 
 
struct ActuatorGeometry
{
    enum class Type {
        Motor,
        Servo,
        Other
    };
 
    enum class SpinDirection {
        Unspecified,
        ClockWise,
        CounterClockWise,
    };
 
    static Type typeFromStr(const QString& type);
 
    struct RenderOptions {
        bool highlight{false};
    };
 
    ActuatorGeometry(Type type_=Type::Other, int index_=0, QVector3D position_={},
            SpinDirection spinDirection_=SpinDirection::Unspecified)
    : type(type_), index(index_), position(position_), spinDirection(spinDirection_) { }
 
    Type type;
    int index;
    int labelIndexOffset{0};
    QVector3D position;
    SpinDirection spinDirection;
 
    RenderOptions renderOptions{};
};