parttext.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 "parttext.h"
#include "texteditor.h"
#include "elementprimitivedecorator.h"
#include "elementscene.h"
#include "qetapp.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"

PartText::PartText(QETElementEditor *editor, QGraphicsItem *parent) :
    QGraphicsTextItem(parent),
    CustomElementPart(editor),
    previous_text()
{
    document() -> setDocumentMargin(1.0);
    setDefaultTextColor(Qt::black);
    setFont(QETApp::diagramTextsFont());
    real_font_size_ = font().pointSize();
    setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges | QGraphicsItem::ItemIsMovable);
    setAcceptHoverEvents(true);
    setDefaultTextColor(Qt::black);
    setPlainText(QObject::tr("T", "default text when adding a text in the element editor"));
    
    adjustItemPosition(1);
    // adjust textfield position after line additions/deletions
    connect(document(), SIGNAL(blockCountChanged(int)), this, SLOT(adjustItemPosition(int)));
    connect(document(), SIGNAL(contentsChanged()),      this, SLOT(adjustItemPosition()));
}

PartText::~PartText() {
}

void PartText::fromXml(const QDomElement &xml_element)
{
    bool ok;

    if (xml_element.hasAttribute("size"))
    {
        int font_size = xml_element.attribute("size").toInt(&ok);
        if (!ok || font_size < 1) {
            font_size = 20;
        }
        QFont font_ = this->font();
        font_.setPointSize(font_size);
        setFont(font_);
    }
    else if (xml_element.hasAttribute("font"))
    {
        QFont font_;
        font_.fromString(xml_element.attribute("font"));
        setFont(font_);
    }
    
    setDefaultTextColor(QColor(xml_element.attribute("color", "#000000")));
    setPlainText(xml_element.attribute("text"));
    setPos(xml_element.attribute("x").toDouble(),
           xml_element.attribute("y").toDouble());
    setRotation(xml_element.attribute("rotation", QString::number(0)).toDouble());
}

const QDomElement PartText::toXml(QDomDocument &xml_document) const
{
    QDomElement xml_element = xml_document.createElement(xmlName());

    xml_element.setAttribute("x", QString::number(pos().x()));
    xml_element.setAttribute("y", QString::number(pos().y()));
    xml_element.setAttribute("text", toPlainText());
    xml_element.setAttribute("font", font().toString());
    xml_element.setAttribute("rotation", QString::number(rotation()));
    xml_element.setAttribute("color", defaultTextColor().name());

    return(xml_element);
}

QPointF PartText::margin() const
{
    QFont used_font = font();
    QFontMetrics qfm(used_font);
    qreal document_margin = document() -> documentMargin();
    
    QPointF margin(
        // marge autour du texte
        document_margin,
        // marge au-dessus du texte + distance entre le plafond du texte et la baseline
        document_margin + qfm.ascent()
    );
    return(margin);
}

void PartText::focusInEvent(QFocusEvent *e) {
    startEdition();
    QGraphicsTextItem::focusInEvent(e);
}


void PartText::focusOutEvent(QFocusEvent *e) {
    QGraphicsTextItem::focusOutEvent(e);
    endEdition();
}

void PartText::keyPressEvent(QKeyEvent *event) {
    if (event -> key() == Qt::Key_Escape) {
        endEdition();
    }
    else {
        QGraphicsTextItem::keyPressEvent(event);
    }
}

void PartText::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *e) {
    QGraphicsTextItem::mouseDoubleClickEvent(e);
    if (e -> button() == Qt::LeftButton) {
        setEditable(true);
    }
}

QVariant PartText::itemChange(GraphicsItemChange change, const QVariant &value) {
    if (change == QGraphicsItem::ItemPositionHasChanged || change == QGraphicsItem::ItemSceneHasChanged) {
        updateCurrentPartEditor();
    } else if (change == QGraphicsItem::ItemSelectedHasChanged) {
        if (value.toBool() == true) {
            updateCurrentPartEditor();
        }
    }
    return(QGraphicsTextItem::itemChange(change, value));
}

QRectF PartText::boundingRect() const {
    QRectF r = QGraphicsTextItem::boundingRect();
    r.adjust(0.0, -1.1, 0.0, 0.0);
    return(r);
}

bool PartText::isUseless() const {
    return(toPlainText().isEmpty());
}

QRectF PartText::sceneGeometricRect() const {
    return(sceneBoundingRect());
}

void PartText::startUserTransformation(const QRectF &rect) {
    Q_UNUSED(rect)
    saved_point_ = pos(); // scene coordinates, no need to mapFromScene()
    saved_font_size_ = real_font_size_;
}

void PartText::handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect) {
    // let's try the naive approach
    QPointF new_pos = mapPoints(initial_selection_rect, new_selection_rect, QList<QPointF>() << saved_point_).first();
    setPos(new_pos);
    
    // adjust the font size following the vertical scale factor
    qreal sy = new_selection_rect.height() / initial_selection_rect.height();
    qreal new_font_size = saved_font_size_ * sy;
    setProperty("real_size", qMax(1, qRound(new_font_size)));
}

void PartText::setDefaultTextColor(const QColor &color)
{
    if (color != this->defaultTextColor())
    {
        QGraphicsTextItem::setDefaultTextColor(color);
        emit colorChanged(color);
    }
}

void PartText::setPlainText(const QString &text)
{
    if (text != this->toPlainText())
    {
        QGraphicsTextItem::setPlainText(text);
        emit plainTextChanged(text);
    }
}

void PartText::setFont(const QFont &font)
{
    if (font != this->font())
    {
        QGraphicsTextItem::setFont(font);
        emit fontChanged(font);
    }
}


void PartText::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if((event->buttons() & Qt::LeftButton) && (flags() & QGraphicsItem::ItemIsMovable))
    {
        QPointF pos = event->scenePos() + (m_origine_pos - event->buttonDownScenePos(Qt::LeftButton));
        event->modifiers() == Qt::ControlModifier ? setPos(pos) : setPos(elementScene()->snapToGrid(pos));
    }
    else
        QGraphicsObject::mouseMoveEvent(event);
}

void PartText::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if(event->button() == Qt::LeftButton)
        m_origine_pos = this->pos();

    QGraphicsObject::mousePressEvent(event);
}

void PartText::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if((event->button() & Qt::LeftButton) && (flags() & QGraphicsItem::ItemIsMovable) && m_origine_pos != pos())
    {
        QPropertyUndoCommand *undo = new QPropertyUndoCommand(this, "pos", QVariant(m_origine_pos), QVariant(pos()));
        undo->setText(tr("Déplacer un texte"));
        undo->enableAnimation();
        elementScene()->undoStack().push(undo);
    }

    QGraphicsObject::mouseReleaseEvent(event);
}

void PartText::adjustItemPosition(int new_block_count) {
    Q_UNUSED(new_block_count);
    QPointF origin_offset = margin();
    
    QTransform base_translation;
    base_translation.translate(-origin_offset.x(), -origin_offset.y());
    setTransform(base_translation, false);
    setTransformOriginPoint(origin_offset);
}

void PartText::setEditable(bool editable) {
    if (editable) {
        setFlag(QGraphicsItem::ItemIsFocusable, true);
        setTextInteractionFlags(Qt::TextEditorInteraction);
        setFocus(Qt::MouseFocusReason);
    }
    else {
        setTextInteractionFlags(Qt::NoTextInteraction);
        setFlag(QGraphicsItem::ItemIsFocusable, false);
    }
}

void PartText::startEdition() {
    // !previous_text.isNull() means the text is being edited
    previous_text = toPlainText();
}

void PartText::endEdition()
{
    if (!previous_text.isNull())
    {
            // the text was being edited
        QString new_text = toPlainText();
        if (previous_text != new_text)
        {
            QPropertyUndoCommand *undo = new QPropertyUndoCommand(this, "text", previous_text, new_text);
            undo->setText(tr("Modifier un champ texte"));
            undoStack().push(undo);
            previous_text = QString();
        }
    }

    // deselectionne le texte
    QTextCursor qtc = textCursor();
    qtc.clearSelection();
    setTextCursor(qtc);

    setEditable(false);
}