editorcommands.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 "editorcommands.h"

ElementEditionCommand::ElementEditionCommand(ElementScene *scene, ElementView *view, QUndoCommand *parent):
    QUndoCommand(parent),
    m_scene(scene),
    m_view(view)
{
}

ElementEditionCommand::ElementEditionCommand(const QString &text, ElementScene *scene, ElementView *view, QUndoCommand *parent):
    QUndoCommand(text, parent),
    m_scene(scene),
    m_view(view)
{
}

ElementEditionCommand::~ElementEditionCommand() {
}

ElementScene *ElementEditionCommand::elementScene() const {
    return(m_scene);
}

void ElementEditionCommand::setElementScene(ElementScene *scene) {
    m_scene = scene;
}

ElementView *ElementEditionCommand::elementView() const {
    return(m_view);
}

void ElementEditionCommand::setElementView(ElementView *view) {
    m_view = view;
}

/*** DeletePartsCommand ***/
DeletePartsCommand::DeletePartsCommand(
    ElementScene *scene,
    const QList<QGraphicsItem *>& parts,
    QUndoCommand *parent
) :
    ElementEditionCommand(QObject::tr("suppression", "undo caption"), scene, nullptr, parent),
    deleted_parts(parts)
{
    foreach(QGraphicsItem *qgi, deleted_parts) {
        m_scene -> qgiManager().manage(qgi);
    }
}

DeletePartsCommand::~DeletePartsCommand() {
    foreach(QGraphicsItem *qgi, deleted_parts) {
        m_scene -> qgiManager().release(qgi);
    }
}

void DeletePartsCommand::undo() {
    m_scene -> blockSignals(true);
    foreach(QGraphicsItem *qgi, deleted_parts) {
        m_scene -> addItem(qgi);
    }
    m_scene -> blockSignals(false);
}

void DeletePartsCommand::redo() {
    m_scene -> blockSignals(true);
    foreach(QGraphicsItem *qgi, deleted_parts) {
        m_scene -> removeItem(qgi);
    }
    m_scene -> blockSignals(false);
}

/*** CutPartsCommand ***/
PastePartsCommand::PastePartsCommand(
    ElementView *view,
    const ElementContent &c,
    QUndoCommand *parent
) :
    ElementEditionCommand(view ? view -> scene() : nullptr, view, parent),
    content_(c),
    uses_offset(false),
    first_redo(true)
{
    setText(QObject::tr("coller"));
    m_scene -> qgiManager().manage(content_);
}

PastePartsCommand::~PastePartsCommand() {
    m_scene -> qgiManager().release(content_);
}

void PastePartsCommand::undo() {
    // enleve les parties
    m_scene -> blockSignals(true);
    foreach(QGraphicsItem *part, content_) {
        m_scene -> removeItem(part);
    }
    m_scene -> blockSignals(false);
    if (uses_offset) {
        m_view -> offset_paste_count_    = old_offset_paste_count_;
        m_view -> start_top_left_corner_ = old_start_top_left_corner_;
    }
    m_view -> adjustSceneRect();
}

void PastePartsCommand::redo() {
    if (first_redo) first_redo = false;
    else {
        // pose les parties
        m_scene -> blockSignals(true);
        foreach(QGraphicsItem *part, content_) {
            m_scene -> addItem(part);
        }
        m_scene -> blockSignals(false);
        if (uses_offset) {
            m_view -> offset_paste_count_    = new_offset_paste_count_;
            m_view -> start_top_left_corner_ = new_start_top_left_corner_;
        }
    }
    m_scene -> slot_select(content_);
    m_view -> adjustSceneRect();
}

void PastePartsCommand::setOffset(int old_offset_pc, const QPointF &old_start_tlc, int new_offset_pc, const QPointF &new_start_tlc) {
    old_offset_paste_count_    = old_offset_pc;
    old_start_top_left_corner_ = old_start_tlc;
    new_offset_paste_count_    = new_offset_pc;
    new_start_top_left_corner_ = new_start_tlc;
    uses_offset = true;
}

/*** CutPartsCommand ***/
CutPartsCommand::CutPartsCommand(
    ElementScene *scene,
    const QList<QGraphicsItem *>& parts,
    QUndoCommand *parent
) :
    DeletePartsCommand(scene, parts, parent)
{
    setText(QString(QObject::tr("couper des parties", "undo caption")));
}

CutPartsCommand::~CutPartsCommand() {
}

/*** MovePartsCommand ***/
MovePartsCommand::MovePartsCommand(
    const QPointF &m,
    ElementScene *scene,
    const QList<QGraphicsItem *>& parts,
    QUndoCommand *parent
) :
    ElementEditionCommand(QObject::tr("déplacement", "undo caption"), scene, nullptr, parent),
    movement(m),
    first_redo(true)
{
    moved_parts = parts;
}

MovePartsCommand::~MovePartsCommand() {
}

void MovePartsCommand::undo() {
    foreach(QGraphicsItem *qgi, moved_parts) qgi -> moveBy(-movement.x(), -movement.y());
}

void MovePartsCommand::redo() {
    // le premier appel a redo, lors de la construction de l'objet, ne doit pas se faire
    if (first_redo) {
        first_redo = false;
        return;
    }
    foreach(QGraphicsItem *qgi, moved_parts) qgi -> moveBy(movement.x(), movement.y());
}

/*** AddPartCommand ***/
AddPartCommand::AddPartCommand(
    const QString &name,
    ElementScene *scene,
    QGraphicsItem *p,
    QUndoCommand *parent
) :
    ElementEditionCommand(QString(QObject::tr("ajout %1", "undo caption")).arg(name), scene, nullptr, parent),
    part(p),
    first_redo(true)
{
    m_scene -> qgiManager().manage(part);
}

AddPartCommand::~AddPartCommand() {
    m_scene -> qgiManager().release(part);
}

void AddPartCommand::undo() {
    m_scene -> removeItem(part);
}

void AddPartCommand::redo() {
    // le premier appel a redo, lors de la construction de l'objet, ne doit pas se faire
    if (first_redo) {
        if (!part -> zValue()) {
            // the added part has no specific zValue already defined, we put it
            // above existing items (but still under terminals)
            QList<QGraphicsItem *> existing_items = m_scene -> zItems(ElementScene::SortByZValue | ElementScene::SelectedOrNot);
            qreal z = existing_items.count() ? existing_items.last() -> zValue() + 1 : 1;
            part -> setZValue(z);
        }
        m_scene -> clearSelection();
        first_redo = false;
        return;
    }
    m_scene -> addItem(part);
}

ChangeNamesCommand::ChangeNamesCommand(
    ElementScene *element_scene,
    const NamesList &before,
    const NamesList &after,
    QUndoCommand *parent
) :
    ElementEditionCommand(QObject::tr("modification noms", "undo caption"), element_scene, nullptr, parent),
    names_before(before),
    names_after(after)
{
}

ChangeNamesCommand::~ChangeNamesCommand() {
}

void ChangeNamesCommand::undo() {
    m_scene -> setNames(names_before);
}

void ChangeNamesCommand::redo() {
    m_scene -> setNames(names_after);
}

ChangeZValueCommand::ChangeZValueCommand(
    ElementScene *elmt,
    QET::DepthOption o,
    QUndoCommand *parent
) :
    ElementEditionCommand(elmt, nullptr, parent),
    m_option(o)
{
    // retrieve all primitives but terminals
    QList<QGraphicsItem *> items_list = m_scene -> zItems(ElementScene::SortByZValue | ElementScene::SelectedOrNot);
    
    // prend un snapshot des zValues
    foreach(QGraphicsItem *qgi, items_list) undo_hash.insert(qgi, qgi -> zValue());
    
    // choisit le nom en fonction du traitement
    if (m_option == QET::BringForward) {
        setText(QObject::tr("amener au premier plan", "undo caption"));
        applyBringForward(items_list);
    } else if (m_option == QET::Raise) {
        setText(QObject::tr("rapprocher", "undo caption"));
        applyRaise(items_list);
    } else if (m_option == QET::Lower) {
        setText(QObject::tr("éloigner", "undo caption"));
        applyLower(items_list);
    } else if (m_option == QET::SendBackward) {
        setText(QObject::tr("envoyer au fond", "undo caption"));
        applySendBackward(items_list);
    }
}

ChangeZValueCommand::~ChangeZValueCommand() {
}

void ChangeZValueCommand::undo() {
    foreach(QGraphicsItem *qgi, undo_hash.keys()) qgi -> setZValue(undo_hash[qgi]);
}

void ChangeZValueCommand::redo() {
    foreach(QGraphicsItem *qgi, redo_hash.keys()) qgi -> setZValue(redo_hash[qgi]);
}

void ChangeZValueCommand::applyBringForward(const QList<QGraphicsItem *> &items_list) {
    QList<QGraphicsItem *> non_selected_items = items_list;
    QList<QGraphicsItem *> selected_items;
    foreach(QGraphicsItem *qgi, non_selected_items) {
        if (qgi -> isSelected()) {
            selected_items << qgi;
            non_selected_items.removeAt(non_selected_items.indexOf(qgi));
        }
    }
    int z = 1;
    foreach(QGraphicsItem *qgi, non_selected_items) redo_hash.insert(qgi, z ++);
    foreach(QGraphicsItem *qgi,     selected_items) redo_hash.insert(qgi, z ++);
}

void ChangeZValueCommand::applyRaise(const QList<QGraphicsItem *> &items_list) {
    QList<QGraphicsItem *> my_items_list = items_list;
    
    for (int i = my_items_list.count() - 2 ; i >= 0 ; -- i) {
        if (my_items_list[i] -> isSelected()) {
            if (!my_items_list[i +1] -> isSelected()) {
                my_items_list.swap(i, i + 1);
            }
        }
    }
    int z = 1;
    foreach(QGraphicsItem *qgi, my_items_list) redo_hash.insert(qgi, z ++);
}

void ChangeZValueCommand::applyLower(const QList<QGraphicsItem *> &items_list) {
    QList<QGraphicsItem *> my_items_list = items_list;
    
    for (int i = 1 ; i < my_items_list.count() ; ++ i) {
        if (my_items_list[i] -> isSelected()) {
            if (!my_items_list[i - 1] -> isSelected()) {
                my_items_list.swap(i, i - 1);
            }
        }
    }
    
    int z = 1;
    foreach(QGraphicsItem *qgi, my_items_list) redo_hash.insert(qgi, z ++);
}

void ChangeZValueCommand::applySendBackward(const QList<QGraphicsItem *> &items_list) {
    QList<QGraphicsItem *> non_selected_items = items_list;
    QList<QGraphicsItem *> selected_items;
    foreach(QGraphicsItem *qgi, non_selected_items) {
        if (qgi -> isSelected()) {
            selected_items << qgi;
            non_selected_items.removeAt(non_selected_items.indexOf(qgi));
        }
    }
    int z = 1;
    foreach(QGraphicsItem *qgi,     selected_items) redo_hash.insert(qgi, z ++);
    foreach(QGraphicsItem *qgi, non_selected_items) redo_hash.insert(qgi, z ++);
}

ChangeInformationsCommand::ChangeInformationsCommand(ElementScene *elmt, const QString &old_infos, const QString &new_infos, QUndoCommand *parent) :
    ElementEditionCommand(QObject::tr("modification informations complementaires", "undo caption"), elmt, nullptr, parent),
    old_informations_(old_infos),
    new_informations_(new_infos)
{
}

ChangeInformationsCommand::~ChangeInformationsCommand() {
}

void ChangeInformationsCommand::undo() {
    m_scene -> setInformations(old_informations_);
}

void ChangeInformationsCommand::redo() {
    m_scene -> setInformations(new_informations_);
}

ScalePartsCommand::ScalePartsCommand(ElementScene *scene, QUndoCommand * parent) :
    ElementEditionCommand(scene, nullptr, parent),
    first_redo(true)
{}

ScalePartsCommand::~ScalePartsCommand() {
}

void ScalePartsCommand::undo() {
    scale(new_rect_, original_rect_);
}

void ScalePartsCommand::redo() {
    if (first_redo) {
        first_redo = false;
        return;
    }
    scale(original_rect_, new_rect_);
}

ElementScene *ScalePartsCommand::elementScene() const {
    return(m_scene);
}

void ScalePartsCommand::setScaledPrimitives(const QList<CustomElementPart *> &primitives) {
    scaled_primitives_ = primitives;
    adjustText();
}

QList<CustomElementPart *> ScalePartsCommand::scaledPrimitives() const {
    return(scaled_primitives_);
}

void ScalePartsCommand::setTransformation(const QRectF &original_rect, const QRectF &new_rect) {
    original_rect_ = original_rect;
    new_rect_ = new_rect;
}

QPair<QRectF, QRectF> ScalePartsCommand::transformation() {
    return(QPair<QRectF, QRectF>(original_rect_, new_rect_));
}

void ScalePartsCommand::scale(const QRectF &before, const QRectF &after) {
    if (!scaled_primitives_.count()) return;
    if (before == after) return;
    if (!before.width() || !before.height()) return; // cowardly flee division by zero FIXME?
    
    foreach (CustomElementPart *part_item, scaled_primitives_) {
        part_item -> startUserTransformation(before);
        part_item -> handleUserTransformation(before, after);
    }
}

void ScalePartsCommand::adjustText() {
    if (scaled_primitives_.count() == 1) {
        setText(QObject::tr("redimensionnement %1", "undo caption -- %1 is the resized primitive type name").arg(scaled_primitives_.first() -> name()));
    } else {
        setText(QObject::tr("redimensionnement de %1 primitives", "undo caption -- %1 always > 1").arg(scaled_primitives_.count()));
    }
}
ChangePropertiesCommand::ChangePropertiesCommand(ElementScene *scene, const QString& type, const DiagramContext& info, const DiagramContext& elmt_info, QUndoCommand *parent) :
    ElementEditionCommand(scene, nullptr, parent)
{
    m_type << scene->m_elmt_type << type;
    m_kind_info << scene->m_elmt_kindInfo << info;
    m_elmt_info << scene->m_elmt_information << elmt_info;
    setText(QObject::tr("Modifier les propriétés"));
}

ChangePropertiesCommand::~ChangePropertiesCommand() {}

void ChangePropertiesCommand::undo()
{
    m_scene->m_elmt_type = m_type.first();
    m_scene->m_elmt_kindInfo = m_kind_info.first();
    m_scene->setElementInfo(m_elmt_info.first());
}

void ChangePropertiesCommand::redo()
{
    m_scene->m_elmt_type = m_type.last();
    m_scene->m_elmt_kindInfo = m_kind_info.last();
    m_scene->setElementInfo(m_elmt_info.last());
}