element.cpp

Go to the documentation of this file.

/*
    Copyright 2006-2019 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/>.
*/
#include "element.h"
#include "diagram.h"
#include "conductor.h"
#include "diagramcommands.h"
#include <utility>
#include "elementprovider.h"
#include "diagramposition.h"
#include "terminal.h"
#include "PropertiesEditor/propertieseditordialog.h"
#include "elementpropertieswidget.h"
#include "numerotationcontextcommands.h"
#include "diagramcontext.h"
#include "changeelementinformationcommand.h"
#include "dynamicelementtextitem.h"
#include "elementtextitemgroup.h"
#include "elementpicturefactory.h"
#include "iostream"

class ElementXmlRetroCompatibility
{
    friend class Element;

    static void loadSequential(const QDomElement &dom_element, const QString& seq, QStringList* list)
    {
        int i = 0;
        while (!dom_element.attribute(seq + QString::number(i+1)).isEmpty())
        {
                list->append(dom_element.attribute(seq + QString::number(i+1)));
                i++;
        }
    }

    static void loadSequential(const QDomElement &dom_element, Element *element)
    {
        autonum::sequentialNumbers sn;

        loadSequential(dom_element,"sequ_",&sn.unit);
        loadSequential(dom_element,"sequf_",&sn.unit_folio);
        loadSequential(dom_element,"seqt_",&sn.ten);
        loadSequential(dom_element,"seqtf_",&sn.ten_folio);
        loadSequential(dom_element,"seqh_",&sn.hundred);
        loadSequential(dom_element,"seqhf_",&sn.hundred_folio);

        element->rSequenceStruct() = sn;
    }
};

Element::Element(const ElementsLocation &location, QGraphicsItem *parent, int *state, kind link_type) :
    QetGraphicsItem(parent),
    m_link_type (link_type),
    m_location (location)
{
    if(! (location.isElement() && location.exist()))
    {
        if (state)
        {
            *state = 1;
            return;
        }
    }
    int elmt_state;
    buildFromXml(location.xml(), &elmt_state);
    if (state) {
        *state = elmt_state;
    }
    if (elmt_state) {
        return;
    }
    if (state) {
        *state = 0;
    }
    
    setPrefix(autonum::elementPrefixForLocation(location));
    m_uuid = QUuid::createUuid();
    setZValue(10);
    setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
    setAcceptHoverEvents(true);
    
    connect(this, &Element::rotationChanged, [this]() {
        for(QGraphicsItem *qgi : childItems())
        {
            if (Terminal *t = qgraphicsitem_cast<Terminal *>(qgi))
                t->updateConductor();
        }
    });
}

Element::~Element()
{
    qDeleteAll (m_dynamic_text_list);
    qDeleteAll (m_terminals);
}

QList<Terminal *> Element::terminals() const {
    return m_terminals;
}

QList<Conductor *> Element::conductors() const
{
    QList<Conductor *> conductors;
    
    for (Terminal *t : m_terminals) {
        conductors << t -> conductors();
    }
    
    return(conductors);
}

void Element::editProperty()
{
    if (diagram() && !diagram()->isReadOnly())
    {
        ElementPropertiesWidget *epw = new ElementPropertiesWidget(this);
        PropertiesEditorDialog dialog(epw, QApplication::activeWindow());
        connect(epw, &ElementPropertiesWidget::findEditClicked, &dialog, &QDialog::reject);
            //Must be windowModal, else when user do a drag and drop
            //with the "text" tab of ElementPropertiesWidget, the ui freeze, until user press escape key
        dialog.setWindowModality(Qt::WindowModal);
        dialog.exec();
    }
}

void Element::setHighlighted(bool hl) {
    m_must_highlight = hl;
    update();
}

void Element::displayHelpLine(bool b)
{
    foreach (Terminal *t, terminals())
        t->drawHelpLine(b);
}

void Element::paint(QPainter *painter, const QStyleOptionGraphicsItem *options, QWidget *)
{
    if (m_must_highlight) {
        drawHighlight(painter, options);
    }
    
    if (options && options -> levelOfDetail < 1.0) {
        painter->drawPicture(0, 0, m_low_zoom_picture);
    } else {
        painter->drawPicture(0, 0, m_picture);
    }
    
        //Draw the selection rectangle
    if ( isSelected() || m_mouse_over ) {
        drawSelection(painter, options);
    }
}

QRectF Element::boundingRect() const {
    return(QRectF(QPointF(-hotspot_coord.x(), -hotspot_coord.y()), dimensions));
}

void Element::setSize(int wid, int hei)
{
    prepareGeometryChange();

    while (wid % 10) ++ wid;
    while (hei % 10) ++ hei;
    dimensions = QSize(wid, hei);
}

QSize Element::size() const {
    return(dimensions);
}

QPoint Element::setHotspot(QPoint hs) {
    // la taille doit avoir ete definie
    prepareGeometryChange();
    if (dimensions.isNull()) hotspot_coord = QPoint(0, 0);
    else {
        // les coordonnees indiquees ne doivent pas depasser les dimensions de l'element
        int hsx = qMin(hs.x(), dimensions.width());
        int hsy = qMin(hs.y(), dimensions.height());
        hotspot_coord = QPoint(hsx, hsy);
    }
    return(hotspot_coord);
}

QPoint Element::hotspot() const {
    return(hotspot_coord);
}

QPixmap Element::pixmap() {
    return ElementPictureFactory::instance()->pixmap(m_location);
}

/*** Methodes protegees ***/

void Element::drawAxes(QPainter *painter, const QStyleOptionGraphicsItem *options) {
    Q_UNUSED(options);
    painter -> setPen(Qt::blue);
    painter -> drawLine(0, 0, 10, 0);
    painter -> drawLine(7,-3, 10, 0);
    painter -> drawLine(7, 3, 10, 0);
    painter -> setPen(Qt::red);
    painter -> drawLine(0,  0, 0, 10);
    painter -> drawLine(0, 10,-3,  7);
    painter -> drawLine(0, 10, 3,  7);
}

/*** Methodes privees ***/

void Element::drawSelection(QPainter *painter, const QStyleOptionGraphicsItem *options) {
    Q_UNUSED(options);
    painter -> save();
    // Annulation des renderhints
    painter -> setRenderHint(QPainter::Antialiasing,          false);
    painter -> setRenderHint(QPainter::TextAntialiasing,      false);
    painter -> setRenderHint(QPainter::SmoothPixmapTransform, false);
    // Dessin du cadre de selection en gris
    QPen t;
    t.setColor(Qt::gray);
    t.setStyle(Qt::DashDotLine);
    t.setCosmetic(true);
    painter -> setPen(t);
    // Le dessin se fait a partir du rectangle delimitant
    painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10);
    painter -> restore();
}

void Element::drawHighlight(QPainter *painter, const QStyleOptionGraphicsItem *options) {
    Q_UNUSED(options);
    painter -> save();
    
    qreal gradient_radius = qMin(boundingRect().width(), boundingRect().height()) / 2.0;
    QRadialGradient gradient(
        boundingRect().center(),
        gradient_radius,
        boundingRect().center()
    );
    gradient.setColorAt(0.0, QColor::fromRgb(69, 137, 255, 255));
    gradient.setColorAt(1.0, QColor::fromRgb(69, 137, 255, 0));
    QBrush brush(gradient);
    
    painter -> setPen(Qt::NoPen);
    painter -> setBrush(brush);
    // Le dessin se fait a partir du rectangle delimitant
    painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10);
    painter -> restore();
}

bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
{
    m_state = QET::GIBuildingFromXml;

    if (xml_def_elmt.tagName() != "definition" || xml_def_elmt.attribute("type") != "element")
    {
        if (state) *state = 4;
        m_state = QET::GIOK;
        return(false);
    }

        //Check if the curent version can read the xml description
    if (xml_def_elmt.hasAttribute("version"))
    {
        bool conv_ok;
        qreal element_version = xml_def_elmt.attribute("version").toDouble(&conv_ok);
        if (conv_ok && QET::version.toDouble() < element_version)
        {
            std::cerr << qPrintable(
                QObject::tr("Avertissement : l'élément "
                " a été enregistré avec une version"
                " ultérieure de QElectroTech.")
            ) << std::endl;
        }
    }

        //This attribute must be present and valid
    int w, h, hot_x, hot_y;
    if (
        !QET::attributeIsAnInteger(xml_def_elmt, QString("width"), &w) ||\
        !QET::attributeIsAnInteger(xml_def_elmt, QString("height"), &h) ||\
        !QET::attributeIsAnInteger(xml_def_elmt, QString("hotspot_x"), &hot_x) ||\
        !QET::attributeIsAnInteger(xml_def_elmt, QString("hotspot_y"), &hot_y)
    ) {
        if (state) *state = 5;
        m_state = QET::GIOK;
        return(false);
    }

    setSize(w, h);
    setHotspot(QPoint(hot_x, hot_y));

        //the definition must have childs
    if (xml_def_elmt.firstChild().isNull())
    {
        if (state) *state = 6;
        m_state = QET::GIOK;
        return(false);
    }
        //Extract the names
    m_names.fromXml(xml_def_elmt);
    setToolTip(name());

        //load kind informations
    m_kind_informations.fromXml(xml_def_elmt.firstChildElement("kindInformations"), "kindInformation");
        //load element information
    m_element_informations.fromXml(xml_def_elmt.firstChildElement("elementInformations"), "elementInformation");

        //scroll of the Children of the Definition: Parts of the Drawing
    int parsed_elements_count = 0;
    for (QDomNode node = xml_def_elmt.firstChild() ; !node.isNull() ; node = node.nextSibling())
    {
        QDomElement elmts = node.toElement();
        if (elmts.isNull())
            continue;
        
        if (elmts.tagName() == "description")
        {
                //Minor workaround to find if there is a "input" tagg as label.
                //If not, we set the tagg "label" to the first "input.
            QList <QDomElement> input_field;
            bool have_label = false;
            for (QDomElement input_node = node.firstChildElement("input") ; !input_node.isNull() ; input_node = input_node.nextSiblingElement("input"))
            {
                if (!input_node.isNull())
                {
                    input_field << input_node;
                    if (input_node.attribute("tagg", "none") == "label")
                        have_label = true;
                }
            }
            if(!have_label && !input_field.isEmpty())
                input_field.first().setAttribute("tagg", "label");
            
                //Parse the definition
            for (QDomNode n = node.firstChild() ; !n.isNull() ; n = n.nextSibling())
            {
                QDomElement qde = n.toElement();
                if (qde.isNull())
                    continue;
                
                if (parseElement(qde)) {
                    ++ parsed_elements_count;
                }
                else
                {
                    if (state)
                        *state = 7;
                    m_state = QET::GIOK;
                    return(false);
                }
            }
        }
    }

    ElementPictureFactory *epf = ElementPictureFactory::instance();
    epf->getPictures(m_location, const_cast<QPicture&>(m_picture), const_cast<QPicture&>(m_low_zoom_picture));
    
    if(!m_picture.isNull())
        ++ parsed_elements_count;

        //They must be at least one parsed graphics part
    if (!parsed_elements_count)
    {
        if (state)
            *state = 8;
        m_state = QET::GIOK;
        return(false);
    }
    else
    {
        if (state)
            *state = 0;
        m_state = QET::GIOK;
        return(true);
    }
}

bool Element::parseElement(const QDomElement &dom)
{
    if      (dom.tagName() == "terminal")     return(parseTerminal(dom));
    else if (dom.tagName() == "input")        return(parseInput(dom));
    else if (dom.tagName() == "dynamic_text") return(parseDynamicText(dom));
    else return(true);
}

bool Element::parseInput(const QDomElement &dom_element)
{
    qreal pos_x, pos_y;
    int size;
    if (
        !QET::attributeIsAReal(dom_element, "x", &pos_x) ||\
        !QET::attributeIsAReal(dom_element, "y", &pos_y) ||\
        !QET::attributeIsAnInteger(dom_element, "size", &size)
    ) return(false);
    else
    {
        DynamicElementTextItem *deti = new DynamicElementTextItem(this);
        deti->setText(dom_element.attribute("text", "_"));
        QFont font = deti->font();
        font.setPointSize(dom_element.attribute("size", QString::number(9)).toInt());
        deti->setFont(font);
        deti->setRotation(dom_element.attribute("rotation", QString::number(0)).toDouble());

        if(dom_element.attribute("tagg", "none") != "none")
        {
            deti->setTextFrom(DynamicElementTextItem::ElementInfo);
            deti->setInfoName(dom_element.attribute("tagg"));
        }
        
            //the origin transformation point of PartDynamicTextField is the top left corner, no matter the font size
            //The origin transformation point of ElementTextItem is the middle of left edge, and so by definition, change with the size of the font
            //We need to use a QTransform to find the pos of this text from the saved pos of text item
        QTransform transform;
            //First make the rotation
        transform.rotate(dom_element.attribute("rotation", "0").toDouble());
        QPointF pos = transform.map(QPointF(0, -deti->boundingRect().height()/2));
        transform.reset();
            //Second translate to the pos
        QPointF p(dom_element.attribute("x", QString::number(0)).toDouble(),
                  dom_element.attribute("y", QString::number(0)).toDouble());
        transform.translate(p.x(), p.y());
        deti->setPos(transform.map(pos));
        m_converted_text_from_xml_description.insert(deti, p);
        return true;
    }
    
    return false;
}

DynamicElementTextItem *Element::parseDynamicText(const QDomElement &dom_element)
{
    DynamicElementTextItem *deti = new DynamicElementTextItem(this);
        //Because the xml description of a .elmt file is the same as how a dynamic text field is save to xml in a .qet file
        //wa call fromXml, we just change the tagg name (.elmt = dynamic_text, .qet = dynamic_elmt_text)
        //and the uuid (because the uuid, is the uuid of the descritpion and not the uuid of instantiated dynamic text field)
    
    QDomElement dom(dom_element.cloneNode(true).toElement());
    dom.setTagName(DynamicElementTextItem::xmlTaggName());
    deti->fromXml(dom);
    deti->m_uuid = QUuid::createUuid();
    this->addDynamicTextItem(deti);
    return deti;
}

Terminal *Element::parseTerminal(const QDomElement &dom_element)
{
    qreal terminalx, terminaly;
    Qet::Orientation terminalo;
    if (!QET::attributeIsAReal(dom_element, QString("x"), &terminalx)) {
        return(nullptr);
    }
    if (!QET::attributeIsAReal(dom_element, QString("y"), &terminaly)) {
        return(nullptr);
    }
    if (!dom_element.hasAttribute("orientation")) {
        return(nullptr);
    }
    if (dom_element.attribute("orientation") == "n") {
        terminalo = Qet::North;
    }
    else if (dom_element.attribute("orientation") == "s") {
        terminalo = Qet::South;
    }
    else if (dom_element.attribute("orientation") == "e") {
        terminalo = Qet::East;
    }
    else if (dom_element.attribute("orientation") == "w") {
        terminalo = Qet::West;
    }
    else {
        return(nullptr);
    }
    
    Terminal *new_terminal = new Terminal(terminalx, terminaly, terminalo, this);
    m_terminals << new_terminal;
    
        //Sort from top to bottom and left to rigth
    std::sort(m_terminals.begin(), m_terminals.end(), [](Terminal *a, Terminal *b)
    {
        if(a->dockConductor().y() == b->dockConductor().y())
            return (a->dockConductor().x() < b->dockConductor().x());
        else
            return (a->dockConductor().y() < b->dockConductor().y());
    });
    
    return(new_terminal);
}

bool Element::valideXml(QDomElement &e) {
    // verifie le nom du tag
    if (e.tagName() != "element") return(false);
    
    // verifie la presence des attributs minimaux
    if (!e.hasAttribute("type")) return(false);
    if (!e.hasAttribute("x"))    return(false);
    if (!e.hasAttribute("y"))    return(false);
    
    bool conv_ok;
    // parse l'abscisse
    e.attribute("x").toDouble(&conv_ok);
    if (!conv_ok) return(false);
    
    // parse l'ordonnee
    e.attribute("y").toDouble(&conv_ok);
    if (!conv_ok) return(false);
    return(true);
}

bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool handle_inputs_rotation)
{
    m_state = QET::GILoadingFromXml;
    /*
        les bornes vont maintenant etre recensees pour associer leurs id a leur adresse reelle
        ce recensement servira lors de la mise en place des fils
    */
    QList<QDomElement> liste_terminals;
    foreach(QDomElement qde, QET::findInDomElement(e, "terminals", "terminal")) {
        if (Terminal::valideXml(qde)) liste_terminals << qde;
    }
    
    QHash<int, Terminal *> priv_id_adr;
    int terminals_non_trouvees = 0;
    foreach(QGraphicsItem *qgi, childItems()) {
        if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) {
            bool terminal_trouvee = false;
            foreach(QDomElement qde, liste_terminals) {
                if (p -> fromXml(qde)) {
                    priv_id_adr.insert(qde.attribute("id").toInt(), p);
                    terminal_trouvee = true;
                    // We used to break here, because we did not expect
                    // several terminals to share the same position.
                    // Of course, it finally happened.
                }
            }
            if (!terminal_trouvee) ++ terminals_non_trouvees;
        }
    }
    
    if (terminals_non_trouvees > 0)
    {
        m_state = QET::GIOK;
        return(false);
    } 
    else
    {
        // verifie que les associations id / adr n'entrent pas en conflit avec table_id_adr
        foreach(int id_trouve, priv_id_adr.keys())
        {
            if (table_id_adr.contains(id_trouve))
            {
                // cet element possede un id qui est deja reference (= conflit)
                m_state = QET::GIOK;
                return(false);
            }
        }
        // copie des associations id / adr
        foreach(int id_trouve, priv_id_adr.keys()) {
            table_id_adr.insert(id_trouve, priv_id_adr.value(id_trouve));
        }
    }

    //load uuid of connected elements
    QList <QDomElement> uuid_list = QET::findInDomElement(e, "links_uuids", "link_uuid");
    foreach (QDomElement qdo, uuid_list) tmp_uuids_link << qdo.attribute("uuid");
    
    //uuid of this element
    m_uuid= QUuid(e.attribute("uuid", QUuid::createUuid().toString()));

        //load prefix
    m_prefix = e.attribute("prefix");

    QString fl = e.attribute("freezeLabel", "false");
    m_freeze_label = fl == "false"? false : true;

        //Load Sequential Values
    if (e.hasAttribute("sequ_1") || e.hasAttribute("sequf_1") || e.hasAttribute("seqt_1") || e.hasAttribute("seqtf_1") || e.hasAttribute("seqh_1") || e.hasAttribute("sequf_1"))
        ElementXmlRetroCompatibility::loadSequential(e, this);
    else
        m_autoNum_seq.fromXml(e.firstChildElement("sequentialNumbers"));

        //Position and selection.
        //We directly call setPos from QGraphicsObject, because QetGraphicsItem will snap to grid
    QGraphicsObject::setPos(e.attribute("x").toDouble(), e.attribute("y").toDouble());
    setZValue(e.attribute("z", QString::number(this->zValue())).toDouble());
    setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
    
    // orientation
    bool conv_ok;
    int read_ori = e.attribute("orientation").toInt(&conv_ok);
    if (!conv_ok || read_ori < 0 || read_ori > 3) read_ori = 0;
    if (handle_inputs_rotation) {
        setRotation(rotation() + (90*read_ori));
    } else {
        setRotation(90*read_ori);
    }
    
        //Befor load the dynamic text field,
        //we remove the dynamic text field created from the description of this element, to avoid doublons.
    for(DynamicElementTextItem *deti : m_dynamic_text_list)
        delete deti;
    m_dynamic_text_list.clear();
    
        //************************//
        //***Dynamic texts item***//
        //************************//
    for (const QDomElement& qde : QET::findInDomElement(e, "dynamic_texts", DynamicElementTextItem::xmlTaggName()))
    {
        DynamicElementTextItem *deti = new DynamicElementTextItem(this);
        addDynamicTextItem(deti);
        deti->fromXml(qde);
    }
    

        //************************//
        //***Element texts item***//
        //************************//
    QList<QDomElement> inputs = QET::findInDomElement(e, "inputs", "input");
    
        //First case, we check for the text item converted to dynamic text item
    const QList <DynamicElementTextItem *> conv_deti_list = m_converted_text_from_xml_description.keys();
    QList <DynamicElementTextItem *> successfully_converted; 
    const QList <QDomElement> dom_inputs = inputs;
    
    for (DynamicElementTextItem *deti : conv_deti_list)
    {
        for(const QDomElement& dom_input : dom_inputs)
        {
                //we use the same method used in ElementTextItem::fromXml to compar and know if the input dom element is for one of the text stored.
                //The comparaison is made from the text position : if the position of the text is the same as the position stored in 'input' dom element
                //that mean this is the good text
            if (qFuzzyCompare(qreal(dom_input.attribute("x").toDouble()), m_converted_text_from_xml_description.value(deti).x()) &&
                qFuzzyCompare(qreal(dom_input.attribute("y").toDouble()), m_converted_text_from_xml_description.value(deti).y()))
            {
                    //Once again this 'if', is only for retrocompatibility with old old old project
                    //when element text with tagg "label" is not null, but the element information "label" is. 
                if((deti->textFrom() == DynamicElementTextItem::ElementInfo) && (deti->infoName() == "label"))
                    m_element_informations.addValue("label", dom_input.attribute("text"));
                
                deti->setText(dom_input.attribute("text"));
                
                qreal rotation = deti->rotation();
                QPointF xml_pos = m_converted_text_from_xml_description.value(deti);
                
                if (dom_input.attribute("userrotation").toDouble())
                    rotation = dom_input.attribute("userrotation").toDouble();
                
                if (dom_input.hasAttribute("userx"))
                    xml_pos.setX(dom_input.attribute("userx").toDouble());
                if(dom_input.hasAttribute("usery"))
                    xml_pos.setY(dom_input.attribute("usery", "0").toDouble());
                
                    //the origin transformation point of PartDynamicTextField is the top left corner, no matter the font size
                    //The origin transformation point of PartTextField is the middle of left edge, and so by definition, change with the size of the font
                    //We need to use a QTransform to find the pos of this text from the saved pos of text item
                
                deti->setPos(xml_pos);
                deti->setRotation(rotation);
                
                QTransform transform;
                    //First make the rotation
                transform.rotate(rotation);
                QPointF pos = transform.map(QPointF(0, -deti->boundingRect().height()/2));
                transform.reset();
                    //Second translate to the pos
                transform.translate(xml_pos.x(), xml_pos.y());
                deti->setPos(transform.map(pos));
                
                    //dom_input and deti matched we remove the dom_input from @inputs list,
                    //to avoid unnecessary checking made below
                    //we also move deti from the m_converted_text_from_xml_description to m_dynamic_text_list
                inputs.removeAll(dom_input);
                m_dynamic_text_list.append(deti);
                m_converted_text_from_xml_description.remove(deti);
                successfully_converted << deti;
            }
        }
    }
    
        //###Firts case : if this is the first time the user open the project since text item are converted to dynamic text,
        //in the previous opening of the project, every texts field present in the element description was created.
        //At save time, the values of each of them was save in the 'input' dom element.
        //The loop upper is made for the first case, to import the values in 'input' to the new converted dynamic texts field.
        //###Second case : this is not the first time the user open the project since text item are converted to dynamic text.
        //That mean, in a previous opening of the project, the text item was already converted and save as a dynamic text field.
        //So there isn't 'input' dom element in the project, and every dynamic text item present in m_converted_text_from_xml_description
        //need to be deleted (because already exist in m_dynamic_text_list, from a previous save)
    for (DynamicElementTextItem *deti : m_converted_text_from_xml_description.keys())
        delete deti;
    m_converted_text_from_xml_description.clear();
    
    for (QDomElement qde : QET::findInDomElement(e, "texts_groups", ElementTextItemGroup::xmlTaggName()))
    {
        ElementTextItemGroup *group = addTextGroup("loaded_from_xml_group");
        group->fromXml(qde);
    }
    
        //load informations
    DiagramContext dc;
    dc.fromXml(e.firstChildElement("elementInformations"), "elementInformation");
    if (dc["label"].toString().contains("%") && dc["formula"].toString().isNull())
    {
        dc.addValue("formula", dc["label"]);
    }
        //retrocompatibility with older version
    if(dc.value("label").toString().isEmpty() &&
       !m_element_informations.value("label").toString().isEmpty())
        dc.addValue("label", m_element_informations.value("label"));
    
        //We must to block the update of the alignment when load the information
        //otherwise the pos of the text will not be the same as it was at save time.
    for(DynamicElementTextItem *deti : m_dynamic_text_list)
        deti->m_block_alignment = true;
    setElementInformations(dc);
    for(DynamicElementTextItem *deti : m_dynamic_text_list)
        deti->m_block_alignment = false;
    
    
        //#1 There must be old text converted to dynamic text
    if(!successfully_converted.isEmpty())
    {
            //#2 the element information must have label not empty and visible
            //and a least comment or location not empty and visible
        QString label = m_element_informations.value("label").toString();
        QString comment = m_element_informations.value("comment").toString();
        QString location = m_element_informations.value("location").toString();
        bool la = m_element_informations.keyMustShow("label");
        bool c = m_element_informations.keyMustShow("comment");
        bool lo = m_element_informations.keyMustShow("location");
        
        if((m_link_type != Master) ||
           ((m_link_type == Master) &&
            (diagram()->project()->defaultXRefProperties(m_kind_informations["type"].toString()).snapTo() == XRefProperties::Label))
           )
        {
            if(!label.isEmpty() && la &&
               ((!comment.isEmpty() && c) || (!location.isEmpty() && lo)))
            {
                    //#2 in the converted list one text must have text from = element info and info name = label
                for(DynamicElementTextItem *deti : successfully_converted)
                {
                    if(deti->textFrom() == DynamicElementTextItem::ElementInfo && deti->infoName() == "label")
                    {
                        qreal rotation = deti->rotation();
                        
                            //Create the comment item
                        DynamicElementTextItem *comment_text = nullptr;
                        if (m_link_type !=PreviousReport || m_link_type !=NextReport)
                        {
                            m_state = QET::GIOK;
                            return(true);
                        }
                        if(!comment.isEmpty() && c)
                        {
                            comment_text = new DynamicElementTextItem(this);
                            comment_text->setTextFrom(DynamicElementTextItem::ElementInfo);
                            comment_text->setInfoName("comment");
                            QFont font = comment_text->font();
                            font.setPointSize(6);
                            comment_text->setFont(font);
                            comment_text->setFrame(true);
                            if(comment_text->toPlainText().count() > 17)
                                comment_text->setTextWidth(80);
                            comment_text->setPos(deti->x(), deti->y()+10); //+10 is arbitrary, comment_text must be below deti
                            addDynamicTextItem(comment_text);
                        }
                            //create the location item
                        DynamicElementTextItem *location_text = nullptr;
                        if (m_link_type !=PreviousReport || m_link_type !=NextReport)
                        {
                            m_state = QET::GIOK;
                            return(true);
                        }
                        if(!location.isEmpty() && lo)
                        {
                            location_text = new DynamicElementTextItem(this);
                            location_text->setTextFrom(DynamicElementTextItem::ElementInfo);
                            location_text->setInfoName("location");
                            QFont font = location_text->font();
                            font.setPointSize(6);
                            location_text->setFont(font);
                            if(location_text->toPlainText().count() > 17)
                                location_text->setTextWidth(80);
                            location_text->setPos(deti->x(), deti->y()+20); //+20 is arbitrary, location_text must be below deti and comment
                            addDynamicTextItem(location_text);
                        }
                        
                        QPointF pos = deti->pos();
                        if (m_link_type !=PreviousReport || m_link_type !=NextReport)
                        {
                            m_state = QET::GIOK;
                            return(true);
                        }
                            //Create the group
                        ElementTextItemGroup *group = addTextGroup(tr("Label + commentaire"));
                        addTextToGroup(deti, group);
                        if(comment_text)
                            addTextToGroup(comment_text, group);
                        if(location_text)
                            addTextToGroup(location_text, group);
                        group->setAlignment(Qt::AlignVCenter);
                        group->setVerticalAdjustment(-4);
                        group->setRotation(rotation);
                            //Change the position of the group, so that the text "label" stay in the same
                            //position in scene coordinate
                        group->setPos(pos - deti->pos());
                        
                        break;
                    }
                }
            }
        }
        else
        {
                //This element is supposed to be a master and Xref property snap to bottom
            if((!comment.isEmpty() && c) || (!location.isEmpty() && lo))
            {
                    //Create the comment item
                DynamicElementTextItem *comment_text = nullptr;
                if(!comment.isEmpty() && c)
                {
                    comment_text = new DynamicElementTextItem(this);
                    comment_text->setTextFrom(DynamicElementTextItem::ElementInfo);
                    comment_text->setInfoName("comment");
                    QFont font = comment_text->font();
                    font.setPointSize(6);
                    comment_text->setFont(font);
                    comment_text->setFrame(true);
                    comment_text->setTextWidth(80);
                    addDynamicTextItem(comment_text);
                }
                    //create the location item
                DynamicElementTextItem *location_text = nullptr;
                if(!location.isEmpty() && lo)
                {
                    location_text = new DynamicElementTextItem(this);
                    location_text->setTextFrom(DynamicElementTextItem::ElementInfo);
                    location_text->setInfoName("location");
                    QFont font = location_text->font();
                    font.setPointSize(6);
                    location_text->setFont(font);
                    location_text->setTextWidth(80);
                    if(comment_text)
                        location_text->setPos(comment_text->x(), comment_text->y()+10); //+10 is arbitrary, location_text must be below the comment
                    addDynamicTextItem(location_text);
                }
                
                    //Create the group
                ElementTextItemGroup *group = addTextGroup(tr("Label + commentaire"));
                if(comment_text)
                    addTextToGroup(comment_text, group);
                if(location_text)
                    addTextToGroup(location_text, group);
                group->setAlignment(Qt::AlignVCenter);
                group->setVerticalAdjustment(-4);
                group->setHoldToBottomPage(true);
            }
        }
    }
    m_state = QET::GIOK;
    return(true);
}

QDomElement Element::toXml(QDomDocument &document, QHash<Terminal *, int> &table_adr_id) const
{
    QDomElement element = document.createElement("element");
    
        // type
    element.setAttribute("type", m_location.path());

        // uuid
    element.setAttribute("uuid", uuid().toString());

        // prefix
    element.setAttribute("prefix", m_prefix);

        //frozen label
    element.setAttribute("freezeLabel", m_freeze_label? "true" : "false");

        // sequential num
    QDomElement seq = m_autoNum_seq.toXml(document);
    if (seq.hasChildNodes())
        element.appendChild(seq);
    
    // position, selection et orientation
    element.setAttribute("x", QString::number(pos().x()));
    element.setAttribute("y", QString::number(pos().y()));
    element.setAttribute("z", QString::number(this->zValue()));
    element.setAttribute("orientation", QString::number(orientation()));
    
    /* recupere le premier id a utiliser pour les bornes de cet element */
    int id_terminal = 0;
    if (!table_adr_id.isEmpty()) {
        // trouve le plus grand id
        int max_id_t = -1;
        foreach (int id_t, table_adr_id.values()) {
            if (id_t > max_id_t) max_id_t = id_t;
        }
        id_terminal = max_id_t + 1;
    }
    
    // enregistrement des bornes de l'appareil
    QDomElement xml_terminals = document.createElement("terminals");
    // pour chaque enfant de l'element
    foreach(Terminal *t, terminals()) {
        // alors on enregistre la borne
        QDomElement terminal = t -> toXml(document);
        terminal.setAttribute("id", id_terminal);
        table_adr_id.insert(t, id_terminal ++);
        xml_terminals.appendChild(terminal);
    }
    element.appendChild(xml_terminals);
    
    // enregistrement des champ de texte de l'appareil
    QDomElement inputs = document.createElement("inputs");
    element.appendChild(inputs);

    //if this element is linked to other elements,
    //save the uuid of each other elements
    if (! isFree()) {
        QDomElement links_uuids = document.createElement("links_uuids");
        foreach (Element *elmt, connected_elements) {
            QDomElement link_uuid = document.createElement("link_uuid");
            link_uuid.setAttribute("uuid", elmt->uuid().toString());
            links_uuids.appendChild(link_uuid);
        }
        element.appendChild(links_uuids);
    }

        //save information of this element
    if (! m_element_informations.keys().isEmpty()) {
        QDomElement infos = document.createElement("elementInformations");
        m_element_informations.toXml(infos, "elementInformation");
        element.appendChild(infos);
    }
        
        //Dynamic texts
    QDomElement dyn_text = document.createElement("dynamic_texts");
    for (DynamicElementTextItem *deti : m_dynamic_text_list)
        dyn_text.appendChild(deti->toXml(document));
    
    QDomElement texts_group = document.createElement("texts_groups");
    
        //Dynamic texts owned by groups
    for(ElementTextItemGroup *group : m_texts_group)
    {
        group->blockAlignmentUpdate(true);
            //temporarily remove the texts from group to get the pos relative to element and not group.
            //Set the alignment to top, because top is not used by groupand so,
            //each time a text is removed from the group, the alignement is not updated
        Qt::Alignment al = group->alignment();
        group->setAlignment(Qt::AlignTop);
        
            //Remove the texts from group
        QList<DynamicElementTextItem *> deti_list = group->texts();
        for(DynamicElementTextItem *deti : deti_list)
            group->removeFromGroup(deti);
        
            //Save the texts to xml
        for (DynamicElementTextItem *deti : deti_list)
            dyn_text.appendChild(deti->toXml(document));
        
            //Re add texts to group
        for(DynamicElementTextItem *deti : deti_list)
            group->addToGroup(deti);
        
            //Restor the alignement
        group->setAlignment(al);
        
            //Save the group to xml
        texts_group.appendChild(group->toXml(document));
        group->blockAlignmentUpdate(false);
    }
    
        //Append the dynamic texts to element
    element.appendChild(dyn_text);
        //Append the texts group to element
    element.appendChild(texts_group);

    return(element);
}

void Element::addDynamicTextItem(DynamicElementTextItem *deti)
{
    if (deti && !m_dynamic_text_list.contains(deti))
    {
        m_dynamic_text_list.append(deti);
        deti->setParentItem(this);
        emit textAdded(deti);
    }
    else
    {
        DynamicElementTextItem *text = new DynamicElementTextItem(this);
        m_dynamic_text_list.append(text);
        emit textAdded(text);
    }
}

void Element::removeDynamicTextItem(DynamicElementTextItem *deti)
{
    if (m_dynamic_text_list.contains(deti))
    {
        m_dynamic_text_list.removeOne(deti);
        deti->setParentItem(nullptr);
        emit textRemoved(deti);
        return;
    }
    
    for(ElementTextItemGroup *group : m_texts_group)
    {
        if(group->texts().contains(deti))
        {
            removeTextFromGroup(deti, group);
            m_dynamic_text_list.removeOne(deti);
            deti->setParentItem(nullptr);
            emit textRemoved(deti);
            return;
        }
    }
}

QList<DynamicElementTextItem *> Element::dynamicTextItems() const {
    return m_dynamic_text_list;
}

ElementTextItemGroup *Element::addTextGroup(const QString &name)
{
    if(m_texts_group.isEmpty())
    {
        ElementTextItemGroup *group = new ElementTextItemGroup(name, this);
        m_texts_group << group;
        emit textsGroupAdded(group);
        return group;
    }
        
        //Set a new name if name already exist
    QString rename = name;
    int i=1;
    while (textGroup(rename))
    {
        rename = name+QString::number(i);
        i++;
    }
    
        //Create the group
    ElementTextItemGroup *group = new ElementTextItemGroup(rename, this);
    m_texts_group << group;
    emit textsGroupAdded(group);
    return group;
}

void Element::addTextGroup(ElementTextItemGroup *group)
{
    if(group->parentElement())
        return;
    
    m_texts_group << group;
    group->setParentItem(this);
    emit textsGroupAdded(group);
}

void Element::removeTextGroup(ElementTextItemGroup *group)
{
    if(!m_texts_group.contains(group))
        return;
    
    const QList <QGraphicsItem *> items_list = group->childItems();
    
    for(QGraphicsItem *qgi : items_list)
    {
        if(qgi->type() == DynamicElementTextItem::Type)
        {
            DynamicElementTextItem *deti = static_cast<DynamicElementTextItem *>(qgi);
            removeTextFromGroup(deti, group);
        }
    }
    
    
    emit textsGroupAboutToBeRemoved(group);
    m_texts_group.removeOne(group);
    group->setParentItem(nullptr);
}

ElementTextItemGroup *Element::textGroup(const QString &name) const
{
    for (ElementTextItemGroup *group : m_texts_group)
        if(group->name() == name)
            return group;
    
    return nullptr;
}

QList<ElementTextItemGroup *> Element::textGroups() const
{
    return m_texts_group;
}

bool Element::addTextToGroup(DynamicElementTextItem *text, ElementTextItemGroup *group)
{
    if(!m_dynamic_text_list.contains(text))
        return false;
    if(!m_texts_group.contains(group))
        return false;

    m_dynamic_text_list.removeOne(text);
    emit textRemoved(text);
    
    group->addToGroup(text);
    emit textAddedToGroup(text, group);
    
    return true;
}

bool Element::removeTextFromGroup(DynamicElementTextItem *text, ElementTextItemGroup *group)
{
    if(!m_texts_group.contains(group))
        return false;
    
    if(group->texts().contains(text))
    {
        group->removeFromGroup(text);
        emit textRemovedFromGroup(text, group);
        addDynamicTextItem(text);
        return true;
    }
    
    return false;
}

QList <QPair <Terminal *, Terminal *> > Element::AlignedFreeTerminals() const
{
    QList <QPair <Terminal *, Terminal *> > list;

    foreach (Terminal *terminal, terminals())
    {
        if (terminal->conductors().isEmpty())
        {
            Terminal *other_terminal = terminal -> alignedWithTerminal();
            if (other_terminal)
                list << qMakePair(terminal, other_terminal);
        }
    }

    return list;
}

void Element::initLink(QETProject *prj)
{
        // if nothing to link return now
    if (tmp_uuids_link.isEmpty()) return;

    ElementProvider ep(prj);
    foreach (Element *elmt, ep.fromUuids(tmp_uuids_link)) {
        elmt->linkToElement(this);
    }
    tmp_uuids_link.clear();
}

void Element::setElementInformations(DiagramContext dc)
{
    if (m_element_informations == dc) return;
    DiagramContext old_info = m_element_informations;
    m_element_informations = dc;
    emit elementInfoChange(old_info, m_element_informations);
}

bool comparPos(const Element *elmt1, const Element *elmt2) {
    //Compare folio first
    if (elmt1->diagram()->folioIndex() != elmt2->diagram()->folioIndex())
        return elmt1->diagram()->folioIndex() < elmt2->diagram()->folioIndex();
    //Compare the row(in letter pos) in second
    QString a = elmt1->diagram()->convertPosition(elmt1->scenePos()).letter();
    QString b = elmt2->diagram()->convertPosition(elmt2->scenePos()).letter();
    if (a != b)
        return a<b;
    //In last compare the line, if line is egal, return sorted by row in real pos
    if (elmt1->pos().x() == elmt2->pos().x())
        return elmt1->y() <= elmt2->pos().y();
    return elmt1->pos().x() <= elmt2->pos().x();
}

void Element::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    QetGraphicsItem::mouseMoveEvent(event);
    foreach (Terminal *t, terminals())
    {
        t -> drawHelpLine(true);
    }
}

void Element::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    QetGraphicsItem::mouseReleaseEvent(event);
    foreach (Terminal *t, terminals())
    {
        t -> drawHelpLine(false);
    }
}

void Element::hoverEnterEvent(QGraphicsSceneHoverEvent *e) {
    Q_UNUSED(e);

    foreach (Element *elmt, linkedElements())
        elmt -> setHighlighted(true);

    m_mouse_over = true;
    setToolTip( name() );
    update();
}

void Element::hoverLeaveEvent(QGraphicsSceneHoverEvent *e) {
    Q_UNUSED(e);

    foreach (Element *elmt, linkedElements())
        elmt -> setHighlighted(false);

    m_mouse_over = false;
    update();
}

void Element::setUpFormula(bool code_letter)
{
    Q_UNUSED(code_letter)
    
    if (linkType() == Element::Slave || linkType() & Element::AllReport)
        return;

    if (diagram())
    {
        QString formula = diagram()->project()->elementAutoNumCurrentFormula();

        m_element_informations.addValue("formula", formula);
        
        QString element_currentAutoNum = diagram()->project()->elementCurrentAutoNum();
        NumerotationContext nc = diagram()->project()->elementAutoNum(element_currentAutoNum);
        NumerotationContextCommands ncc (nc);
        
        m_autoNum_seq.clear();
        autonum::setSequential(formula, m_autoNum_seq, nc, diagram(), element_currentAutoNum);
        diagram()->project()->addElementAutoNum(element_currentAutoNum, ncc.next());

        if(!m_freeze_label && !formula.isEmpty())
        {
            DiagramContext dc = m_element_informations;
            QString label = autonum::AssignVariables::formulaToLabel(formula, m_autoNum_seq, diagram(), this);
            m_element_informations.addValue("label", label);
            emit elementInfoChange(dc, m_element_informations);
        }
    }
}

QString Element::getPrefix() const{
    return m_prefix;
}

void Element::setPrefix(QString prefix) {
    m_prefix = std::move(prefix);
}

void Element::freezeLabel(bool freeze)
{
    m_freeze_label = freeze;
}

void Element::freezeNewAddedElement() {
    if (this->diagram()->freezeNewElements() || this->diagram()->project()->isFreezeNewElements()) {
        freezeLabel(true);
    }
    else return;
}

QString Element::name() const {
    return m_names.name(m_location.baseName());
}

ElementsLocation Element::location() const {
    return m_location;
}