diagramcommands.h

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/>.
*/
#ifndef DIAGRAM_COMMANDS_H
#define DIAGRAM_COMMANDS_H

#include "borderproperties.h"
#include "qetgraphicsitem/conductor.h"
#include "diagramcontent.h"
#include "qet.h"
#include "qetgraphicsitem/qetshapeitem.h"
#include "conductorprofile.h"
#include "diagram.h"
#include "undocommand/deleteqgraphicsitemcommand.h"

class DiagramTextItem;
class Element;
class IndependentTextItem;
class DiagramImageItem;
class QetGraphicsItem;

template <typename QGI>
class AddItemCommand : public QUndoCommand {
    public:
        AddItemCommand(QGI item, Diagram *diagram, const QPointF &pos = QPointF(), QUndoCommand *parent = nullptr) :
            QUndoCommand (parent),
            m_item (item),
            m_diagram (diagram),
            m_pos(pos)
        {
            setText(QObject::tr("Ajouter ") + itemText(item));
            m_diagram -> qgiManager().manage(m_item);
        }

        ~AddItemCommand() override {
            m_diagram -> qgiManager().release(m_item);
        }

        void undo() override {
            m_diagram -> showMe();
            m_diagram -> removeItem(m_item);
            QUndoCommand::undo();
        }

        void redo() override {
            m_diagram -> showMe();
            m_diagram -> addItem(m_item);
            m_item    -> setPos(m_pos);
            QUndoCommand::redo();
        }

    private:
        QGI m_item;
        Diagram *m_diagram;
        QPointF m_pos;
};

//Return a string to describe a QGraphicsItem
QString itemText(const QetGraphicsItem     *item);
QString itemText(const IndependentTextItem *item);
QString itemText(const Conductor           *item);

class PasteDiagramCommand : public QUndoCommand {
    // constructors, destructor
    public:
    PasteDiagramCommand(Diagram *, const DiagramContent &, QUndoCommand * = nullptr);
    ~PasteDiagramCommand() override;
    private:
    PasteDiagramCommand(const PasteDiagramCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    
    // attributes
    private:
    DiagramContent content;
    Diagram *diagram;
    int filter;
    bool first_redo;
};

class CutDiagramCommand : public DeleteQGraphicsItemCommand {
    // constructors, destructor
    public:
    CutDiagramCommand(Diagram *, const DiagramContent &, QUndoCommand * = nullptr);
    ~CutDiagramCommand() override;
    private:
    CutDiagramCommand(const CutDiagramCommand &);
};

class MoveElementsCommand : public QUndoCommand {
        // constructors, destructor
    public:
        MoveElementsCommand(Diagram *, const DiagramContent &, const QPointF &m, QUndoCommand * = nullptr);
        ~MoveElementsCommand() override;
    private:
        MoveElementsCommand(const MoveElementsCommand &);
    
        // methods
    public:
        void undo() override;
        void redo() override;
        virtual void move(const QPointF &);

    private:
        void setupAnimation (QObject * target, const QByteArray &propertyName, const QVariant& start, const QVariant& end);
    
    // attributes
    private:
    Diagram *diagram;
    DiagramContent content_to_move;
    QPointF movement;
    QParallelAnimationGroup *m_anim_group;
    bool first_redo;
};

class MoveConductorsTextsCommand : public QUndoCommand {
    // constructors, destructor
    public:
    MoveConductorsTextsCommand(Diagram *, QUndoCommand * = nullptr);
    ~MoveConductorsTextsCommand() override;
    private:
    MoveConductorsTextsCommand(const MoveConductorsTextsCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    virtual void addTextMovement(ConductorTextItem *, const QPointF &, const QPointF &, bool = false);
    
    private:
    void regenerateTextLabel();
    
    // attributes
    private:
    Diagram *diagram;
    QHash<ConductorTextItem *, QPair<QPointF, bool> > texts_to_move_;
    bool first_redo;
};

class ChangeDiagramTextCommand : public QUndoCommand {
    // constructors, destructor
    public:
    ChangeDiagramTextCommand(DiagramTextItem *, const QString &before, const QString &after, QUndoCommand * = nullptr);
    ~ChangeDiagramTextCommand() override;
    private:
    ChangeDiagramTextCommand(const ChangeDiagramTextCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    
    // attributes
    private:
    DiagramTextItem *text_item;
    QString text_before;
    QString text_after;
    bool first_redo;
    Diagram *diagram;
};

class ChangeConductorCommand : public QUndoCommand {
    // constructors, destructor
    public:
    ChangeConductorCommand(Conductor *, const ConductorProfile &, const ConductorProfile &, Qt::Corner, QUndoCommand * = nullptr);
    ~ChangeConductorCommand() override;
    private:
    ChangeConductorCommand(const ChangeConductorCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    virtual void setConductorTextItemMove(const QPointF &, const QPointF &);
    
    // attributes
    private:
    Conductor *conductor;
    ConductorProfile old_profile;
    ConductorProfile new_profile;
    Qt::Corner path_type;
    QPointF text_pos_before_mov_;
    QPointF text_pos_after_mov_;
    bool first_redo;
    Diagram *diagram;
};

class ResetConductorCommand : public QUndoCommand {
    // constructors, destructor
    public:
    ResetConductorCommand(const QHash<Conductor *, ConductorProfilesGroup> &, QUndoCommand * = nullptr);
    ~ResetConductorCommand() override;
    private:
    ResetConductorCommand(const ResetConductorCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    
    // attributes
    private:
    QHash<Conductor *, ConductorProfilesGroup> conductors_profiles;
    Diagram *diagram;
};



class ChangeBorderCommand : public QUndoCommand {
    // constructors, destructor
    public:
    ChangeBorderCommand(Diagram *, const BorderProperties &, const BorderProperties &, QUndoCommand * = nullptr);
    ~ChangeBorderCommand() override;
    private:
    ChangeBorderCommand(const ChangeBorderCommand &);
    
    // methods
    public:
    void undo() override;
    void redo() override;
    
    // attributes
    private:
    Diagram *diagram;
    public:
    BorderProperties old_properties;
    BorderProperties new_properties;
};

#endif