Ajout d'une classe DiagramContent pour eviter de passer plusieurs listes en parametre lorsqu'on veut transmettre tout ou partie du contenu du schema.

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

diagram.cpp

@@ -5,6 +5,7 @@
 #include "diagram.h"
 #include "exportdialog.h"
 #include "diagramcommands.h"
+#include "diagramcontent.h"
 
 const int   Diagram::xGrid  = 10;
 const int   Diagram::yGrid  = 10;
@@ -113,16 +114,7 @@ void Diagram::keyReleaseEvent(QKeyEvent *e) {
 		!current_movement.isNull()  && !e -> isAutoRepeat()
 	) {
 		// cree un objet d'annulation pour le mouvement qui vient de se finir
-		undoStack().push(
+		undoStack().push(new MoveElementsCommand(this, selectedContent(), current_movement));
-			new MoveElementsCommand(
-				this,
-				elementsToMove(),
-				conductorsToMove(),
-				conductorsToUpdate(),
-				textsToMove(),
-				current_movement
-			)
-		);
 		invalidateMovedElements();
 		current_movement = QPointF();
 	}
@@ -300,14 +292,11 @@ QDomDocument Diagram::toXml(bool diagram) {
 	@param position La position du diagram importe
 	@param consider_informations Si vrai, les informations complementaires
 	(auteur, titre, ...) seront prises en compte
-	@param added_elements si ce pointeur vers une liste d'elements n'est pas
+	@param content_ptr si ce pointeur vers un DiagramContentn'est pas NULL, il
-	NULL, il sera rempli avec les elements ajoutes au schema par le fromXml
+	sera rempli avec le contenu ajoute au schema par le fromXml
-	@param added_conductors si ce pointeur vers une liste de conducteurs n'est
-	pas NULL, il sera rempli avec les conducteurs ajoutes au schema par le
-	fromXml
 	@return true si l'import a reussi, false sinon
 */
-bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList<Element *> *added_elements_ptr, QList<Conductor *> *added_conductors_ptr, QList<DiagramTextItem *> *added_texts_ptr) {
+bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, DiagramContent *content_ptr) {
 	QDomElement root = document.documentElement();
 	// le premier element doit etre un schema
 	if (root.tagName() != "diagram") return(false);
@@ -457,9 +446,11 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in
 	}
 	
 	// remplissage des listes facultatives
-	if (added_elements_ptr   != NULL) *added_elements_ptr   = added_elements;
+	if (content_ptr != NULL) {
-	if (added_conductors_ptr != NULL) *added_conductors_ptr = added_conductors;
+		content_ptr -> elements         = added_elements;
-	if (added_texts_ptr      != NULL) *added_texts_ptr      = added_texts;
+		content_ptr -> conductorsToMove = added_conductors;
+		content_ptr -> textFields       = added_texts;
+	}
 	
 	return(true);
 }
@@ -604,3 +595,33 @@ bool Diagram::clipboardMayContainDiagram() {
 	bool may_be_diagram = clipboard_text.startsWith("<diagram") && clipboard_text.endsWith("</diagram>");
 	return(may_be_diagram);
 }
+
+/**
+	@return Le contenu du schema. Les conducteurs sont tous places dans
+	conductorsToMove.
+*/
+DiagramContent Diagram::content() const {
+	DiagramContent dc;
+	foreach(QGraphicsItem *qgi, items()) {
+		if (Element *e = qgraphicsitem_cast<Element *>(qgi)) {
+			dc.elements << e;
+		} else if (DiagramTextItem *dti = qgraphicsitem_cast<DiagramTextItem *>(qgi)) {
+			dc.textFields << dti;
+		} else if (Conductor *c = qgraphicsitem_cast<Conductor *>(qgi)) {
+			dc.conductorsToMove << c;
+		}
+	}
+	return(dc);
+}
+
+/**
+	@return le contenu selectionne du schema.
+*/
+DiagramContent Diagram::selectedContent() {
+	DiagramContent dc;
+	dc.elements           = elementsToMove().toList();
+	dc.textFields         = textsToMove().toList();
+	dc.conductorsToMove   = conductorsToMove().toList();
+	dc.conductorsToUpdate = conductorsToUpdate();
+	return(dc);
+}

diagram.h

@@ -10,6 +10,7 @@ class Element;
 class Terminal;
 class Conductor;
 class DiagramTextItem;
+class DiagramContent;
 /**
 	Cette classe represente un schema electrique.
 	Elle gere les differents elements et conducteurs qui le composent
@@ -77,7 +78,7 @@ class Diagram : public QGraphicsScene {
 	
 	// fonctions relatives a l'import / export XML
 	QDomDocument toXml(bool = true);
-	bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList<Element *> * = NULL, QList<Conductor *> * = NULL, QList<DiagramTextItem *> * = NULL);
+	bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, DiagramContent * = NULL);
 	
 	// fonctions relatives aux options graphiques
 	void setDisplayGrid(bool);
@@ -101,6 +102,8 @@ class Diagram : public QGraphicsScene {
 	const QHash<Conductor *, Terminal *> &conductorsToUpdate();
 	const QSet<DiagramTextItem *> &textsToMove();
 	QSet<Conductor *> selectedConductors() const;
+	DiagramContent content() const;
+	DiagramContent selectedContent();
 	void moveElements(const QPointF &, QGraphicsItem * = NULL);
 	
 	QUndoStack &undoStack();

diagramcommands.cpp

@@ -112,53 +112,43 @@ void AddConductorCommand::redo() {
 /**
 	Constructeur
 	@param dia Schema dont on supprime des elements et conducteurs
-	@param elements Elements supprimes
+	@param content Contenu supprime
-	@param conductors Conducteurs supprimes
-	@param texts Textes supprimes
 	@param parent QUndoCommand parent
 */
 DeleteElementsCommand::DeleteElementsCommand(
 	Diagram *dia,
-	QSet<Element *> elements,
+	const DiagramContent &content,
-	QSet<Conductor *> conductors,
-	QSet<DiagramTextItem *> texts,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
-	removed_elements(elements),
+	removed_content(content),
-	removed_conductors(conductors),
-	removed_texts(texts),
 	diagram(dia)
 {
-	setText(QObject::tr("supprimer ") + QET::ElementsAndConductorsSentence(removed_elements.count(), removed_conductors.count(), removed_texts.count()));
+	setText(QObject::tr("supprimer ") + removed_content.sentence(true));
-	foreach(QGraphicsItem *qgi, removed_elements)  diagram -> qgiManager().manage(qgi);
+	diagram -> qgiManager().manage(removed_content.items());
-	foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().manage(qgi);
-	foreach(QGraphicsItem *qgi, removed_texts) diagram -> qgiManager().manage(qgi);
 }
 
 /// Destructeur
 DeleteElementsCommand::~DeleteElementsCommand() {
-	foreach(QGraphicsItem *qgi, removed_texts) diagram -> qgiManager().release(qgi);
+	diagram -> qgiManager().release(removed_content.items());
-	foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().release(qgi);
-	foreach(QGraphicsItem *qgi, removed_elements)  diagram -> qgiManager().release(qgi);
 }
 
 /// annule les suppressions
 void DeleteElementsCommand::undo() {
 	// remet les elements
-	foreach(Element *e, removed_elements) {
+	foreach(Element *e, removed_content.elements) {
 		diagram -> addItem(e);
 	}
 	
 	// remet les conducteurs
-	foreach(Conductor *c, removed_conductors) {
+	foreach(Conductor *c, removed_content.conductors()) {
 		diagram -> addItem(c);
 		c -> terminal1 -> addConductor(c);
 		c -> terminal2 -> addConductor(c);
 	}
 	
 	// remet les textes
-	foreach(DiagramTextItem *t, removed_texts) {
+	foreach(DiagramTextItem *t, removed_content.textFields) {
 		diagram -> addItem(t);
 	}
 }
@@ -166,19 +156,19 @@ void DeleteElementsCommand::undo() {
 /// refait les suppressions
 void DeleteElementsCommand::redo() {
 	// enleve les conducteurs
-	foreach(Conductor *c, removed_conductors) {
+	foreach(Conductor *c, removed_content.conductors()) {
 		c -> terminal1 -> removeConductor(c);
 		c -> terminal2 -> removeConductor(c);
 		diagram -> removeItem(c);
 	}
 	
 	// enleve les elements
-	foreach(Element *e, removed_elements) {
+	foreach(Element *e, removed_content.elements) {
 		diagram -> removeItem(e);
 	}
 	
 	// enleve les textes
-	foreach(DiagramTextItem *t, removed_texts) {
+	foreach(DiagramTextItem *t, removed_content.textFields) {
 		diagram -> removeItem(t);
 	}
 }
@@ -193,45 +183,37 @@ void DeleteElementsCommand::redo() {
 */
 PasteDiagramCommand::PasteDiagramCommand(
 	Diagram *dia,
-	const QList<Element *> &e,
+	const DiagramContent &c,
-	const QList<Conductor *> &c,
-	const QList<DiagramTextItem *> &t,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
-	elements(e),
+	content(c),
-	conductors(c),
-	texts(t),
 	diagram(dia),
 	first_redo(true)
 {
-	setText(QObject::tr("coller ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count()));
+	setText(QObject::tr("coller ") + content.sentence());
-	foreach(QGraphicsItem *qgi, elements)  diagram -> qgiManager().manage(qgi);
+	diagram -> qgiManager().manage(content.items());
-	foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().manage(qgi);
-	foreach(QGraphicsItem *qgi, texts) diagram -> qgiManager().manage(qgi);
 }
 
 /// Destructeur
 PasteDiagramCommand::~PasteDiagramCommand() {
-	foreach(QGraphicsItem *qgi, texts) diagram -> qgiManager().release(qgi);
+	diagram -> qgiManager().release(content.items());
-	foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().release(qgi);
-	foreach(QGraphicsItem *qgi, elements)  diagram -> qgiManager().release(qgi);
 }
 
 /// annule le coller
 void PasteDiagramCommand::undo() {
 	// enleve les conducteurs
-	foreach(Conductor *c, conductors) {
+	foreach(Conductor *c, content.conductorsToMove) {
 		c -> terminal1 -> removeConductor(c);
 		c -> terminal2 -> removeConductor(c);
 		diagram -> removeItem(c);
 	}
 	
 	// enleve les elements
-	foreach(Element *e, elements)  diagram -> removeItem(e);
+	foreach(Element *e, content.elements) diagram -> removeItem(e);
 	
 	// enleve les textes
-	foreach(DiagramTextItem *t, texts)  diagram -> removeItem(t);
+	foreach(DiagramTextItem *t, content.textFields) diagram -> removeItem(t);
 }
 
 /// refait le coller
@@ -239,40 +221,37 @@ void PasteDiagramCommand::redo() {
 	if (first_redo) first_redo = false;
 	else {
 		// pose les elements
-		foreach(Element *e, elements)  diagram -> addItem(e);
+		foreach(Element *e, content.elements)  diagram -> addItem(e);
 		
 		// pose les conducteurs
-		foreach(Conductor *c, conductors) {
+		foreach(Conductor *c, content.conductorsToMove) {
 			diagram -> addItem(c);
 			c -> terminal1 -> addConductor(c);
 			c -> terminal2 -> addConductor(c);
 		}
 		
 		// pose les textes
-		foreach(DiagramTextItem *t, texts) diagram -> addItem(t);
+		foreach(DiagramTextItem *t, content.textFields) diagram -> addItem(t);
 	}
-	foreach(Element *e, elements)   e -> setSelected(true);
+	foreach(Element *e, content.elements) e -> setSelected(true);
-	foreach(Conductor *c, conductors) c -> setSelected(true);
+	foreach(Conductor *c, content.conductorsToMove) c -> setSelected(true);
-	foreach(DiagramTextItem *t, texts) t -> setSelected(true);
+	foreach(DiagramTextItem *t, content.textFields) t -> setSelected(true);
 }
 
 /**
 	Constructeur
 	@param dia Schema dont on coupe des elements et conducteurs
-	@param elements Elements coupes
+	@param content Contenu coupe
-	@param conductors Conducteurs coupes
 	@param parent QUndoCommand parent
 */
 CutDiagramCommand::CutDiagramCommand(
 	Diagram *dia,
-	QSet<Element *> elements,
+	const DiagramContent &content,
-	QSet<Conductor *> conductors,
-	QSet<DiagramTextItem *> texts,
 	QUndoCommand *parent
 ) : 
-	DeleteElementsCommand(dia, elements, conductors, texts, parent)
+	DeleteElementsCommand(dia, content, parent)
 {
-	setText(QObject::tr("couper ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count(), texts.count()));
+	setText(QObject::tr("couper ") + content.sentence(true));
 }
 
 /// Destructeur
@@ -282,32 +261,23 @@ CutDiagramCommand::~CutDiagramCommand() {
 /**
 	Constructeur
 	@param dia Schema sur lequel on deplace des elements
-	@param move_elements Elements a deplacer
+	@param diagram_content Contenu a deplacer
-	@param move_conductors Conducteurs a deplacer
-	@param modify_conductors Conducteurs a mettre a jour
-	@param move_texts Textes a deplacer
 	@param m translation subie par les elements
 	@param parent QUndoCommand parent
 */
 MoveElementsCommand::MoveElementsCommand(
 	Diagram *dia,
-	const QSet<Element *> &move_elements,
+	const DiagramContent &diagram_content,
-	const QSet<Conductor *> &move_conductors,
-	const QHash<Conductor *, Terminal *> &modify_conductors,
-	const QSet<DiagramTextItem *> &move_texts,
 	const QPointF &m,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
 	diagram(dia),
-	elements_to_move(move_elements),
+	content_to_move(diagram_content),
-	conductors_to_move(move_conductors),
-	conductors_to_update(modify_conductors),
-	texts_to_move(move_texts),
 	movement(m),
 	first_redo(true)
 {
-	setText(QObject::tr("d\351placer ") + QET::ElementsAndConductorsSentence(elements_to_move.count(), conductors_to_move.count(), texts_to_move.count()));
+	setText(QObject::tr("d\351placer ") + content_to_move.sentence());
 }
 
 /// Destructeur
@@ -331,22 +301,26 @@ void MoveElementsCommand::redo() {
 */
 void MoveElementsCommand::move(const QPointF &actual_movement) {
 	// deplace les elements
-	foreach(Element *element, elements_to_move) {
+	foreach(Element *element, content_to_move.elements) {
 		element -> setPos(element -> pos() + actual_movement);
 	}
 	
 	// deplace certains conducteurs
-	foreach(Conductor *conductor, conductors_to_move) {
+	foreach(Conductor *conductor, content_to_move.conductorsToMove) {
 		conductor -> setPos(conductor -> pos() + actual_movement);
 	}
 	
 	// recalcule les autres conducteurs
-	foreach(Conductor *conductor, conductors_to_update.keys()) {
+	foreach(Conductor *conductor, content_to_move.conductorsToUpdate.keys()) {
-		conductor -> updateWithNewPos(QRectF(), conductors_to_update[conductor], conductors_to_update[conductor] -> amarrageConductor());
+		conductor -> updateWithNewPos(
+			QRectF(),
+			content_to_move.conductorsToUpdate[conductor],
+			content_to_move.conductorsToUpdate[conductor] -> amarrageConductor()
+		);
 	}
 	
 	// deplace les textes
-	foreach(DiagramTextItem *text, texts_to_move) {
+	foreach(DiagramTextItem *text, content_to_move.textFields) {
 		text -> setPos(text -> pos() + actual_movement);
 	}
 }

diagramcommands.h

@@ -2,6 +2,7 @@
 #define DIAGRAM_COMMANDS_H
 #include "qet.h"
 #include "diagram.h"
+#include "diagramcontent.h"
 #include "diagramtextitem.h"
 #include "conductor.h"
 #include "conductorproperties.h"
@@ -89,7 +90,7 @@ class AddConductorCommand : public QUndoCommand {
 class DeleteElementsCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	DeleteElementsCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, QSet<DiagramTextItem *>, QUndoCommand * = 0);
+	DeleteElementsCommand(Diagram *, const DiagramContent &, QUndoCommand * = 0);
 	virtual ~DeleteElementsCommand();
 	private:
 	DeleteElementsCommand(const DeleteElementsCommand &);
@@ -101,12 +102,8 @@ class DeleteElementsCommand : public QUndoCommand {
 	
 	// attributs
 	private:
-	/// liste des elements enleves
+	/// contenu enleve
-	QSet<Element *> removed_elements;
+	DiagramContent removed_content;
-	/// liste des conducteurs enleves
-	QSet<Conductor *> removed_conductors;
-	/// liste des textes enleves
-	QSet<DiagramTextItem *> removed_texts;
 	/// schema dont on supprime des elements et conducteurs
 	Diagram *diagram;
 };
@@ -117,7 +114,7 @@ class DeleteElementsCommand : public QUndoCommand {
 class PasteDiagramCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	PasteDiagramCommand(Diagram *, const QList<Element *> &, const QList<Conductor *> &, const QList<DiagramTextItem *> &, QUndoCommand * = 0);
+	PasteDiagramCommand(Diagram *, const DiagramContent &, QUndoCommand * = 0);
 	virtual ~PasteDiagramCommand();
 	private:
 	PasteDiagramCommand(const PasteDiagramCommand &);
@@ -129,12 +126,8 @@ class PasteDiagramCommand : public QUndoCommand {
 	
 	// attributs
 	private:
-	/// elements ajoutes
+	/// contenu  ajoute
-	QList<Element *> elements;
+	DiagramContent content;
-	/// conducteurs ajoutes
-	QList<Conductor *> conductors;
-	/// textes ajoutes
-	QList<DiagramTextItem *> texts;
 	/// schema sur lequel on colle les elements et conducteurs
 	Diagram *diagram;
 	/// booleen pour empecher le premier appel a redo
@@ -148,7 +141,7 @@ class PasteDiagramCommand : public QUndoCommand {
 class CutDiagramCommand : public DeleteElementsCommand {
 	// constructeurs, destructeur
 	public:
-	CutDiagramCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, QSet<DiagramTextItem *>, QUndoCommand * = 0);
+	CutDiagramCommand(Diagram *, const DiagramContent &, QUndoCommand * = 0);
 	virtual ~CutDiagramCommand();
 	private:
 	CutDiagramCommand(const CutDiagramCommand &);
@@ -161,7 +154,7 @@ class CutDiagramCommand : public DeleteElementsCommand {
 class MoveElementsCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	MoveElementsCommand(Diagram *, const QSet<Element *> &, const QSet<Conductor *> &, const QHash<Conductor *, Terminal *> &, const QSet<DiagramTextItem *> &, const QPointF &m, QUndoCommand * = 0);
+	MoveElementsCommand(Diagram *, const DiagramContent &, const QPointF &m, QUndoCommand * = 0);
 	virtual ~MoveElementsCommand();
 	private:
 	MoveElementsCommand(const MoveElementsCommand &);
@@ -176,14 +169,8 @@ class MoveElementsCommand : public QUndoCommand {
 	private:
 	/// schema sur lequel on deplace les elements
 	Diagram *diagram;
-	/// elements a deplacer
+	/// contenu a deplacer
-	QSet<Element *> elements_to_move;
+	DiagramContent content_to_move;
-	/// conducteurs a deplacer
-	QSet<Conductor *> conductors_to_move;
-	/// conducteurs a actualiser
-	QHash<Conductor *, Terminal *> conductors_to_update;
-	/// textes a deplacer
-	QSet<DiagramTextItem *> texts_to_move;
 	/// mouvement effectue
 	QPointF movement;
 	/// booleen pour ne pas executer le premier redo()

diagramcontent.cpp

@@ -0,0 +1,91 @@
+#include "diagramcontent.h"
+#include <QGraphicsItem>
+#include "element.h"
+#include "diagramtextitem.h"
+#include "conductor.h"
+
+/**
+	Constructeur par defaut. Ne contient rien.
+*/
+DiagramContent::DiagramContent() {
+}
+
+/**
+	Constructeur de copie.
+*/
+DiagramContent::DiagramContent(const DiagramContent &other) :
+	elements(other.elements),
+	textFields(other.textFields),
+	conductorsToUpdate(other.conductorsToUpdate),
+	conductorsToMove(other.conductorsToMove)
+{
+}
+
+/**
+	Constructeur
+*/
+DiagramContent::~DiagramContent() {
+}
+
+/**
+	@return tous les conducteurs
+*/
+QList<Conductor *> DiagramContent::conductors() const {
+	return(conductorsToMove + conductorsToUpdate.keys());
+}
+
+/**
+	Vide le conteneur
+*/
+void DiagramContent::clear() {
+	elements.clear();
+	textFields.clear();
+	conductorsToUpdate.clear();
+	conductorsToMove.clear();
+}
+
+/**
+	@return la liste des items formant le contenu du schema
+*/
+QList<QGraphicsItem *> DiagramContent::items() const {
+	QList<QGraphicsItem *> items_list;
+	foreach(QGraphicsItem *qgi, conductors()) items_list << qgi;
+	foreach(QGraphicsItem *qgi, elements)     items_list << qgi;
+	foreach(QGraphicsItem *qgi, textFields)   items_list << qgi;
+	return(items_list);
+}
+
+/**
+	@param include_updated_conductors true pour compter les conducteurs mis a jour, false sinon
+	@return le nombre d'items formant le contenu du schema
+*/
+int DiagramContent::count(bool include_updated_conductors) const {
+	int conductors_count = conductorsToMove.count();
+	if (include_updated_conductors) conductors_count += conductorsToUpdate.count();
+	
+	return(
+		elements.count()
+		+ textFields.count()
+		+ conductors_count
+		+ conductorsToUpdate.count()
+	);
+}
+
+/**
+	Permet de composer rapidement la proposition "x elements, y conducteurs et
+	z champs de texte".
+	@param include_updated_conductors true pour compter les conducteurs mis a jour, false sinon
+	@return la proposition decrivant le contenu.
+*/
+QString DiagramContent::sentence(bool include_updated_conductors) const {
+	int conductors_count = conductorsToMove.count();
+	if (include_updated_conductors) conductors_count += conductorsToUpdate.count();
+	
+	return(
+		QET::ElementsAndConductorsSentence(
+			elements.count(),
+			conductors_count,
+			textFields.count()
+		)
+	);
+}

diagramcontent.h

@@ -0,0 +1,39 @@
+#ifndef DIAGRAM_CONTENT_H
+#define DIAGRAM_CONTENT_H
+#include <QtGui>
+class Conductor;
+class Element;
+class Terminal;
+class DiagramTextItem;
+/**
+	Cette classe est un conteneur pour passer facilement le contenu d'un schema
+	a une fonction. Il permet d'acceder rapidement aux differents types de
+	composants que l'on peut trouver sur un schema, comme les elements, les
+	champs de texte, les conducteurs (a deplacer ou a mettre a jour, en cas de
+	deplacements), etc.
+	A noter que ce container ne contient pas systematiquement l'integralite
+	d'un schema. Il peut n'en contenir qu'une partie, typiquement les
+	composants selectionnes.
+*/
+class DiagramContent {
+	public:
+	DiagramContent();
+	DiagramContent(const DiagramContent &);
+	~DiagramContent();
+	
+	/// Elements de texte du schema
+	QList<Element *> elements;
+	/// Champs de texte du schema
+	QList<DiagramTextItem *> textFields;
+	/// Conducteurs a mettre a jour du schema
+	QHash<Conductor *, Terminal *> conductorsToUpdate;
+	/// Conducteurs a deplacer du schema
+	QList<Conductor *> conductorsToMove;
+	
+	QList<Conductor *> conductors() const;
+	QList<QGraphicsItem *> items() const;
+	QString sentence(bool = false) const;
+	int count(bool = false) const;
+	void clear();
+};
+#endif

diagramtextitem.cpp

@@ -135,10 +135,7 @@ void DiagramTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 			diagram_ptr -> undoStack().push(
 				new MoveElementsCommand(
 					diagram_ptr,
-					diagram_ptr -> elementsToMove(),
+					diagram_ptr -> selectedContent(),
-					diagram_ptr -> conductorsToMove(),
-					diagram_ptr -> conductorsToUpdate(),
-					diagram_ptr -> textsToMove(),
 					diagram_ptr -> current_movement
 				)
 			);

diagramview.cpp

@@ -81,26 +81,9 @@ void DiagramView::deleteSelection() {
 	// selection
 	if (scene -> focusItem()) return;
 
-	QSet<Element *> garbage_elmt;
+	DiagramContent removed_content = scene -> selectedContent();
-	QSet<Conductor *> garbage_conductors;
-	QSet<DiagramTextItem *> garbage_texts;
-	
-	// creation de deux listes : une pour les conducteurs, une pour les elements
-	foreach (QGraphicsItem *qgi, scene -> selectedItems()) {
-		// pour chaque qgi selectionne, il s'agit soit d'un element soit d'un conducteur
-		if (Conductor * c = qgraphicsitem_cast<Conductor *>(qgi)) {
-			// s'il s'agit d'un conducteur, on le met dans la liste des conducteurs
-			garbage_conductors << c;
-		} else if (Element *e = qgraphicsitem_cast<Element *>(qgi)) {
-			garbage_elmt << e;
-			// s'il s'agit d'un element, on veille a enlever ses conducteurs
-			garbage_conductors += e -> conductors().toSet();
-		} else if (DiagramTextItem *t = qgraphicsitem_cast<DiagramTextItem *>(qgi)) {
-			if (!t -> parentItem()) garbage_texts << t;
-		}
-	}
 	scene -> clearSelection();
-	scene -> undoStack().push(new DeleteElementsCommand(scene, garbage_elmt, garbage_conductors, garbage_texts));
+	scene -> undoStack().push(new DeleteElementsCommand(scene, removed_content));
 }
 
 /**
@@ -214,27 +197,9 @@ void DiagramView::zoomReset() {
 */
 void DiagramView::cut() {
 	copy();
-	QSet<Element *> cut_elmt;
+	DiagramContent removed_content = scene -> selectedContent();
-	QSet<Conductor *> cut_conductors;
-	QSet<DiagramTextItem *> cut_texts;
-	
-	// creation de deux listes : une pour les conducteurs, une pour les elements
-	foreach (QGraphicsItem *qgi, scene -> selectedItems()) {
-		// pour chaque qgi selectionne, il s'agit soit d'un element soit d'un conducteur
-		if (Conductor *c = qgraphicsitem_cast<Conductor *>(qgi)) {
-			// s'il s'agit d'un conducteur, on le met dans la liste des conducteurs
-			cut_conductors << c;
-		} else if (Element *e = qgraphicsitem_cast<Element *>(qgi)) {
-			cut_elmt << e;
-			// s'il s'agit d'un element, on veille a enlever ses conducteurs
-			cut_conductors += e -> conductors().toSet();
-		} else if (DiagramTextItem *t = qgraphicsitem_cast<DiagramTextItem *>(qgi)) {
-			// les textes recherches n'ont pas de parent
-			if (!t -> parentItem()) cut_texts << t;
-		}
-	}
 	scene -> clearSelection();
-	scene -> undoStack().push(new CutDiagramCommand(scene, cut_elmt, cut_conductors, cut_texts));
+	scene -> undoStack().push(new CutDiagramCommand(scene, scene -> selectedContent()));
 }
 
 /**
@@ -260,16 +225,14 @@ void DiagramView::paste(const QPointF &pos, QClipboard::Mode clipboard_mode) {
 	QDomDocument document_xml;
 	if (!document_xml.setContent(texte_presse_papier)) return;
 	
-	// listes pour recupere les elements et conducteurs ajoutes au schema par le coller
+	// objet pour recuperer le contenu ajoute au schema par le coller
-	QList<Element *> elements_pasted;
+	DiagramContent content_pasted;
-	QList<Conductor *> conductors_pasted;
+	scene -> fromXml(document_xml, pos, false, &content_pasted);
-	QList<DiagramTextItem *> texts_pasted;
-	scene -> fromXml(document_xml, pos, false, &elements_pasted, &conductors_pasted, &texts_pasted);
 	
 	// si quelque chose a effectivement ete ajoute au schema, on cree un objet d'annulation
-	if (elements_pasted.count() || conductors_pasted.count() || texts_pasted.count()) {
+	if (content_pasted.count()) {
 		scene -> clearSelection();
-		scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conductors_pasted, texts_pasted));
+		scene -> undoStack().push(new PasteDiagramCommand(scene, content_pasted));
 	}
 }
 

element.cpp

@@ -264,10 +264,7 @@ void Element::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 			diagram_ptr -> undoStack().push(
 				new MoveElementsCommand(
 					diagram_ptr,
-					diagram_ptr -> elementsToMove(),
+					diagram_ptr -> selectedContent(),
-					diagram_ptr -> conductorsToMove(),
-					diagram_ptr -> conductorsToUpdate(),
-					diagram_ptr -> textsToMove(),
 					diagram_ptr -> current_movement
 				)
 			);

elementtextitem.h

@@ -25,6 +25,7 @@ class ElementTextItem : public DiagramTextItem {
 	// methodes
 	public:
 	virtual int type() const { return Type; }
+	virtual QRectF boundingRect() { return(QGraphicsTextItem::boundingRect().adjusted(0.0, -1.0, 0.0, 0.0)); }
 	bool followParentRotations() const;
 	void setFollowParentRotations(bool);
 	void fromXml(const QDomElement &);

qelectrotech.pro

@@ -80,6 +80,7 @@ HEADERS += aboutqet.h \
            diagramtextitem.h \
            insetproperties.h \
            conductorpropertieswidget.h \
+           diagramcontent.h \
            conductorproperties.h
 SOURCES += aboutqet.cpp \
            borderinset.cpp \
@@ -140,6 +141,7 @@ SOURCES += aboutqet.cpp \
            diagramcommands.cpp \
            diagramtextitem.cpp \
            conductorpropertieswidget.cpp \
+           diagramcontent.cpp \
            conductorproperties.cpp
 RESOURCES += qelectrotech.qrc
 TRANSLATIONS += lang/qet_en.ts lang/qt_fr.ts

qet.cpp

@@ -128,6 +128,7 @@ bool QET::attributeIsAReal(const QDomElement &e, QString nom_attribut, double *r
 	Permet de composer rapidement la proposition "x elements et y conducteurs"
 	@param elements_count nombre d élements
 	@param conductors_count nombre de conducteurs
+	@param texts_count nombre de champs de texte
 	@return la proposition decrivant le nombre d'elements et de conducteurs
 */
 QString QET::ElementsAndConductorsSentence(int elements_count, int conductors_count, int texts_count) {

qgimanager.cpp

@@ -48,6 +48,25 @@ void QGIManager::release(QGraphicsItem *qgi) {
 	}
 }
 
+/**
+	Demande au QGIManager de gerer plusieurs QGI
+	@param qgis QGraphicsItems a gerer
+*/
+void QGIManager::manage(const QList<QGraphicsItem *> &qgis) {
+	foreach(QGraphicsItem *qgi, qgis) manage(qgi);
+}
+
+/**
+	Indique au QGIManager que pour chaque QGI fourni, une reference vers celui-ci
+	a ete detruite.
+	S'il n'y a plus de references vers un QGI et que celui-ci n'est pas present
+	sur la scene de ce QGIManager, alors il sera detruit.
+	@param qgis QGraphicsItems a ne plus gerer
+*/
+void QGIManager::release(const QList<QGraphicsItem *> &qgis) {
+	foreach(QGraphicsItem *qgi, qgis) release(qgi);
+}
+
 /**
 	Indique au QGIManager de detruire les QGraphicsItem restants lors de sa
 	destruction si ceux-ci n'appartiennent pas a la scene

qgimanager.h

@@ -26,6 +26,8 @@ class QGIManager {
 	public:
 	void manage(QGraphicsItem *);
 	void release(QGraphicsItem *);
+	void manage(const QList<QGraphicsItem *> &);
+	void release(const QList<QGraphicsItem *> &);
 	void setDestroyQGIOnDelete(bool);
 };
 #endif