elementscene.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 "elementscene.h"
#include "qetelementeditor.h"
#include "elementprimitivedecorator.h"
#include <cmath>
#include "partline.h"
#include "partrectangle.h"
#include "partellipse.h"
#include "partpolygon.h"
#include "partterminal.h"
#include "parttext.h"
#include "partarc.h"
#include "editorcommands.h"
#include "elementcontent.h"
#include "ui/elementpropertieseditorwidget.h"
#include "eseventinterface.h"
#include "QetGraphicsItemModeler/qetgraphicshandleritem.h"
#include "partdynamictextfield.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"
#include "namelistdialog.h"
#include "namelistwidget.h"

#include <algorithm>
#include <QKeyEvent>

ElementScene::ElementScene(QETElementEditor *editor, QObject *parent) :
    QGraphicsScene(parent),
    m_elmt_type("simple"),
    m_qgi_manager(this),
    m_element_editor(editor)
{
    setItemIndexMethod(QGraphicsScene::NoIndex);
        //Set to no index, because they can be the source of the crash with conductor and shape ghost.
        //https://forum.qt.io/topic/71316/qgraphicsscenefinditembsptreevisitor-visit-crashes-due-to-an-obsolete-paintevent-after-qgraphicsscene-removeitem
        //https://stackoverflow.com/questions/38458830/crash-after-qgraphicssceneremoveitem-with-custom-item-class
        //http://www.qtcentre.org/archive/index.php/t-33730.html
        //http://tech-artists.org/t/qt-properly-removing-qgraphicitems/3063
    
    m_behavior = Normal;
    setItemIndexMethod(NoIndex);
    setGrid(1, 1);
    initPasteArea();
    m_undo_stack.setClean();
    m_decorator_lock = new QMutex(QMutex::NonRecursive);
    connect(&m_undo_stack, SIGNAL(indexChanged(int)), this, SLOT(managePrimitivesGroups()));
    connect(this, SIGNAL(selectionChanged()), this, SLOT(managePrimitivesGroups()));
}

ElementScene::~ElementScene()
{
        //Disconnect to avoid crash, see bug report N° 122.
    disconnect(&m_undo_stack, SIGNAL(indexChanged(int)), this, SLOT(managePrimitivesGroups()));
    delete m_decorator_lock;

    if (m_event_interface)
        delete m_event_interface;

    if (m_decorator)
        delete m_decorator;
}

void ElementScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
    if (m_event_interface) {
        if (m_event_interface -> mouseMoveEvent(e)) {
            if (m_event_interface->isFinish()) {
                delete m_event_interface; m_event_interface = nullptr;
                emit(partsAdded());
            }
            return;
        }
    }

    QPointF event_pos = e -> scenePos();
    if (!(e -> modifiers() & Qt::ControlModifier))
        event_pos = snapToGrid(event_pos);
    
    if (m_behavior == PasteArea) {
        QRectF current_rect(m_paste_area -> rect());
        current_rect.moveCenter(event_pos);
        m_paste_area -> setRect(current_rect);
        return;
    }

    QGraphicsScene::mouseMoveEvent(e);
}

void ElementScene::mousePressEvent(QGraphicsSceneMouseEvent *e) {
    if (m_event_interface) {
        if (m_event_interface -> mousePressEvent(e)) {
            if (m_event_interface->isFinish()) {
                delete m_event_interface; m_event_interface = nullptr;
                emit(partsAdded());
            }
            return;
        }
    }

    QGraphicsScene::mousePressEvent(e);
}

void ElementScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
    if (m_event_interface) {
        if (m_event_interface -> mouseReleaseEvent(e)) {
            if (m_event_interface->isFinish()) {
                delete m_event_interface; m_event_interface = nullptr;
                emit(partsAdded());
            }
            return;
        }
    }
    
    if (m_behavior == PasteArea) {
        m_defined_paste_area = m_paste_area -> rect();
        removeItem(m_paste_area);
        emit(pasteAreaDefined(m_defined_paste_area));
        m_behavior = Normal;
        return;
    }

    QGraphicsScene::mouseReleaseEvent(e);
}

void ElementScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) {
    if (m_event_interface) {
        if (m_event_interface -> mouseDoubleClickEvent(event)) {
            if (m_event_interface->isFinish()) {
                delete m_event_interface; m_event_interface = nullptr;
                emit(partsAdded());
            }
            return;
        }
    }

    QGraphicsScene::mouseDoubleClickEvent(event);
}

void ElementScene::keyPressEvent(QKeyEvent *event)
{
    if (m_event_interface)
    {
        if (m_event_interface -> keyPressEvent(event))
        {
            if (m_event_interface->isFinish())
            {
                delete m_event_interface; m_event_interface = nullptr;
                emit(partsAdded());
            }
            return;
        }
    }
    
    if(selectedItems().size() == 1)
    {
        if(selectedItems().first()->type() == PartText::Type)
        {
            PartText *t = static_cast<PartText *>(selectedItems().first());
            if(t->textInteractionFlags() & Qt::TextEditorInteraction)
            {
                QGraphicsScene::keyPressEvent(event);
                return;
            }
        }
        
        QGraphicsObject *qgo = selectedItems().first()->toGraphicsObject();
        if(qgo)
        {
            QPointF original_pos = qgo->pos();
            QPointF p = qgo->pos();
            int k = event->key();
            if(k == Qt::Key_Right)
                p.rx() += 1;
            else if (k == Qt::Key_Left)
                p.rx() -= 1;
            else if (k == Qt::Key_Up)
                p.ry() -= 1;
            else if (k == Qt::Key_Down)
                p.ry() += 1;
            
            qgo->setPos(p);
            QPropertyUndoCommand *undo = new QPropertyUndoCommand(qgo, "pos", QVariant(original_pos), QVariant(p));
            undo->setText(tr("Déplacer une primitive"));
            undo->enableAnimation();
            undoStack().push(undo);
            event->accept();
            return;
        }
    }
    
    QGraphicsScene::keyPressEvent(event);
}

void ElementScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
    QGraphicsScene::contextMenuEvent(event);
    if(event->isAccepted())
        return;
    
    if (m_behavior == ElementScene::Normal)
        m_element_editor -> contextMenu(event->screenPos());
}

void ElementScene::drawForeground(QPainter *p, const QRectF &rect) {
    Q_UNUSED(rect);
    p -> save();
    
    // desactive tout antialiasing, sauf pour le texte
    p -> setRenderHint(QPainter::Antialiasing, false);
    p -> setRenderHint(QPainter::TextAntialiasing, true);
    p -> setRenderHint(QPainter::SmoothPixmapTransform, false);
    
    QPen pen(Qt::red);
    pen.setCosmetic(true);
    p -> setPen(pen);
    p -> setBrush(Qt::NoBrush);
    p -> drawLine(-20, 0, 20, 0);
    p -> drawLine(0, -20, 0, 20);
    p -> restore();
}

void ElementScene::setEventInterface(ESEventInterface *event_interface)
{
    if (m_event_interface)
    {
        delete m_event_interface;
        //We must to re-init because previous interface
        //Reset his own init when deleted
        event_interface->init();
    }
    m_event_interface = event_interface;
}

void ElementScene::clearEventInterface()
{
    if(m_event_interface)
    {
        delete m_event_interface;
        m_event_interface = nullptr;
    }
}

void ElementScene::setBehavior(ElementScene::Behavior b) {
    m_behavior = b;
}

ElementScene::Behavior ElementScene::behavior() const {
    return m_behavior;
}

int ElementScene::xGrid() const {
    return(m_x_grid);
}

int ElementScene::yGrid() const {
    return(m_y_grid);
}

void ElementScene::setGrid(int x_g, int y_g) {
    m_x_grid = x_g ? x_g : 1;
    m_y_grid = y_g ? y_g : 1;
}

const QDomDocument ElementScene::toXml(bool all_parts)
{
    QRectF size= elementSceneGeometricRect();

        //if the element doesn't contains the origin point of the scene
        //we move the element to the origin for solve this default before saving
    if (!size.contains(0,0) && all_parts)
    {
        centerElementToOrigine();
            //recalcul the size after movement
        size= elementSceneGeometricRect();
    }

        //define the size of the element by the upper multiple of 10
    int upwidth = ((qRound(size.width())/10)*10)+10;
    if ((qRound(size.width())%10) > 6) upwidth+=10;

    int upheight = ((qRound(size.height())/10)*10)+10;
    if ((qRound(size.height())%10) > 6) upheight+=10;

        //the margin between the real size of the element and the rectangle that delimits
    int xmargin = qRound(upwidth - size.width());
    int ymargin = qRound(upheight - size.height());

        // document XML
    QDomDocument xml_document;

        //Root of xml document
    QDomElement root = xml_document.createElement("definition");
    root.setAttribute("type",        "element");
    root.setAttribute("width",       QString("%1").arg(upwidth));
    root.setAttribute("height",      QString("%1").arg(upheight));
    root.setAttribute("hotspot_x",   QString("%1").arg(-(qRound(size.x() - (xmargin/2)))));
    root.setAttribute("hotspot_y",   QString("%1").arg(-(qRound(size.y() - (ymargin/2)))));
    root.setAttribute("orientation", "dyyy"); //we keep the orientation for compatibility with previous version of qet
    root.setAttribute("version", QET::version);
    root.setAttribute("link_type", m_elmt_type);

        //Uuid used to compare two elements
    QDomElement uuid = xml_document.createElement("uuid");
    uuid.setAttribute("uuid", QUuid::createUuid().toString());
    root.appendChild(uuid);
    
        //names of element
    root.appendChild(m_names_list.toXml(xml_document));

    if (m_elmt_type == "slave" || m_elmt_type == "master")
    {
        QDomElement kindInfo = xml_document.createElement("kindInformations");
        m_elmt_kindInfo.toXml(kindInfo, "kindInformation");
        root.appendChild(kindInfo);
    }
    
    if(m_elmt_type == "simple" || m_elmt_type == "master" || m_elmt_type == "terminal")
    {
        QDomElement element_info = xml_document.createElement("elementInformations");
        m_elmt_information.toXml(element_info, "elementInformation");
        root.appendChild(element_info);
    }
    
        //complementary information about the element
    QDomElement informations_element = xml_document.createElement("informations");
    root.appendChild(informations_element);
    informations_element.appendChild(xml_document.createTextNode(informations()));
    
    QDomElement description = xml_document.createElement("description");

        //the graphic description of the element
    foreach(QGraphicsItem *qgi, zItems())
    {
            //If the export concerns only the selection, the not selected part is ignored
        if (!all_parts && !qgi -> isSelected()) continue;
        if (CustomElementPart *ce = dynamic_cast<CustomElementPart *>(qgi))
        {
            if (ce -> isUseless()) continue;
            description.appendChild(ce -> toXml(xml_document));
        }
    }
    root.appendChild(description);
    
    xml_document.appendChild(root);
    return(xml_document);
}

QRectF ElementScene::boundingRectFromXml(const QDomDocument &xml_document) {
    // charge les parties depuis le document XML
    ElementContent loaded_content = loadContent(xml_document);
    if (loaded_content.isEmpty()) return(QRectF());
    
    // calcule le boundingRect
    QRectF bounding_rect = elementContentBoundingRect(loaded_content);
    
    // detruit les parties chargees
    qDeleteAll(loaded_content);
    
    return(bounding_rect);
}

void ElementScene::fromXml(const QDomDocument &xml_document, const QPointF &position, bool consider_informations, ElementContent *content_ptr)
{
    bool state = true;
    
        //Consider the informations of the element
    if (consider_informations) {
        state = applyInformations(xml_document);
    }
    
    if (state)
    {
        ElementContent loaded_content = loadContent(xml_document);
        if (position != QPointF())
            addContentAtPos(loaded_content, position);
        else
            addContent(loaded_content);
        
        if (content_ptr)
            *content_ptr = loaded_content;
    }
}

QRectF ElementScene::elementSceneGeometricRect() const{
    QRectF esgr;
    foreach (QGraphicsItem *qgi, items()) {
        if (qgi->type() == ElementPrimitiveDecorator::Type) continue;
        if (qgi->type() == QGraphicsRectItem::Type) continue;
        if (qgi->type() == PartDynamicTextField::Type) continue;
        if (CustomElementPart *cep = dynamic_cast <CustomElementPart*> (qgi)) {
            esgr |= cep -> sceneGeometricRect();
        }
    }
    return (esgr);
}

bool ElementScene::containsTerminals() const {
    foreach(QGraphicsItem *qgi,items()) {
        if (qgraphicsitem_cast<PartTerminal *>(qgi)) {
            return(true);
        }
    }
    return(false);
}

QUndoStack &ElementScene::undoStack() {
    return(m_undo_stack);
}

QGIManager &ElementScene::qgiManager() {
    return(m_qgi_manager);
}

bool ElementScene::clipboardMayContainElement() {
    QString clipboard_text = QApplication::clipboard() -> text().trimmed();
    bool may_be_element = clipboard_text.startsWith("<definition") && clipboard_text.endsWith("</definition>");
    return(may_be_element);
}

bool ElementScene::wasCopiedFromThisElement(const QString &clipboard_content) {
    return(clipboard_content == m_last_copied);
}

void ElementScene::cut() {
    copy();
    QList<QGraphicsItem *> cut_content = selectedItems();
    clearSelection();
    undoStack().push(new CutPartsCommand(this, cut_content));
}

void ElementScene::copy() {
    // accede au presse-papier
    QClipboard *clipboard = QApplication::clipboard();
    
    // genere la description XML de la selection
    QString clipboard_content = toXml(false).toString(4);
    
    // met la description XML dans le presse-papier
    if (clipboard -> supportsSelection()) {
        clipboard -> setText(clipboard_content, QClipboard::Selection);
    }
    clipboard -> setText(clipboard_content);
    
    // retient le dernier contenu copie
    m_last_copied = clipboard_content;
}

QETElementEditor* ElementScene::editor() const {
    return m_element_editor;
}

void ElementScene::setElementInfo(const DiagramContext& dc)
{
    if(m_elmt_information != dc)
    {
        m_elmt_information = dc;
        emit elementInfoChanged();
    }
}

void ElementScene::slot_select(const ElementContent &content)
{
    blockSignals(true);
    
    //Befor clear selection, we must to remove the handlers items in @content,
    //because if in @content there are a selected item, but also its handlers items,
    //When item is deselected, the item delete its handlers items,
    //then handlers in content doesn't exist anymore and cause segfault
    QList<QGraphicsItem*> items_list;
    for (QGraphicsItem *qgi : content)
    {
        if(qgi->type() != QetGraphicsHandlerItem::Type)
            items_list << qgi;
    }
    clearSelection();

    foreach(QGraphicsItem *qgi, items_list)
        qgi -> setSelected(true);
    
    blockSignals(false);
    emit(selectionChanged());
}

void ElementScene::slot_selectAll() {
    slot_select(items());
}

void ElementScene::slot_deselectAll() {
    slot_select(ElementContent());
}

void ElementScene::slot_invertSelection() {
    blockSignals(true);
    foreach(QGraphicsItem *qgi, items()) qgi -> setSelected(!qgi -> isSelected());
    blockSignals(false);
    emit(selectionChanged());
}

void ElementScene::slot_delete() {
    // verifie qu'il y a qqc de selectionne
    QList<QGraphicsItem *> selected_items = selectedItems();
    if (selected_items.isEmpty()) return;
    
    // efface tout ce qui est selectionne
    m_undo_stack.push(new DeletePartsCommand(this, selected_items));
    
    // removing items does not trigger QGraphicsScene::selectionChanged()
    emit(partsRemoved());
    emit(selectionChanged());
}

void ElementScene::slot_editAuthorInformations() {
    bool is_read_only = m_element_editor && m_element_editor -> isReadOnly();
    
    // cree un dialogue
    QDialog dialog_author(m_element_editor);
    dialog_author.setModal(true);
#ifdef Q_OS_MAC
    dialog_author.setWindowFlags(Qt::Sheet);
#endif
    dialog_author.setMinimumSize(400, 260);
    dialog_author.setWindowTitle(tr("Éditer les informations sur l'auteur", "window title"));
    QVBoxLayout *dialog_layout = new QVBoxLayout(&dialog_author);
    
    // ajoute un champ explicatif au dialogue
    QLabel *information_label = new QLabel(tr("Vous pouvez utiliser ce champ libre pour mentionner les auteurs de l'élément, sa licence, ou tout autre renseignement que vous jugerez utile."));
    information_label -> setAlignment(Qt::AlignJustify | Qt::AlignVCenter);
    information_label -> setWordWrap(true);
    dialog_layout -> addWidget(information_label);
    
    // ajoute un QTextEdit au dialogue
    QTextEdit *text_field = new QTextEdit();
    text_field -> setAcceptRichText(false);
    text_field -> setPlainText(informations());
    text_field -> setReadOnly(is_read_only);
    dialog_layout -> addWidget(text_field);
    
    // ajoute deux boutons au dialogue
    QDialogButtonBox *dialog_buttons = new QDialogButtonBox(is_read_only ? QDialogButtonBox::Ok : QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
    dialog_layout -> addWidget(dialog_buttons);
    connect(dialog_buttons, SIGNAL(accepted()),    &dialog_author, SLOT(accept()));
    connect(dialog_buttons, SIGNAL(rejected()),    &dialog_author, SLOT(reject()));
    
    // lance le dialogue
    if (dialog_author.exec() == QDialog::Accepted && !is_read_only) {
        QString new_infos = text_field -> toPlainText().remove(QChar(13)); // CR-less text
        if (new_infos != informations()) {
            undoStack().push(new ChangeInformationsCommand(this, informations(), new_infos));
        }
    }
}

void  ElementScene::slot_editProperties()
{
    QString type = m_elmt_type;
    DiagramContext kind_info = m_elmt_kindInfo;
    DiagramContext elmt_info = m_elmt_information;
    
    ElementPropertiesEditorWidget epew(type, kind_info, elmt_info);
    epew.exec();
    
    if (type != m_elmt_type ||
        kind_info != m_elmt_kindInfo ||
        elmt_info != m_elmt_information)
        undoStack().push(new ChangePropertiesCommand(this, type, kind_info, elmt_info));
}

void ElementScene::slot_editNames()
{
    bool is_read_only = m_element_editor && m_element_editor -> isReadOnly();
    
    NameListDialog dialog_(m_element_editor);
    
    dialog_.setModal(true);
    dialog_.setMinimumSize(400, 330);
    dialog_.setWindowTitle(tr("Éditer les noms", "window title"));
    
    dialog_.setInformationText(tr("Vous pouvez spécifier le nom de l'élément dans plusieurs langues."));
    
    NameListWidget *nlw_ = dialog_.namelistWidget();
    nlw_->setNames(m_names_list);
    nlw_->setReadOnly(is_read_only);
    
    if (dialog_.exec() == QDialog::Accepted && !is_read_only && !nlw_->isEmpty())
    {
        NamesList new_names = nlw_->names();
        if (new_names != m_names_list) {
            undoStack().push(new ChangeNamesCommand(this, m_names_list, new_names));
        }
    }
}

QList<CustomElementPart *> ElementScene::primitives() const {
    QList<CustomElementPart *> primitives_list;
    foreach (QGraphicsItem *item, items()) {
        if (CustomElementPart *primitive = dynamic_cast<CustomElementPart *>(item)) {
            primitives_list << primitive;
        }
    }
    return(primitives_list);
}

QList<QGraphicsItem *> ElementScene::zItems(ItemOptions options) const {
    // handle dummy request, i.e. when neither Selected nor NonSelected are set
    if (!(options & ElementScene::Selected) && !(options & ElementScene::NonSelected)) {
        return(QList<QGraphicsItem *>());
    }
    
    // retrieve all items
    QList<QGraphicsItem *> all_items_list(items());
    QMutableListIterator<QGraphicsItem *> i(all_items_list);
    
    // remove unrequired items
    if ((options & ElementScene::SelectedOrNot) != ElementScene::SelectedOrNot) {
        bool keep_selected = options & ElementScene::Selected;
        while (i.hasNext()) {
            if (i.next() -> isSelected() != keep_selected) {
                i.remove();
            }
        }
    }
    
    QList<QGraphicsItem *> terminals;
    QList<QGraphicsItem *> helpers;
    for (i.toFront(); i.hasNext(); ) {
        i.next();
        QGraphicsItem *qgi = i.value();
        if (
            qgi -> type() == ElementPrimitiveDecorator::Type ||
            qgi -> type() == QGraphicsRectItem::Type ||
            qgi->type() == QetGraphicsHandlerItem::Type
        ) {
            i.remove();
            helpers << qgi;
        }
        else if (qgraphicsitem_cast<PartTerminal *>(qgi)) {
            i.remove();
            terminals << qgi;
        }
    }
    
    // ordonne les parties par leur zValue
    if (options & SortByZValue) {
        std::sort (all_items_list.begin(), all_items_list.end(), ElementScene::zValueLessThan);
    }
    
    // rajoute eventuellement les bornes
    if (options & ElementScene::IncludeTerminals) {
        all_items_list += terminals;
    }
    if (options & ElementScene::IncludeHelperItems) {
        all_items_list += helpers;
    }
    return(all_items_list);
}

ElementContent ElementScene::selectedContent() const {
    ElementContent content;
    foreach(QGraphicsItem *qgi, zItems()) {
        if (qgi -> isSelected()) content << qgi;
    }
    return(content);
}

void ElementScene::getPasteArea(const QRectF &to_paste) {
    // on le dessine sur la scene
    m_paste_area -> setRect(to_paste);
    addItem(m_paste_area);
    
    // on passe la scene en mode "recherche de zone pour copier/coller"
    m_behavior = PasteArea;
}

void ElementScene::reset()
{
    clearSelection();
    undoStack().clear();

        //We don't add handlers, because it's the role of the primitive or decorator to remove it.
    QList<QGraphicsItem*> items_list;
    for (QGraphicsItem *qgi : items())
    {
        if(qgi->type() != QetGraphicsHandlerItem::Type)
            items_list << qgi;
    }
    
    for (QGraphicsItem *qgi : items_list)
    {
        removeItem(qgi);
        qgiManager().release(qgi);
    }

    delete m_decorator;
    m_decorator = nullptr;
}

QRectF ElementScene::elementContentBoundingRect(const ElementContent &content) const {
    QRectF bounding_rect;
    foreach(QGraphicsItem *qgi, content) {
        // skip non-primitives QGraphicsItems (paste area, selection decorator)
        if (qgi -> type() == ElementPrimitiveDecorator::Type) continue;
        if (qgi -> type() == QGraphicsRectItem::Type) continue;
        bounding_rect |= qgi -> sceneBoundingRect();
    }
    return(bounding_rect);
}

bool ElementScene::applyInformations(const QDomDocument &xml_document)
{
        // Root must be an element definition
    QDomElement root = xml_document.documentElement();
    
    if (root.tagName() != "definition" || root.attribute("type") != "element")
        return(false);

        //Extract info about element type
    m_elmt_type = root.attribute("link_type", "simple");
    m_elmt_kindInfo.fromXml(root.firstChildElement("kindInformations"), "kindInformation");
        //Extract info of element
    m_elmt_information.fromXml(root.firstChildElement("elementInformations"), "elementInformation");

    //Extract names of xml definition
    m_names_list.fromXml(root);
    
    //extract additional informations
    setInformations(QString());
    for (QDomNode node = root.firstChild() ; !node.isNull() ; node = node.nextSibling()) {
        QDomElement elmt = node.toElement();
        if (elmt.isNull()) continue;
        if (elmt.tagName() == "informations") {
            setInformations(elmt.text());
            break;
        }
    }
    
    return(true);
}

ElementContent ElementScene::loadContent(const QDomDocument &xml_document)
{
    ElementContent loaded_parts;
    
        //The root is supposed to be an element definition
    QDomElement root = xml_document.documentElement();
    
    if (root.tagName() != "definition" || root.attribute("type") != "element")
        return(loaded_parts);
    
        //Load the graphic description of the element
    for (QDomNode node = root.firstChild() ; !node.isNull() ; node = node.nextSibling())
    {
        QDomElement elmts = node.toElement();
        if (elmts.isNull())
            continue;
        
        if (elmts.tagName() == "description")
        {
            int z = 1;
            for (QDomNode n = node.firstChild() ; !n.isNull() ; n = n.nextSibling())
            {
                QDomElement qde = n.toElement();
                if (qde.isNull())
                    continue;
                CustomElementPart *cep = nullptr;
                PartDynamicTextField *pdtf = nullptr;
                
                if      (qde.tagName() == "line")     cep = new PartLine     (m_element_editor);
                else if (qde.tagName() == "rect")     cep = new PartRectangle(m_element_editor);
                else if (qde.tagName() == "ellipse")  cep = new PartEllipse  (m_element_editor);
                else if (qde.tagName() == "circle")   cep = new PartEllipse  (m_element_editor);
                else if (qde.tagName() == "polygon")  cep = new PartPolygon  (m_element_editor);
                else if (qde.tagName() == "terminal") cep = new PartTerminal (m_element_editor);
                else if (qde.tagName() == "text")     cep = new PartText     (m_element_editor);
                else if (qde.tagName() == "arc")      cep = new PartArc      (m_element_editor);
                else if (qde.tagName() == "dynamic_text") cep = new PartDynamicTextField (m_element_editor);
                    //For the input (aka the old text field) we try to convert it to the new partDynamicTextField
                else if (qde.tagName() == "input") cep = pdtf = new PartDynamicTextField(m_element_editor);
                else continue;
                
                if (QGraphicsItem *qgi = dynamic_cast<QGraphicsItem *>(cep))
                {
                    if (!qgi->zValue())
                        qgi->setZValue(z++);
                    
                    loaded_parts<<qgi;
                    
                    if(pdtf)
                        pdtf->fromTextFieldXml(qde);
                    else
                        cep->fromXml(qde);
                }
                else
                    delete cep;
            }
        }
    }
    
    return(loaded_parts);
}

ElementContent ElementScene::addContent(const ElementContent &content) {
    foreach(QGraphicsItem *part, content) {
        addPrimitive(part);
    }
    return(content);
}

ElementContent ElementScene::addContentAtPos(const ElementContent &content, const QPointF &pos) {
    // calcule le boundingRect du contenu a ajouter
    QRectF bounding_rect = elementContentBoundingRect(content);
    
    // en deduit le decalage a appliquer aux parties pour les poser au point demander
    QPointF offset = pos - bounding_rect.topLeft();
    
    // ajoute les parties avec le decalage adequat
    foreach(QGraphicsItem *part, content) {
        part -> setPos(part -> pos() + offset);
        addPrimitive(part);
    }
    return(content);
}

void ElementScene::addPrimitive(QGraphicsItem *primitive) {
    if (!primitive) return;
    addItem(primitive);
}

void ElementScene::initPasteArea() {
    m_paste_area = new QGraphicsRectItem();
    m_paste_area -> setZValue(1000000);
    
    QPen paste_area_pen;
    paste_area_pen.setStyle(Qt::DashDotLine);
    paste_area_pen.setColor(QColor(30, 56, 86, 255));
    
    QBrush paste_area_brush;
    paste_area_brush.setStyle(Qt::SolidPattern);
    paste_area_brush.setColor(QColor(90, 167, 255, 64));
    
    m_paste_area -> setPen(paste_area_pen);
    m_paste_area -> setBrush(paste_area_brush);
}

QPointF ElementScene::snapToGrid(QPointF point) {
    point.rx() = qRound(point.x() / m_x_grid) * m_x_grid;
    point.ry() = qRound(point.y() / m_y_grid) * m_y_grid;
    return point;
}

bool ElementScene::zValueLessThan(QGraphicsItem *item1, QGraphicsItem *item2) {
    return(item1-> zValue() < item2 -> zValue());
}

void ElementScene::centerElementToOrigine() {
    QRectF size= elementSceneGeometricRect();
    int center_x = qRound(size.center().x());
    int center_y = qRound(size.center().y());

    //define the movement of translation
    int move_x = center_x - (center_x %10);
    if (center_x < 0) move_x -= 10;
    int move_y = center_y - (center_y %10);
    if (center_y < 0) move_y -= 10;

        //move each primitive by @move
        foreach (QGraphicsItem *qgi, items()) {
            if (qgi -> type() == ElementPrimitiveDecorator::Type) continue;
            if (qgi -> type() == QGraphicsRectItem::Type) continue;
            //deselect item for disable decorator
            qgi -> setSelected(false);
            qgi -> moveBy(-(move_x), -(move_y));
        }
        emit (needZoomFit());
}

void ElementScene::managePrimitivesGroups()
{
        //this function is not supposed to be reentrant
    if (!m_decorator_lock->tryLock())
        return;
    
    if (!m_decorator)
    {
        m_decorator = new ElementPrimitiveDecorator();
        connect(m_decorator, SIGNAL(actionFinished(ElementEditionCommand*)), this, SLOT(stackAction(ElementEditionCommand *)));
        addItem(m_decorator);
        m_decorator -> hide();
    }
    
        // should we hide the decorator?
    QList<QGraphicsItem *> selected_items = zItems(ElementScene::Selected | ElementScene::IncludeTerminals);
    if (selected_items.size() <= 1)
    {
        m_decorator -> hide();
    }
    else
    {
        for(QGraphicsItem *qgi : selected_items)
        {
                //We recall set selected, then every primitive will remove there handler because there are several item selected
            qgi->setSelected(true);
        }
        m_decorator -> setZValue(1000000);
        m_decorator -> setPos(0, 0);
        m_decorator -> setItems(selected_items);
    }
    m_decorator_lock -> unlock();
}

void ElementScene::stackAction(ElementEditionCommand *command) {
    if (command -> elementScene()) {
        if (command -> elementScene() != this) return;
    } else {
        command -> setElementScene(this);
    }
    
    if (!command -> elementView()) {
        foreach (QGraphicsView *view, views()) {
            if (ElementView *element_view = dynamic_cast<ElementView *>(view)) {
                command -> setElementView(element_view);
                break;
            }
        }
    }
    
    undoStack().push(command);
}