QeLedArray.hpp

#ifndef QELEDARRAY_H
#define QELEDARRAY_H
 
#include <QWidget>
#include <QColor>
#include <QList>
#include <QGridLayout>
#include <elt/cut/widgets/widgets/QeLed.hpp>
#include <QMap>
#include <optional>
#include <QStringList>
#include <QLabel>
#include <vector>

class QeLedArray : public QWidget
{
    Q_OBJECT

    Q_PROPERTY(bool vertical READ IsVertical WRITE SetVertical NOTIFY OrderChanged)
 
    
    Q_PROPERTY(bool labels_visible READ AreLabelsVisible WRITE SetLabelsVisibility NOTIFY LabelsVisibilityChanged)

    Q_PROPERTY(int leds_count READ GetLedsCount WRITE SetLedsCount NOTIFY LedsCountChanged)

    Q_PROPERTY(QStringList states READ GetStates WRITE SetStates NOTIFY StatesChanged)

    Q_PROPERTY(QList<QString> labels READ GetLabels WRITE SetLabels NOTIFY LabelsChanged)

    Q_PROPERTY(QStringList signal_types READ GetSignalTypes WRITE SetSignalTypes NOTIFY SignalTypesChanged)
 
 
public:
    enum class SignalType {NONE, WARNING, CRITICAL, INFO};
    Q_ENUM(SignalType);
 
    explicit QeLedArray(QWidget* parent = nullptr);
    explicit QeLedArray(int led_count, QWidget* parent = nullptr);
    explicit QeLedArray(const QList<QString>& labels, const QList<SignalType>& signal_roles, QWidget* parent = nullptr);
    ~QeLedArray(){};
 
 
 
    bool IsVertical(){ return m_vertical; }
    bool AreLabelsVisible(){ return m_labels_visible; }
    int GetLedsCount(){ return m_leds_count; }
    QStringList GetStates() const { return m_states; }
    std::vector<bool> GetStatesBoolVector() const { return m_bool_states_vector; }
    QList<QString> GetLabels(){ return m_labels; }
    QStringList GetSignalTypes(){ return m_signal_types; }
    QList<SignalType> GetSignalTypesEnumList() { return m_signal_types_list; };
 
    void SetLedType(QeLed* led, SignalType type);

    void SetToolTips(QList<QString> tooltips);

    void SetSignalTypes(const QList<SignalType> &signal_types);

    void SetLabel(int index, QString label_text);

    void SetState(int index, bool state);

    void SetSignalType(int index, SignalType signal_type);
 
 
public slots:
    void SetVertical(bool new_value) {
        if(new_value == this->m_vertical)
            return;
 
        this->m_vertical = new_value;
        RebuildArray();
 
        emit OrderChanged(new_value);
    }
 
    void SetLabelsVisibility(bool new_value) {
        if(new_value == this->m_labels_visible)
            return;
 
        this->m_labels_visible = new_value;
        this->ChangeLabelsVisibility(this->m_labels_visible);
        emit LabelsVisibilityChanged(new_value);
    }
 
    void SetLedsCount(int new_value){
        if(new_value == this->m_leds_count)
            return;
 
        this->m_leds_count = new_value;
 
        if(layout())
        {
            for(QeLed *led : m_leds_list){
                m_layout->removeWidget(led);
                led->deleteLater();
            }
        }
 
        m_leds_list.clear();
 
        this->RebuildArray();
        emit LedsCountChanged(new_value);
 
    }
 
    void SetStates(const QStringList &states);
 
    void SetStates(int int_value);
 
    void SetStates(std::vector<bool> bool_states_list);
 
    void SetLabels(QList<QString> labels);

    void SetSignalTypes(const QStringList &signal_types);
 
 
 
signals:
    void OrderChanged(bool new_value);
 

    void LabelsVisibilityChanged(bool new_value);

    void LedsCountChanged(int new_value);

    void StatesChanged(QStringList new_value);

    void LabelsChanged(QList<QString> labels);

    void SignalTypesChanged(QStringList new_values);
 
 
private:    
    void CreateLayout();

    void AddToLayout(QeLed *led, QLabel *label, int index);

    void InitLedColorsMap();
    void Init(std::optional<const QList<QString>> labels = std::nullopt,
              std::optional<const QList<SignalType>> signal_roles = std::nullopt);
 
    static std::vector<bool> IntToBits(int value, int num_bits);
    void RebuildArray();
    void ChangeLabelsVisibility(bool is_visible);

    bool Value(const std::vector<bool> &vec, size_t index, bool default_value = false);
 
 
    bool m_vertical = false;
    bool m_labels_visible = true;
    int m_leds_count = 4;
    QList<QString> m_labels;
    QList<QLabel*> m_labels_list;
 
    QList<QeLed*> m_leds_list;
    QGridLayout* m_layout = nullptr;
 
    QStringList m_states;
    std::vector<bool> m_bool_states_vector;
 
    QStringList m_signal_types;
    QList<SignalType> m_signal_types_list;
 
    QColor warning_color = QColor(255,165,0);
    QColor critical_color = QColor(255,0,0);
    QColor info_color = QColor(0,0,255);
    QColor none_color = QColor(169,169,169);
 
    using OnOffMap = QMap<QString, QColor>;
    using LedColorMap = QMap<SignalType, OnOffMap>;
    LedColorMap m_led_color_map;
 
 
 
};
 
#endif // QELEDARRAY_H