element.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 ELEMENT_H
#define ELEMENT_H
 
#include "../ElementsCollection/elementslocation.h"
#include "../NameList/nameslist.h"
#include "../autoNum/assignvariables.h"
#include "../diagramcontext.h"
#include "../qet.h"
#include "qetgraphicsitem.h"
#include "../properties/elementdata.h"
 
#include <QHash>
#include <QPicture>
#include <algorithm>
 
class QETProject;
class Terminal;
class Conductor;
class DynamicElementTextItem;
class ElementTextItemGroup;
class QUndoCommand;

class Element : public QetGraphicsItem
{
        friend class DiagramEventAddElement;
        friend class DynamicElementTextItem;
 
        Q_OBJECT
        public:
                enum kind {
            Simple = 1,
            NextReport = 2,
            PreviousReport = 4,
            AllReport = 6,
            Master = 8,
            Slave = 16,
            Terminale = 32,
            Thumbnail = 64,
            ConductorDefinition = 128};

                struct LinkInfo {
                        QUuid uuid;
                        int group_index = -1;  
 
                        LinkInfo() = default;
                        LinkInfo(const QUuid &u, int gi = -1) : uuid(u), group_index(gi) {}
                };
 
                Element(const ElementsLocation &location,
                        QGraphicsItem * = nullptr,
                        int *state = nullptr,
                        Element::kind link_type = Element::Simple);
                ~Element() override;
        private:
                Element(const Element &);
 
                // attributes
        public:
                enum { Type = UserType + 1000 };
                int type() const override { return Type; }
 
        signals:
                void linkedElementChanged(); //This signal is emitted when the linked elements with this element change
                void elementInfoChange(
                                DiagramContext old_info,
                                DiagramContext new_info);
                void textAdded(DynamicElementTextItem *deti);
                void textRemoved(DynamicElementTextItem *deti);
                void textsGroupAdded(ElementTextItemGroup *group);
                void textsGroupAboutToBeRemoved(ElementTextItemGroup *group);
                void textAddedToGroup(
                                DynamicElementTextItem *text,
                                ElementTextItemGroup *group);
                void textRemovedFromGroup(
                                DynamicElementTextItem *text,
                                ElementTextItemGroup *group);
 
        public slots:
                void updateConductorTexts();
 
        public:
                QList<Terminal *> terminals() const;
                QList<Conductor *> conductors() const;
                QList<QPair<Terminal *,Terminal *>> AlignedFreeTerminals() const;
 
                        //METHODS related to information
                DiagramContext elementInformations()const
                {return m_data.m_informations;}
                virtual void setElementInformations(DiagramContext dc);
 
                ElementData elementData() const;
                void setElementData (ElementData data);

                DiagramContext kindInformations() const
                {return m_kind_informations;}
                //@kind_information_ is used to store more information
                //about the herited class like contactelement for know
                // kind of contact (simple tempo) or number of contact show by the element.
 
                autonum::sequentialNumbers sequenceStruct() const
                {return m_autoNum_seq;}
                autonum::sequentialNumbers& rSequenceStruct()
                {return m_autoNum_seq;}
                void setUpFormula(bool code_letter = true, QUndoCommand *parent_undo = nullptr);
                void setPrefix(QString);
                QString getPrefix() const;
                void freezeLabel(bool freeze);
                bool isFreezeLabel() const {return m_freeze_label;}
                void freezeNewAddedElement();
                QString actualLabel();
 
                QString name() const override;
                ElementsLocation location() const;
                virtual void setHighlighted(bool);
                void displayHelpLine(bool b = true);
                QSize size() const;
                QPixmap pixmap();
                QPoint setHotspot(QPoint);
                QPoint hotspot() const;
                void editProperty() override;
                static bool valideXml(QDomElement &);
                virtual bool fromXml(
                                QDomElement &,
                                QHash<int,
                                Terminal *> &);
                virtual QDomElement toXml(
                                QDomDocument &,
                                QHash<Terminal *,
                                int> &) const;
                QUuid uuid() const;
                int orientation() const;
 
                        //METHODS related to texts
                void addDynamicTextItem(DynamicElementTextItem *deti = nullptr);
                void removeDynamicTextItem(DynamicElementTextItem *deti);
                QList<DynamicElementTextItem *> dynamicTextItems() const;
                ElementTextItemGroup *addTextGroup(const QString &name);
                void addTextGroup(ElementTextItemGroup *group);
                void removeTextGroup(ElementTextItemGroup *group);
                ElementTextItemGroup *textGroup(const QString &name) const;
                QList<ElementTextItemGroup *> textGroups() const;
                bool addTextToGroup(
                                DynamicElementTextItem *text,
                                ElementTextItemGroup *group);
                bool removeTextFromGroup(
                                DynamicElementTextItem *text,
                                ElementTextItemGroup *group);
 
                        //METHODS related to linked element
                bool isFree() const;
                virtual void linkToElement(Element *) {}
                virtual void unlinkAllElements() {}
                virtual void unlinkElement(Element *) {}
                virtual void initLink(QETProject *);
                QList<Element *> linkedElements ();
 
                int groupIndexForElement(Element *elmt) const;
                void setGroupIndexForElement(Element *elmt, int index);

                virtual kind linkType() const {return m_link_type;} // return the linkable type
                QString linkTypeToString() const;
 
                void newUuid() {m_uuid = QUuid::createUuid();}  //create new uuid for this element
 
        protected:
                void drawAxes(QPainter *, const QStyleOptionGraphicsItem *);
                void setSize(int, int);
 
        private:
                void drawHighlight(
                                QPainter *,
                                const QStyleOptionGraphicsItem *);
                bool buildFromXml(const QDomElement &, int * = nullptr);
                bool parseElement(const QDomElement &dom);
                bool parseInput(const QDomElement &dom_element);
                DynamicElementTextItem *parseDynamicText(
                                const QDomElement &dom_element);
                Terminal *parseTerminal(const QDomElement &dom_element);
 
                //Reimplemented from QGraphicsItem
        public:
                void paint(
                                QPainter *,
                                const QStyleOptionGraphicsItem *,
                                QWidget *) override;
                QRectF boundingRect() const override;
        protected:
                void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
                void mouseReleaseEvent(
                                QGraphicsSceneMouseEvent *event) override;
                void hoverEnterEvent(QGraphicsSceneHoverEvent *) override;
                void hoverLeaveEvent(QGraphicsSceneHoverEvent *) override;
 
        protected:
                        //ATTRIBUTES related to linked element
                QList <Element *> connected_elements;
                QList <LinkInfo>  tmp_uuids_link;
                QHash <Element *, int> m_group_index_map;  
                QUuid             m_uuid;
                kind              m_link_type = Element::Simple;
 
                        //ATTRIBUTES related to informations
                DiagramContext m_kind_informations;
                autonum::sequentialNumbers m_autoNum_seq;
                bool m_freeze_label = false;
                QString m_F_str;
 
        ElementsLocation m_location;
        QList <Terminal *> m_terminals;
        QPicture m_picture;
        QPicture m_low_zoom_picture;
        ElementData m_data;
        QList<QPointF> m_plc_table_positions;  // Positions of plc_table parts in the element definition
 
        void drawPlcTable(QPainter *painter);
 
        public:
                QList<QPointF> plcTablePositions() const { return m_plc_table_positions; }
 
        private:
                bool m_must_highlight = false;
                QSize   dimensions;
                QPoint  hotspot_coord;
                bool m_mouse_over = false;
                QString m_prefix;
                QList <DynamicElementTextItem *> m_dynamic_text_list;
                QList <ElementTextItemGroup *> m_texts_group;
 
};
 
bool comparPos(const Element * elmt1, const Element * elmt2);
 
inline bool Element::isFree() const
{
        return (connected_elements.isEmpty());
}

inline int Element::orientation() const
{
        return(QET::correctAngle(rotation())/90);
}

inline QUuid Element::uuid() const
{return m_uuid;}

inline QList <Element *> Element::linkedElements()
{
         std::sort(
                                 connected_elements.begin(),
                                 connected_elements.end(),
                                 comparPos);
        return connected_elements;
}
 
#endif