elementtextitemgroup.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 "elementtextitemgroup.h"
#include "dynamicelementtextitem.h"
#include "element.h"
#include "diagram.h"
#include "addelementtextcommand.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"
#include "crossrefitem.h"
#include "qetapp.h"
#include "masterelement.h"
#include "qgraphicsitemutility.h"

#include <QPainter>
#include <QGraphicsSceneMouseEvent>
#include <utility>

bool sorting(QGraphicsItem *qgia, QGraphicsItem *qgib)
{
    return qgia->pos().y() < qgib->pos().y();
}

ElementTextItemGroup::ElementTextItemGroup(const QString &name, Element *parent) :
    QGraphicsItemGroup(parent),
    m_name(name),
    m_parent_element(parent)
{
    setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
    connect(parent, &Element::linkedElementChanged, this, &ElementTextItemGroup::updateXref);
}

ElementTextItemGroup::~ElementTextItemGroup()
{}

void ElementTextItemGroup::addToGroup(QGraphicsItem *item)
{
    if(item->type() == DynamicElementTextItem::Type)
    {
            //Befor add text to this group we must to set the text at the same rotation of this group       
        if((item->rotation() != rotation()) && !m_block_alignment_update)
            item->setRotation(rotation());
        
        QGraphicsItemGroup::addToGroup(item);
        updateAlignment();
        
        DynamicElementTextItem *deti = qgraphicsitem_cast<DynamicElementTextItem *>(item);
        connect(deti, &DynamicElementTextItem::fontChanged,      this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::textChanged,          this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::textFromChanged,      this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::infoNameChanged,      this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::compositeTextChanged, this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::plainTextChanged,     this, &ElementTextItemGroup::updateAlignment);
        connect(deti, &DynamicElementTextItem::textWidthChanged,     this, &ElementTextItemGroup::updateAlignment);
        
        connect(deti, &DynamicElementTextItem::textFromChanged, this, &ElementTextItemGroup::updateXref);
        connect(deti, &DynamicElementTextItem::infoNameChanged, this, &ElementTextItemGroup::updateXref);
        
        updateXref();
    }
}

void ElementTextItemGroup::removeFromGroup(QGraphicsItem *item)
{
    QGraphicsItemGroup::removeFromGroup(item);
        //the item transformation is not reseted, we must to do it, because for exemple if the group rotation is 45°
        //When item is removed from group, visually the item is unchanged (so 45°) but if we call item->rotation() the returned value is 0.
    item->resetTransform();
    item->setRotation(this->rotation());
    item->setFlag(QGraphicsItem::ItemIsSelectable, true);
    updateAlignment();
    
    if(DynamicElementTextItem *deti = qgraphicsitem_cast<DynamicElementTextItem *>(item))
    {
        disconnect(deti, &DynamicElementTextItem::fontChanged,      this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::textChanged,          this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::textFromChanged,      this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::infoNameChanged,      this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::compositeTextChanged, this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::plainTextChanged,     this, &ElementTextItemGroup::updateAlignment);
        disconnect(deti, &DynamicElementTextItem::textWidthChanged,     this, &ElementTextItemGroup::updateAlignment);
        
        disconnect(deti, &DynamicElementTextItem::textFromChanged, this, &ElementTextItemGroup::updateXref);
        disconnect(deti, &DynamicElementTextItem::infoNameChanged, this, &ElementTextItemGroup::updateXref);
        
        updateXref();
    }
}

void ElementTextItemGroup::blockAlignmentUpdate(bool block)
{
    m_block_alignment_update = block;
}

void ElementTextItemGroup::setAlignment(Qt::Alignment alignement)
{
    m_alignment = alignement;
    updateAlignment();
    emit alignmentChanged(alignement);
}

Qt::Alignment ElementTextItemGroup::alignment() const
{
    return m_alignment;
}

void ElementTextItemGroup::updateAlignment()
{
    if(m_block_alignment_update)
        return;
    
    prepareGeometryChange();
    
    QList <DynamicElementTextItem *> texts = this->texts();
    
    qreal rotation_ = rotation();
    
        //Set the rotation of this group to 0° relative to the scene
    qreal rot = rotation();
    QGraphicsItem *parent = parentItem();
    while (parent) {
        rot += parent->rotation();
        parent = parent->parentItem();
    }
    if(rot != 0)
        setRotation(rotation() - rot);
    
    
    if(texts.size() == 1)
    {
        prepareGeometryChange();
        
        QGraphicsItem *first = texts.first();
        setPos(mapFromScene(first->mapToScene(pos())));
        first->setPos(0,0);
    }
    else if (texts.size() > 1)
    {
        qreal width = 0;
        for(QGraphicsItem *item : texts)
            if(item->boundingRect().width() > width)
                width = item->boundingRect().width();
        
        prepareGeometryChange();
        std::sort(texts.begin(), texts.end(), sorting);
        
        qreal y_offset = 0;
        
        if(m_alignment == Qt::AlignLeft)
        {
            QPointF ref = texts.first()->pos();
                
            for(QGraphicsItem *item : texts)
            {
                item->setPos(0, ref.y()+y_offset);
                y_offset+=item->boundingRect().height() + m_vertical_adjustment;
            }
        }
        else if(m_alignment == Qt::AlignVCenter)
        {
            QPointF ref(width/2,0);
            
            for(QGraphicsItem *item : texts)
            {
                item->setPos(ref.x() - item->boundingRect().width()/2,
                             ref.y() + y_offset);
                y_offset+=item->boundingRect().height() + m_vertical_adjustment;
            }   
        }
        else if (m_alignment == Qt::AlignRight)
        {
            QPointF ref(width,0);
            
            for(QGraphicsItem *item : texts)
            {
                item->setPos(ref.x() - item->boundingRect().width(),
                             ref.y() + y_offset);
                y_offset+=item->boundingRect().height() + m_vertical_adjustment;
            }
        }
    }
    
        //Restor the rotation
    setRotation(rotation_);
    
    if(m_Xref_item)
        m_Xref_item->autoPos();
    if(m_slave_Xref_item)
        adjustSlaveXrefPos();
    if(m_hold_to_bottom_of_page)
        autoPos();
}

void ElementTextItemGroup::setVerticalAdjustment(int v)
{
    prepareGeometryChange();
    m_vertical_adjustment = v;
    updateAlignment();
    emit verticalAdjustmentChanged(v);
}

void ElementTextItemGroup::setName(QString name)
{
    m_name = std::move(name);
    emit nameChanged(m_name);
}

void ElementTextItemGroup::setHoldToBottomPage(bool hold)
{
    if(m_hold_to_bottom_of_page == hold)
        return;
    
    m_hold_to_bottom_of_page = hold;
    if(m_hold_to_bottom_of_page)
    {
        setFlag(QGraphicsItem::ItemIsSelectable, false);
        setFlag(QGraphicsItem::ItemIsMovable, false);
        connect(m_parent_element, &Element::yChanged, this, &ElementTextItemGroup::autoPos);
        connect(m_parent_element, &Element::rotationChanged, this, &ElementTextItemGroup::autoPos);
        if(m_parent_element->linkType() == Element::Master)
        {
                //We use timer to let the time of the parent element xref to be updated, befor update the position of this group
                //because the position of this group is related to the size of the parent element Xref
            m_linked_changed_timer = connect(m_parent_element, &Element::linkedElementChanged,
                                             [this]() {QTimer::singleShot(200, this, &ElementTextItemGroup::autoPos);});
            if(m_parent_element->diagram())
                m_XrefChanged_timer = connect(m_parent_element->diagram()->project(), &QETProject::XRefPropertiesChanged,
                                              [this]()  {QTimer::singleShot(200, this, &ElementTextItemGroup::autoPos);});
        }
        autoPos();
    }
    else
    {
        setFlag(QGraphicsItem::ItemIsSelectable, true);
        setFlag(QGraphicsItem::ItemIsMovable, true);
        disconnect(m_parent_element, &Element::yChanged, this, &ElementTextItemGroup::autoPos);
        disconnect(m_parent_element, &Element::rotationChanged, this, &ElementTextItemGroup::autoPos);
        if(m_parent_element->linkType() == Element::Master)
        {
            disconnect(m_linked_changed_timer);
            if(m_XrefChanged_timer)
                disconnect(m_XrefChanged_timer);
        }
    }
    
    emit holdToBottomPageChanged(hold);
}

void ElementTextItemGroup::setFrame(const bool frame)
{
    m_frame = frame;
    update();
    emit frameChanged(m_frame);
}

bool ElementTextItemGroup::frame() const {
    return m_frame;
}

QList<DynamicElementTextItem *> ElementTextItemGroup::texts() const
{
    QList<DynamicElementTextItem *> list;
    for(QGraphicsItem *qgi : childItems())
    {
        if(qgi->type() == DynamicElementTextItem::Type)
            list << static_cast<DynamicElementTextItem *>(qgi);
    }
    return list;
}

Diagram *ElementTextItemGroup::diagram() const
{
    if(scene())
        return static_cast<Diagram *>(scene());
    else
        return nullptr;
}

Element *ElementTextItemGroup::parentElement() const
{
    if(parentItem() && parentItem()->type() == Element::Type)
        return static_cast<Element *>(parentItem());
    else
        return nullptr;
}

QDomElement ElementTextItemGroup::toXml(QDomDocument &dom_document) const
{
    QDomElement dom_element = dom_document.createElement(this->xmlTaggName());
    dom_element.setAttribute("name", m_name);
    
    dom_element.setAttribute("x", QString::number(pos().x()));
    dom_element.setAttribute("y", QString::number(pos().y()));

    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    dom_element.setAttribute("alignment", me.valueToKey(m_alignment));
    
    dom_element.setAttribute("rotation", this->rotation());
    dom_element.setAttribute("vertical_adjustment", m_vertical_adjustment);
    dom_element.setAttribute("frame", m_frame? "true" : "false");
    
    dom_element.setAttribute("hold_to_bottom_page", m_hold_to_bottom_of_page == true ? "true" : "false");
    
    QDomElement dom_texts = dom_document.createElement("texts");
    for(DynamicElementTextItem *deti : texts())
    {
        QDomElement text = dom_document.createElement("text");
        text.setAttribute("uuid", deti->uuid().toString());
        dom_texts.appendChild(text);
    }
    
    dom_element.appendChild(dom_texts);
    return dom_element;
}

void ElementTextItemGroup::fromXml(QDomElement &dom_element)
{
    if (dom_element.tagName() != xmlTaggName()) {
        qDebug() << "ElementTextItemGroup::fromXml : Wrong tagg name";
        return;
    }
    
    setName(dom_element.attribute("name", "no name"));
    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    setAlignment(Qt::Alignment(me.keyToValue(dom_element.attribute("alignment").toStdString().data())));
    
    setPos(dom_element.attribute("x", QString::number(0)).toDouble(),
           dom_element.attribute("y", QString::number(0)).toDouble());
    
    setRotation(dom_element.attribute("rotation", QString::number(0)).toDouble());
    setVerticalAdjustment(dom_element.attribute("vertical_adjustment").toInt());
    setFrame(dom_element.attribute("frame", "false") == "true"? true : false);
    
    QString hold = dom_element.attribute("hold_to_bottom_page", "false");
    setHoldToBottomPage(hold == "true" ? true : false);
    
    if(parentElement())
    {
        m_block_alignment_update = true;
        for(const QDomElement& text : QET::findInDomElement(dom_element, "texts", "text"))
        {
            DynamicElementTextItem *deti = nullptr;
            QUuid uuid(text.attribute("uuid"));
            
            for(DynamicElementTextItem *txt : parentElement()->dynamicTextItems())
                if(txt->uuid() == uuid)
                    deti = txt;
            
            if (deti)
                parentElement()->addTextToGroup(deti, this);
        }
        m_block_alignment_update = false;
    }
}

void ElementTextItemGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    Q_UNUSED(option);
    Q_UNUSED(widget);
    if(isSelected())
    {
        painter->save();
        QPen t;
        t.setColor(Qt::gray);
        t.setStyle(Qt::DashDotLine);
        t.setCosmetic(true);
        painter->setPen(t);
        painter->drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10);
        
        painter->restore();
    }
    if(m_frame)
    {       
        qreal font_size = 1;
        QRectF rect;
        for(DynamicElementTextItem *deti : this->texts())
        {
            font_size = std::max(font_size, deti->font().pointSizeF());
            rect = rect.united(mapFromItem(deti, deti->frameRect()).boundingRect());
        }
        
            //Adjust the thickness according to the font size
        qreal w=0.3;
        if (font_size >= 5)
        {
            w = font_size*0.1;
            if(w > 2.5)
                w = 2.5;
        }
        
        painter->save();
        QPen pen;
        pen.setWidthF(w);
        painter->setPen(pen);
        painter->setRenderHint(QPainter::Antialiasing);
        
            //Adjust the rounding of the rectangle according to the size of the font
        qreal ro = font_size/3;
        painter->drawRoundedRect(rect, ro, ro);
        painter->restore();
    }
}

QRectF ElementTextItemGroup::boundingRect() const
{
        //If we refer to the Qt doc, the bounding rect of a QGraphicsItemGroup,
        //is the bounding of all childrens in the group
        //When add an item in the group, the bounding rect is good, but
        //if we move an item already in the group, the bounding rect of the group stay unchanged.
        //We reimplement this function to avoid this behavior.
    QRectF rect;
    for(QGraphicsItem *qgi : texts())
    {       
        QRectF r(qgi->pos(), QSize(qgi->boundingRect().width(), qgi->boundingRect().height()));
        rect = rect.united(r);
    }
    return rect;
}

void ElementTextItemGroup::setRotation(qreal angle)
{   
    QGraphicsItemGroup::setRotation(angle);
    emit rotationChanged(angle);
}

void ElementTextItemGroup::setPos(const QPointF &pos)
{
    QPointF old_pos = this->pos();
    QGraphicsItemGroup::setPos(pos);
    if (old_pos.x() != this->pos().x())
        emit xChanged();
    if (old_pos.y() != this->pos().y())
        emit yChanged();
}

void ElementTextItemGroup::setPos(qreal x, qreal y)
{
    QPointF old_pos = this->pos();
    QGraphicsItemGroup::setPos(x,y);
    if (old_pos.x() != this->pos().x())
        emit xChanged();
    if (old_pos.y() != this->pos().y())
        emit yChanged();
}

void ElementTextItemGroup::mousePressEvent(QGraphicsSceneMouseEvent *event)
{   
    if(event->button() == Qt::LeftButton)
    {
        m_first_move = true;
        if(event->modifiers() & Qt::ControlModifier)
            setSelected(!isSelected());
    }
    
    QGraphicsItemGroup::mousePressEvent(event);
}

void ElementTextItemGroup::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if((event->buttons() & Qt::LeftButton) && (flags() & ItemIsMovable))
    {
        if(diagram() && m_first_move)
            diagram()->elementTextsMover().beginMovement(diagram(), this);
        
        if(m_first_move)
        {
            m_initial_position = pos();
            if(parentElement())
                parentElement()->setHighlighted(true);
        }
        
        QPointF current_parent_pos;
        QPointF button_down_parent_pos;
        current_parent_pos = mapToParent(mapFromScene(event->scenePos()));
        button_down_parent_pos = mapToParent(mapFromScene(event->buttonDownScenePos(Qt::LeftButton)));
        
        QPointF new_pos = m_initial_position + current_parent_pos - button_down_parent_pos;
        event->modifiers() == Qt::ControlModifier ? setPos(new_pos) : setPos(Diagram::snapToGrid(new_pos));
        
        if(diagram())
            diagram()->elementTextsMover().continueMovement(event);
    } else {
        event->ignore();
    }
    
    if(m_first_move)
        m_first_move = false;
}

void ElementTextItemGroup::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if(diagram())
    {
        diagram()->elementTextsMover().endMovement();
        if(parentElement())
            parentElement()->setHighlighted(false);
    }
    
    if(!(event->modifiers() & Qt::ControlModifier))
        QGraphicsItemGroup::mouseReleaseEvent(event);
}

void ElementTextItemGroup::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
{
    if(m_slave_Xref_item)
    {
        if(m_slave_Xref_item->boundingRect().contains(mapToItem(m_slave_Xref_item, event->pos())))
        {
            if(parentElement()->linkType() == Element::Slave && !parentElement()->linkedElements().isEmpty())
            {
                m_slave_Xref_item->setDefaultTextColor(Qt::black);
                Element *elmt = parentElement()->linkedElements().first();
                
                    //Unselect and ungrab mouse to prevent unwanted
                    //move when linked element is in the same scene of this.
                setSelected(false);
                ungrabMouse();
                
                if(scene() != elmt->scene())
                    elmt->diagram()->showMe();
                elmt->setSelected(true);
                
                    //Zoom to the element
                for(QGraphicsView *view : elmt->scene()->views())
                {
                    QRectF fit = elmt->sceneBoundingRect();
                    fit.adjust(-200, -200, 200, 200);
                    view->fitInView(fit, Qt::KeepAspectRatioByExpanding);
                }
            }
        }
    }
}

void ElementTextItemGroup::keyPressEvent(QKeyEvent *event)
{   
    if(event->modifiers() == Qt::ControlModifier)
    {
        if(event->key() == Qt::Key_Left && m_alignment  != Qt::AlignLeft)
        {
            if(diagram())
                diagram()->undoStack().push(new AlignmentTextsGroupCommand(this, Qt::AlignLeft));
            else
                setAlignment(Qt::AlignLeft);
        }
        else if (event->key() == Qt::Key_Up && m_alignment  != Qt::AlignVCenter)
        {
            if(diagram())
                diagram()->undoStack().push(new AlignmentTextsGroupCommand(this, Qt::AlignVCenter));
            else
                setAlignment(Qt::AlignVCenter);
        }
        else if (event->key() == Qt::Key_Right && m_alignment   != Qt::AlignRight)
        {
            if(diagram())
                diagram()->undoStack().push(new AlignmentTextsGroupCommand(this, Qt::AlignRight));
            else
                setAlignment(Qt::AlignRight);
        }
    }
    event->ignore();
}

void ElementTextItemGroup::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
        //The pos of the event is not in this item coordinate,
        //but in child item hovered by the mouse, so we use the scene pos.
    if(m_slave_Xref_item &&
       m_slave_Xref_item->boundingRect().contains(m_slave_Xref_item->mapFromScene(event->scenePos())))
        m_slave_Xref_item->setDefaultTextColor(Qt::blue);
    
    QGraphicsItemGroup::hoverEnterEvent(event);
}

void ElementTextItemGroup::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
{
    if(m_slave_Xref_item)
        m_slave_Xref_item->setDefaultTextColor(Qt::black);
    
    QGraphicsItemGroup::hoverLeaveEvent(event);
}

void ElementTextItemGroup::updateXref()
{
    if(m_parent_element->diagram())
    {
        QETProject *project = m_parent_element->diagram()->project();
        
        if(m_parent_element->linkType() == Element::Master &&
           !m_parent_element->linkedElements().isEmpty())
        {
            
            XRefProperties xrp = project->defaultXRefProperties(m_parent_element->kindInformations()["type"].toString());
            
            if(xrp.snapTo() == XRefProperties::Label)
            {
                    //At least one text owned by this group must be set with
                    //textFrom -> element info and element info name -> label
                    //for display a xref
                for(DynamicElementTextItem *deti : texts())
                {
                    if(deti->textFrom() == DynamicElementTextItem::ElementInfo &&
                       deti->infoName() == "label")
                    {
                        if(!m_Xref_item)
                            m_Xref_item = new CrossRefItem(m_parent_element, this);
                        m_Xref_item->autoPos();
                        return;
                    }
                }
            }
        }
        else if(m_parent_element->linkType() == Element::Slave &&
                !m_parent_element->linkedElements().isEmpty())
        {
            Element *master_elmt = m_parent_element->linkedElements().first();
            for(DynamicElementTextItem *deti : texts())
            {
                if((deti->textFrom() == DynamicElementTextItem::ElementInfo && deti->infoName() == "label") ||
                   (deti->textFrom() == DynamicElementTextItem::CompositeText && deti->compositeText().contains("%{label")))
                {
                    XRefProperties xrp = project->defaultXRefProperties(master_elmt->kindInformations()["type"].toString());
                    QString xref_label = xrp.slaveLabel();
                    xref_label = autonum::AssignVariables::formulaToLabel(xref_label, master_elmt->rSequenceStruct(), master_elmt->diagram(), master_elmt);
                    
                    if(!m_slave_Xref_item)
                    {
                        m_slave_Xref_item = new QGraphicsTextItem(xref_label, this);
                        m_slave_Xref_item->setFont(QETApp::diagramTextsFont(5));
                        
                        m_update_slave_Xref_connection << connect(master_elmt, &Element::xChanged,                       this, &ElementTextItemGroup::updateXref);
                        m_update_slave_Xref_connection << connect(master_elmt, &Element::yChanged,                       this, &ElementTextItemGroup::updateXref);
                        m_update_slave_Xref_connection << connect(master_elmt, &Element::elementInfoChange,              this, &ElementTextItemGroup::updateXref);
                        m_update_slave_Xref_connection << connect(project,     &QETProject::projectDiagramsOrderChanged, this, &ElementTextItemGroup::updateXref);
                        m_update_slave_Xref_connection << connect(project,     &QETProject::diagramRemoved,              this, &ElementTextItemGroup::updateXref);
                        m_update_slave_Xref_connection << connect(project,     &QETProject::XRefPropertiesChanged,       this, &ElementTextItemGroup::updateXref);
                    }
                    else
                        m_slave_Xref_item->setPlainText(xref_label);
                    
                    adjustSlaveXrefPos();
                    return;
                }
            }
        
        }
    }

    
        //There is no reason to have a xref, we delete it if exist
    if(m_Xref_item)
    {
        delete m_Xref_item;
        m_Xref_item = nullptr;  
    }
    if(m_slave_Xref_item)
    {
        delete m_slave_Xref_item;
        m_slave_Xref_item = nullptr;
        m_update_slave_Xref_connection.clear();
    }
}

void ElementTextItemGroup::adjustSlaveXrefPos()
{
    QRectF r = boundingRect();
    QPointF pos(r.center().x() - m_slave_Xref_item->boundingRect().width()/2,
                r.bottom());
    m_slave_Xref_item->setPos(pos);
}

void ElementTextItemGroup::autoPos()
{
    int offset = 5;
    
    if(m_parent_element->linkType() == Element::Master)
    {
        if(!diagram())
            return;
        
        MasterElement *master = static_cast<MasterElement *>(m_parent_element);
        XRefProperties xrp = diagram()->project()->defaultXRefProperties(master->kindInformations()["type"].toString());
        if(xrp.snapTo() == XRefProperties::Bottom)
        {
            QRectF rectXref = master->XrefBoundingRect();
            offset = xrp.offset() <= 40 ? 5 : xrp.offset();
            
            offset += (int)rectXref.height();
        }
    }
    qreal r = rotation();
    centerToBottomDiagram(this, m_parent_element, offset);
        //centerToBottomDiagram change the rotation of this group if needed,
        //but setRotation is not a virtual function of QGraphicsItem, and the function centerToBottomDiagram
        //work with a QGraphicsItem. So we emit the signal if rotation changed
    if(rotation() != r)
        emit rotationChanged(rotation());
}