diagramcommands.h

Go to the documentation of this file.

/*
        Copyright 2006-2020 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