kotschak/qelectrotech-source-mirror
0
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2025-12-17 20:50:34 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Element text mover : use QPropertyUndoCommand instead of MoveElementsTextsCommand.

Browse Source 
Remove class MoveElementsTextsCommand


git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@4089 bfdf4180-ca20-0410-9c96-a3a8aa849046
This commit is contained in:
blacksun
2015-08-07 19:45:00 +00:00
parent 3535ee8001
commit 65b27f411a
4 changed files with 88 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
sources/diagramcommands.cpp
View File

@@ -362,65 +362,6 @@ void MoveElementsCommand::setupAnimation(QObject *target, const QByteArray &prop
m_anim_group->addAnimation(animation); m_anim_group->addAnimation(animation);
} }
/**
Constructeur
@param diagram Schema sur lequel on deplace des champs de texte
@param texts Liste des textes deplaces
@param m translation subie par les elements
@param parent QUndoCommand parent
*/
MoveElementsTextsCommand::MoveElementsTextsCommand(
Diagram *diagram,
const QSet<ElementTextItem *> &texts,
const QPointF &m,
QUndoCommand *parent
) :
QUndoCommand(parent),
diagram(diagram),
texts_to_move(texts),
movement(m),
first_redo(true)
{
QString moved_content_sentence = QET::ElementsAndConductorsSentence(0, 0, texts_to_move.count());
setText(
QString(
QObject::tr(
"déplacer %1",
"undo caption - %1 is a sentence listing the moved content"
).arg(moved_content_sentence)
)
);
}
/// Destructeur
MoveElementsTextsCommand::~MoveElementsTextsCommand() {
}
/// annule le deplacement
void MoveElementsTextsCommand::undo() {
diagram -> showMe();
move(-movement);
}
/// refait le deplacement
void MoveElementsTextsCommand::redo() {
diagram -> showMe();
if (first_redo) first_redo = false;
else move(movement);
}
/**
deplace les elements et conducteurs
@param actual_movement translation a effectuer sur les elements et conducteurs
*/
void MoveElementsTextsCommand::move(const QPointF &actual_movement) {
// deplace les textes
foreach(ElementTextItem *text, texts_to_move) {
QPointF applied_movement = text -> mapMovementToParent(text -> mapMovementFromScene(actual_movement));
text -> setPos(text -> pos() + applied_movement);
}
}
/** /**
Constructeur Constructeur
@param diagram Schema sur lequel on deplace des champs de texte @param diagram Schema sur lequel on deplace des champs de texte

27
sources/diagramcommands.h
View File

@@ -181,33 +181,6 @@ class MoveElementsCommand : public QUndoCommand {
bool first_redo; bool first_redo;
}; };
class MoveElementsTextsCommand : public QUndoCommand {
// constructors, destructor
public:
MoveElementsTextsCommand(Diagram *, const QSet<ElementTextItem *> &, const QPointF &m, QUndoCommand * = 0);
virtual ~MoveElementsTextsCommand();
private:
MoveElementsTextsCommand(const MoveElementsTextsCommand &);
// methods
public:
virtual void undo();
virtual void redo();
virtual void move(const QPointF &);
// attributes
private:
/// diagram the movement takes place on.
Diagram *diagram;
/// text items to be moved
QSet<ElementTextItem *> texts_to_move;
/// applied movement
QPointF movement;
/// prevent the first call to redo()
bool first_redo;
};
/** /**
This command moves text items related to conductors on a particular This command moves text items related to conductors on a particular
diagram. diagram.

157
sources/elementtextsmover.cpp
View File

@@ -16,126 +16,109 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>. along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "elementtextsmover.h" #include "elementtextsmover.h"
#include "conductor.h"
#include "elementtextitem.h" #include "elementtextitem.h"
#include "diagram.h" #include "diagram.h"
#include "diagramcommands.h" #include "QPropertyUndoCommand/qpropertyundocommand.h"
#include "element.h"
#include "independenttextitem.h"
/** /**
Constructeur * @brief ElementTextsMover::ElementTextsMover
*/ */
ElementTextsMover::ElementTextsMover() : ElementTextsMover::ElementTextsMover() :
movement_running_(false), movement_running_(false),
current_movement_(), diagram_(nullptr),
diagram_(0), movement_driver_(nullptr)
movement_driver_(0), {}
moved_texts_()
{
}
/** /**
Destructeur * @brief ElementTextsMover::isReady
*/ * @return true if this ElementTextsMover is ready to process a new movement.
ElementTextsMover::~ElementTextsMover() { * False if this ElementTextsMover is actually process a movement
} */
/**
@return true si ce gestionnaire de deplacement est pret a etre utilise,
false sinon. Un gestionnaire de deplacement est pret a etre utilise a partir
du moment ou le mouvement precedemment gere n'est plus en cours.
*/
bool ElementTextsMover::isReady() const { bool ElementTextsMover::isReady() const {
return(!movement_running_); return(!movement_running_);
} }
/** /**
Demarre un nouveau mouvement d'ElementTextItems * @brief ElementTextsMover::beginMovement
@param diagram Schema sur lequel se deroule le deplacement * Begin a movement
@param driver_item Item deplace par la souris et ne necessitant donc pas * @param diagram : diagram where the movement is apply
d'etre deplace lors des appels a continueMovement. * @param driver_item : item moved by the mouse
@return le nombre d'items concernes par le deplacement, ou -1 si le * @return : the number of moved text (driver_item include), or -1 if this ElementTextsMover can't begin a movement
mouvement n'a pas ete initie */
*/ int ElementTextsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item)
int ElementTextsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item) { {
// il ne doit pas y avoir de mouvement en cours if (movement_running_ || !diagram) return(-1);
if (movement_running_) return(-1);
// on s'assure que l'on dispose d'un schema pour travailler
if (!diagram) return(-1);
diagram_ = diagram; diagram_ = diagram;
// on prend en compte le driver_item
movement_driver_ = driver_item; movement_driver_ = driver_item;
m_texts_item_H.clear();
// au debut du mouvement, le deplacement est nul
current_movement_ = QPointF(0.0, 0.0); foreach(QGraphicsItem *item, diagram -> selectedItems())
{
// on stocke dans cet objet les items concernes par le deplacement if (item->type() == ElementTextItem::Type)
moved_texts_.clear(); {
foreach(QGraphicsItem *item, diagram -> selectedItems()) { ElementTextItem *eti = static_cast<ElementTextItem *> (item);
if (ElementTextItem *text_item = qgraphicsitem_cast<ElementTextItem *>(item)) { m_texts_item_H.insert(eti, eti->pos());
moved_texts_ << text_item;
} }
} }
// on s'assure qu'il y a quelque chose a deplacer if (!m_texts_item_H.size()) return(-1);
if (!moved_texts_.count()) return(-1);
// a ce stade, on dispose de toutes les informations necessaires pour
// prendre en compte les mouvements
// il y a desormais un mouvement en cours
movement_running_ = true; movement_running_ = true;
return(moved_texts_.count()); return(m_texts_item_H.size());
} }
/** /**
Ajoute un mouvement au deplacement en cours. Cette methode * @brief ElementTextsMover::continueMovement
@param movement mouvement a ajouter au deplacement en cours * Add @movement to the current movement
*/ * The movement must be in scene coordinate.
void ElementTextsMover::continueMovement(const QPointF &movement) { * @param movement
// un mouvement doit avoir ete initie */
if (!movement_running_) return; void ElementTextsMover::continueMovement(const QPointF &movement)
{
if (!movement_running_ || movement.isNull()) return;
// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret foreach(ElementTextItem *text_item, m_texts_item_H.keys())
if (movement.isNull()) return; {
if (text_item == movement_driver_) continue;
// prise en compte du mouvement
current_movement_ += movement;
// deplace les elements selectionnes
foreach(ElementTextItem *text_item, moved_texts_) {
if (movement_driver_ && text_item == movement_driver_) continue;
QPointF applied_movement = text_item -> mapMovementToParent(text_item-> mapMovementFromScene(movement)); QPointF applied_movement = text_item -> mapMovementToParent(text_item-> mapMovementFromScene(movement));
text_item -> setPos(text_item -> pos() + applied_movement); text_item -> setPos(text_item -> pos() + applied_movement);
} }
} }
/** /**
Termine le deplacement en creant un objet d'annulation et en l'ajoutant a * @brief ElementTextsMover::endMovement
la QUndoStack du schema concerne. * Finish the movement by pushing an undo command to the parent diagram of text item
@see Diagram::undoStack() */
*/ void ElementTextsMover::endMovement()
void ElementTextsMover::endMovement() { {
// un mouvement doit avoir ete initie //No movement running, or no text to move
if (!movement_running_) return; if (!movement_running_ || m_texts_item_H.isEmpty()) return;
//Movement is null
ElementTextItem *eti = m_texts_item_H.keys().first();
if (eti->pos() == m_texts_item_H.value(eti)) return;
// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret QPropertyUndoCommand *undo = nullptr;
if (!current_movement_.isNull()) {
// cree un objet d'annulation pour le mouvement ainsi realise foreach (ElementTextItem *eti, m_texts_item_H.keys())
MoveElementsTextsCommand*undo_object = new MoveElementsTextsCommand( {
diagram_, if (undo)
moved_texts_, {
current_movement_ QPropertyUndoCommand *child_undo = new QPropertyUndoCommand(eti, "pos", m_texts_item_H.value(eti), eti->pos(), undo);
); child_undo->enableAnimation();
}
diagram_ -> undoStack().push(undo_object); else
{
undo = new QPropertyUndoCommand(eti, "pos", m_texts_item_H.value(eti), eti->pos());
undo->enableAnimation();
QString txt = m_texts_item_H.size() == 1? QString(QObject::tr("Déplacer un texte d'élément")) :
QString(QObject::tr("Déplacer %1 textes d'élément").arg(m_texts_item_H.size()));
undo->setText(txt);
}
} }
diagram_->undoStack().push(undo);
// il n'y a plus de mouvement en cours
movement_running_ = false; movement_running_ = false;
} }

36
sources/elementtextsmover.h
View File

@@ -17,35 +17,35 @@
*/ */
#ifndef ELEMENT_TEXTS_MOVER_H #ifndef ELEMENT_TEXTS_MOVER_H
#define ELEMENT_TEXTS_MOVER_H #define ELEMENT_TEXTS_MOVER_H
#include <QtWidgets>
#include "diagramcontent.h" #include <QSet>
#include <QPointF>
class QGraphicsItem;
class ElementTextItem; class ElementTextItem;
class Diagram; class Diagram;
/** /**
This class manages the interactive movement of element text items on a This class manages the interactive movement of element text items on a
particular diagram. particular diagram.
*/ */
class ElementTextsMover { class ElementTextsMover
// constructors, destructor {
public: public:
ElementTextsMover(); ElementTextsMover();
virtual ~ElementTextsMover();
private: private:
ElementTextsMover(const ElementTextsMover &); ElementTextsMover(const ElementTextsMover &);
// methods
public: public:
bool isReady() const; bool isReady() const;
int beginMovement(Diagram *, QGraphicsItem * = 0); int beginMovement(Diagram *, QGraphicsItem * = 0);
void continueMovement(const QPointF &); void continueMovement(const QPointF &);
void endMovement(); void endMovement();
// attributes
private: private:
bool movement_running_; bool movement_running_;
QPointF current_movement_; Diagram *diagram_;
Diagram *diagram_; QGraphicsItem *movement_driver_;
QGraphicsItem *movement_driver_; QHash <ElementTextItem *, QPointF> m_texts_item_H;
QSet<ElementTextItem *> moved_texts_;
}; };
#endif #endif