elementdata.h

Go to the documentation of this file.

/*
                Copyright 2006-2026 The QElectroTech Team
                This file is part of QElectroTech.
 
                QElectroTech is free software: you can redistribute it and/or modify
                it under the terms of the GNU General Public License as published by
                the Free Software Foundation, either version 2 of the License, or
                (at your option) any later version.
 
                QElectroTech is distributed in the hope that it will be useful,
                but WITHOUT ANY WARRANTY; without even the implied warranty of
                MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                GNU General Public License for more details.
 
                You should have received a copy of the GNU General Public License
                along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef ELEMENTDATA_H
#define ELEMENTDATA_H
 
#include "propertiesinterface.h"
#include "../diagramcontext.h"
#include "../NameList/nameslist.h"
 
#include <QStringList>
#include <QVector>
#include <QFont>

class ElementData : public PropertiesInterface
{
                Q_GADGET
 
        public:
                enum Type {
                        Simple         = 1,
                        NextReport     = 2,
                        PreviousReport = 4,
                        AllReport      = 6,
                        Master         = 8,
                        Slave          = 16,
                        Terminal       = 32,
                        Thumbnail      = 64,
                        ConductorDefinition = 128};
                Q_ENUM(Type)
                Q_DECLARE_FLAGS(Types, Type)
 
                enum MasterType {
                        Coil,
                        Protection,
                        Commutator,
                        PLC
                };
                Q_ENUM(MasterType)
 
                enum SlaveType {
                        SSimple,
                        Power,
                        DelayOn,
                        DelayOff,
                        delayOnOff,
                        PLCSlave
                };
                Q_ENUM(SlaveType)
 
                enum SlaveState {
                        NO,
                        NC,
                        SW,
                        Other
                };
                Q_ENUM(SlaveState)
 
                enum PlcIOType {
                        EntreeDigitale,
                        SortieDigitale,
                        EntreeAnalogique,
                        SortieAnalogique,
                        EntreeUniverselle,
                        SortieUniverselle
                };
                Q_ENUM(PlcIOType)
 
                
                struct PlcIO {
                        PlcIOType type = EntreeDigitale;
                        QString address;          
                        QString functionText;     
                        QString comment;          
                        QString crossRef;         
                        int terminalCount = 1;    
                        QStringList terminals;    

                        QStringList effectiveTerminals() const {
                                if (!terminals.isEmpty())
                                        return terminals;
                                int count = qMax(terminalCount, 1);
                                QStringList defaults;
                                for (int i = 0; i < count && i < 4; ++i)
                                        defaults << QStringLiteral("T%1").arg(i + 1);
                                return defaults;
                        }
 
                        bool operator==(const PlcIO &other) const {
                                return type == other.type
                                        && address == other.address
                                        && functionText == other.functionText
                                        && comment == other.comment
                                        && crossRef == other.crossRef
                                        && terminalCount == other.terminalCount
                                        && terminals == other.terminals;
                        }
                        bool operator!=(const PlcIO &other) const {
                                return !(*this == other);
                        }
                };

                struct PlcMasterData {
                        QVector<PlcIO> ios;                     
                        QList<int> breakPositions;              
                        QMap<int, qreal> colWidths;             
                        qreal rowHeight = 8.0;                  
                        QMap<int, bool> colVisible;             
                        QFont headerFont;                       
                        QFont cellFont;                         
                        QStringList columnNames;                
                        QList<int> columnOrder;                 
                        bool showHeaders = true;                
 
                        PlcMasterData() {
                                headerFont.setFamily(QString());
                                cellFont.setFamily(QString());
                        }
 
                        bool operator==(const PlcMasterData &other) const {
                                return ios == other.ios
                                        && breakPositions == other.breakPositions
                                        && colWidths == other.colWidths
                                        && qFuzzyCompare(rowHeight, other.rowHeight)
                                        && colVisible == other.colVisible
                                        && headerFont == other.headerFont
                                        && cellFont == other.cellFont
                                        && columnNames == other.columnNames
                                        && columnOrder == other.columnOrder
                                        && showHeaders == other.showHeaders;
                        }
                        bool operator!=(const PlcMasterData &other) const {
                                return !(*this == other);
                        }
                };
 
                static QString plcIOTypeToString(PlcIOType type);
                static PlcIOType plcIOTypeFromString(const QString &string);
                static QString translatedPlcIOType(PlcIOType type);
                static QStringList plcIOTypeList();
 
                enum TerminalType {
                        TTGeneric,
                        TTFuse,
                        TTSectional,
                        TTDiode,
                        TTGround
                };
                Q_ENUM(TerminalType)
 
                enum TerminalFunction {
                        TFGeneric,
                        TFPhase,
                        TFNeutral,
                };
                Q_ENUM(TerminalFunction)
 
                
                struct SlaveContactGroup {
                        SlaveState  type        = NO;      
                        SlaveType   subtype     = SSimple;  
                        int         contactCount  = 1;      
                        int         terminalCount = 1;      
                        QStringList labels;                 
 
                        bool operator==(const SlaveContactGroup &other) const {
                                return type == other.type
                                        && subtype == other.subtype
                                        && contactCount == other.contactCount
                                        && terminalCount == other.terminalCount
                                        && labels == other.labels;
                        }
                        bool operator!=(const SlaveContactGroup &other) const {
                                return !(*this == other);
                        }
                };
 
                ElementData() {}
                ~ElementData() override {}
 
                void toSettings(QSettings &settings, const QString prefix = QString()) const override;
                void fromSettings(const QSettings &settings,  const QString prefix = QString()) override;
                QDomElement toXml(QDomDocument &xml_element) const override;
                bool fromXml(const QDomElement &xml_element) override;
                QDomElement kindInfoToXml(QDomDocument &document);
        QDomElement plcMasterDataToXml(QDomDocument &document) const;
        void plcMasterDataFromXml(const QDomElement &xml_plc);
 
                void setTerminalType(ElementData::TerminalType t_type);
                ElementData::TerminalType terminalType() const;
 
                void setTerminalFunction(ElementData::TerminalFunction t_function);
                ElementData::TerminalFunction terminalFunction() const;
 
                void setTerminalLED(bool led);
                bool terminalLed() const;
                bool terminalPropertiesIsOverrided() const;
 
                bool operator==(const ElementData &data) const;
                bool operator!=(const ElementData &data) const;
 
                QString typeToString() const;
                static QString typeToString(ElementData::Type type);
                static ElementData::Type typeFromString(const QString &string);
 
                QString masterTypeToString() const;
                static QString masterTypeToString(ElementData::MasterType type);
                static ElementData::MasterType masterTypeFromString(const QString &string);
 
                static QString slaveTypeToString (ElementData::SlaveType type);
                static ElementData::SlaveType slaveTypeFromString(const QString &string);
 
                static QString slaveStateToString(ElementData::SlaveState type);
                static ElementData::SlaveState slaveStateFromString(const QString &string);
 
                static QString terminalTypeToString(ElementData::TerminalType type);
                static ElementData::TerminalType terminalTypeFromString(const QString &string);
                static QString translatedTerminalType(ElementData::TerminalType type);
 
                static QString terminalFunctionToString(ElementData::TerminalFunction function);
                static ElementData::TerminalFunction terminalFunctionFromString(const QString &string);
                static QString translatedTerminalFunction(ElementData::TerminalFunction function);
 
                static QString slaveContactGroupTypeToString(ElementData::SlaveState type);
                static ElementData::SlaveState slaveContactGroupTypeFromString(const QString &string);
                static QString slaveContactGroupSubtypeToString(ElementData::SlaveType type);
                static ElementData::SlaveType slaveContactGroupSubtypeFromString(const QString &string);
 
                PlcMasterData plcMasterData() const { return m_plc_master_data; }
                void setPlcMasterData(const PlcMasterData &data) { m_plc_master_data = data; }
 
                // must be public, because this class is a private member
                // of Element/ element editor and they must access this data
                ElementData::Type       m_type = ElementData::Simple;
 
                ElementData::MasterType m_master_type = ElementData::Coil;
                int m_max_slaves{-1};
                bool m_slave_contact_groups_enabled{false};  
                QVector<SlaveContactGroup> m_slave_contact_groups;  
                PlcMasterData m_plc_master_data;              
 
                ElementData::SlaveType  m_slave_type  = ElementData::SSimple;
                ElementData::SlaveState m_slave_state = ElementData::NO;
 
                ElementData::TerminalType     m_terminal_type     = ElementData::TTGeneric;
                ElementData::TerminalFunction m_terminal_function = ElementData::TFGeneric;
 
                int m_contact_count{1};
                DiagramContext m_informations;
                NamesList m_names_list;
                QString m_drawing_information;
 
        private:
                ElementData::TerminalType m_override_terminal_type = ElementData::TTGeneric;
                bool m_terminal_type_is_override = false;
 
                ElementData::TerminalFunction m_override_terminal_function = ElementData::TFGeneric;
                bool m_terminal_function_is_override = false;
 
                bool m_terminal_led = false;
                bool m_terminal_led_is_override = false;
                bool m_override_terminal_led = false;
 
        private:
                void kindInfoFromXml(const QDomElement &xml_element);
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(ElementData::Types)
 
#endif // ELEMENTDATA_H