Move several items : shape item now move with the others selected item

git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@3140 bfdf4180-ca20-0410-9c96-a3a8aa849046

sources/diagramcommands.cpp

@@ -401,12 +401,13 @@ CutDiagramCommand::~CutDiagramCommand() {
 }
 
 /**
-	Constructeur
-	@param dia Schema sur lequel on deplace des elements
-	@param diagram_content Contenu a deplacer
-	@param m translation subie par les elements
-	@param parent QUndoCommand parent
-*/
+ * @brief MoveElementsCommand::MoveElementsCommand
+ * Constructor
+ * @param dia diagram
+ * @param diagram_content diagram content (contain all items to be moved)
+ * @param m movement to applied
+ * @param parent parent undo command
+ */
 MoveElementsCommand::MoveElementsCommand(
 	Diagram *dia,
 	const DiagramContent &diagram_content,
@@ -438,17 +439,24 @@ MoveElementsCommand::MoveElementsCommand(
 	);
 }
 
-/// Destructeur
+/**
+ * @brief MoveElementsCommand::~MoveElementsCommand
+ * Destructor
+ */
 MoveElementsCommand::~MoveElementsCommand() {
 }
 
-/// annule le deplacement
+/**
+ * @brief MoveElementsCommand::undo
+ */
 void MoveElementsCommand::undo() {
 	diagram -> showMe();
 	move(-movement);
 }
 
-/// refait le deplacement
+/**
+ * @brief MoveElementsCommand::redo
+ */
 void MoveElementsCommand::redo() {
 	diagram -> showMe();
 	if (first_redo) first_redo = false;
@@ -456,52 +464,27 @@ void MoveElementsCommand::redo() {
 }
 
 /**
-	deplace les elements et conducteurs
-	@param actual_movement translation a effectuer sur les elements et conducteurs
-*/
+ * @brief MoveElementsCommand::move
+ * Move item and conductor to @actual_movement
+ * @param actual_movement movement to be applied
+ */
 void MoveElementsCommand::move(const QPointF &actual_movement) {
-	// deplace les elements
-	foreach(Element *element, content_to_move.elements) {
-		element -> setPos(element -> pos() + actual_movement);
+	typedef DiagramContent dc;
+
+	//Move every movable item, except conductor
+	foreach (QGraphicsItem *qgi, content_to_move.items(dc::Elements | dc::TextFields | dc::Images | dc::Shapes)) {
+		qgi -> setPos(qgi->pos() + actual_movement);
 	}
 	
-	// deplace certains conducteurs
+	// Move some conductors
 	foreach(Conductor *conductor, content_to_move.conductorsToMove) {
 		conductor -> setPos(conductor -> pos() + actual_movement);
 	}
 	
-	// recalcule les autres conducteurs
+	// Recalcul the path of other conductor
 	foreach(Conductor *conductor, content_to_move.conductorsToUpdate) {
 		conductor -> updatePath();
 	}
-	
-	// repositionne les textes des conducteurs mis a jour
-	foreach(ConductorTextItem *text_item, moved_conductor_texts_.keys()) {
-		// determine s'il s'agit d'un undo ou d'un redo
-		qreal coef = actual_movement.x() / movement.x();
-		// -1 : undo, 1 : redo
-		QPointF desired_pos = coef > 0 ? moved_conductor_texts_[text_item].second : moved_conductor_texts_[text_item].first;
-		text_item -> setPos(desired_pos);
-	}
-	
-	// deplace les textes
-	foreach(DiagramTextItem *text, content_to_move.textFields) {
-		text -> setPos(text -> pos() + actual_movement);
-	}
-
-	// deplace les images
-	foreach (DiagramImageItem *dii, content_to_move.images) {
-		dii -> setPos(dii -> pos() + actual_movement);
-	}
-
-	// deplace les shapes
-	foreach (QetShapeItem *dsi, content_to_move.shapes) {
-		dsi -> setPos(dsi -> pos() + actual_movement);
-		/*QRectF rec = dsi -> boundingRect();
-		rec.translate(actual_movement);
-		dsi -> setBoundingRect(rec);
-		dsi -> setPos(dsi -> pos() - actual_movement);*/
-	}
 }
 
 /**

sources/elementsmover.cpp

@@ -25,8 +25,8 @@
 #include "qetgraphicsitem/diagramimageitem.h"
 
 /**
-	Constructeur
-*/
+ * @brief ElementsMover::ElementsMover Constructor
+ */
 ElementsMover::ElementsMover() :
 	movement_running_(false),
 	current_movement_(),
@@ -38,50 +38,46 @@ ElementsMover::ElementsMover() :
 }
 
 /**
-	Destructeur
-*/
+ * @brief ElementsMover::~ElementsMover Destructor
+ */
 ElementsMover::~ElementsMover() {
 }
 
 /**
-	@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.
-*/
+ * @brief ElementsMover::isReady
+ * @return True if this element mover is ready to be used.
+ * A element mover is ready when the previous managed movement is finish.
+ */
 bool ElementsMover::isReady() const {
 	return(!movement_running_);
 }
 
 /**
-	Demarre un nouveau mouvement d'element
-	@param diagram Schema sur lequel se deroule le deplacement
-	@param driver_item Item deplace par la souris et ne necessitant donc pas
-	d'etre deplace lors des appels a continueMovement.
-	@return le nombre d'items concernes par le deplacement, ou -1 si le
-	mouvement n'a pas ete initie
-*/
+ * @brief ElementsMover::beginMovement
+ * Start a new movement
+ * @param diagram diagram where the movement is applied
+ * @param driver_item item moved by mouse and don't be moved by Element mover
+ * @return the numbers of items to be moved or -1 if movement can't be init.
+ */
 int ElementsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item) {
-	// il ne doit pas y avoir de mouvement en cours
+	// They must be no movement in progress
 	if (movement_running_) return(-1);
 	
-	// on s'assure que l'on dispose d'un schema pour travailler
+	// Be sure we have diagram to work
 	if (!diagram) return(-1);
 	diagram_ = diagram;
 	
-	// on prend en compte le driver_item
+	// Take count of driver item
 	movement_driver_ = driver_item;
 	
-	// au debut du mouvement, le deplacement est nul
+	// At the beginning of movement, move is NULL
 	current_movement_ = QPointF(0.0, 0.0);
 	
-	// on stocke dans cet objet les items concernes par le deplacement
 	moved_content_ = diagram -> selectedContent();
 	
-	// on a egalement besoin de retenir la position des champs de textes
-	// rattaches a un conducteur (ConductorTextItem) si cette position a ete
-	// personnalisee.
-	// ceci n'est necessaire que pour les conducteurs dont le trajet sera
-	// recalcule a cause du mouvement
+	/* We need to save the position of conductor text (ConductorTextItem)
+	 * if the position is defined by user
+	 * It's needed only for conductors whose the path will be recalculated */
 	foreach(Conductor *conductor, moved_content_.conductorsToUpdate) {
 		if (ConductorTextItem *text_item = conductor -> textItem()) {
 			if (text_item -> wasMovedByUser()) {
@@ -92,82 +88,62 @@ int ElementsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item) {
 			}
 		}
 	}
-	// on s'assure qu'il y a quelque chose a deplacer
+
 	if (!moved_content_.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
+	/* At this point, we've got all info to manage movement.
+	 * There is now a move in progress */
 	movement_running_ = true;
 	
 	return(moved_content_.count());
 }
 
 /**
-	Ajoute un mouvement au deplacement en cours. Cette methode
-	@param movement mouvement a ajouter au deplacement en cours
-*/
+ * @brief ElementsMover::continueMovement
+ * Add a move to the current movement.
+ * @param movement movement to applied
+ */
 void ElementsMover::continueMovement(const QPointF &movement) {
-	// un mouvement doit avoir ete initie
-	if (!movement_running_) return;
-	
-	// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret
-	if (movement.isNull()) return;
-	
-	// prise en compte du mouvement
+	if (!movement_running_ || movement.isNull()) return;
+
 	current_movement_ += movement;
-	
-	// deplace les elements selectionnes
-	foreach(Element *element, moved_content_.elements) {
-		if (movement_driver_ && element == movement_driver_) continue;
-		element -> setPos(element -> pos() + movement);
+
+	//Move every movable item, except conductor
+	typedef DiagramContent dc;
+	foreach (QGraphicsItem *qgi, moved_content_.items(dc::Elements | dc::TextFields | dc::Images | dc::Shapes)) {
+		if (qgi == movement_driver_) continue;
+		qgi -> setPos(qgi->pos() + movement);
 	}
 	
-	// deplace certains conducteurs
+	// Move some conductors
 	foreach(Conductor *conductor, moved_content_.conductorsToMove) {
 		conductor -> setPos(conductor -> pos() + movement);
 	}
 	
-	// recalcule les autres conducteurs
+	// Recalcul the path of other conductors
 	foreach(Conductor *conductor, moved_content_.conductorsToUpdate) {
 		conductor -> updatePath();
 	}
-	
-	// deplace les champs de texte
-	foreach(IndependentTextItem *text_field, moved_content_.textFields) {
-		if (movement_driver_ && text_field == movement_driver_) continue;
-		text_field -> setPos(text_field -> pos() + movement);
-	}
-
-	//deplace les images
-	foreach(DiagramImageItem *dii, moved_content_.images) {
-		if (movement_driver_ && dii == movement_driver_) continue;
-		dii -> setPos(dii -> pos() + movement);
-	}
-
 }
 
 /**
-	Termine le deplacement en creant un objet d'annulation et en l'ajoutant a
-	la QUndoStack du schema concerne.
-	@see Diagram::undoStack()
-*/
+ * @brief ElementsMover::endMovement
+ * Ended the current movement by creating an undo added to the undostack of the diagram.
+ */
 void ElementsMover::endMovement() {
-	// un mouvement doit avoir ete initie
+	// A movement must be inited
 	if (!movement_running_) return;
 	
-	// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret
+	// No need of an undo command if the movement is NULL
 	if (!current_movement_.isNull()) {
-		// cree un objet d'annulation pour le mouvement ainsi realise
+		// Create an undo object for this new movement
 		MoveElementsCommand *undo_object = new MoveElementsCommand(
 			diagram_,
 			moved_content_,
 			current_movement_
 		);
 		
-		// ajoute les informations necessaires au repositionnement des champs
-		// de textes des conducteurs
+		// Add info needed to the position of conductors texte
 		foreach(ConductorTextItem *text_item, updated_conductors_text_pos_.keys()) {
 			if (text_item -> pos() != updated_conductors_text_pos_[text_item]) {
 				undo_object -> addConductorTextItemMovement(
@@ -181,6 +157,6 @@ void ElementsMover::endMovement() {
 		diagram_ -> undoStack().push(undo_object);
 	}
 	
-	// il n'y a plus de mouvement en cours
+	// There is no movement in progress now
 	movement_running_ = false;
 }

sources/elementsmover.h

@@ -23,7 +23,15 @@ class ConductorTextItem;
 class Diagram;
 /**
 	This class manages the interactive movement of different items (elements,
-	conductors, text items) on a particular diagram.
+	conductors, text items etc...) on a particular diagram.
+
+	A movement work in 3 steps:
+	1: beginMovement    -> init a new movement
+	2: continueMovement -> continue the curent movement
+	3: endMovement      -> finish the curent movement
+
+	A movement in progress must finish befor start a new movement. We can know if
+	element mover is ready for a new movement by calling isReady().
 */
 class ElementsMover {
 	// constructors, destructor