Classe Conducer renommee en Conductor

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

conducerprofile.cpp

@@ -1,137 +0,0 @@
-#include "conducerprofile.h"
-#include "conducer.h"
-#include "conducersegmentprofile.h"
-
-/// Constructeur
-ConducerProfile::ConducerProfile() {
-}
-
-/**
-	Constructeur
-	@param Conducer conducteur dont il faut extraire le profil
-*/
-ConducerProfile::ConducerProfile(Conducer *conducer) {
-	fromConducer(conducer);
-}
-
-/**
-	Constructeur de copie
-	@param c autre conducteur
-*/
-ConducerProfile::ConducerProfile(const ConducerProfile &c) {
-	beginOrientation = c.beginOrientation;
-	endOrientation   = c.endOrientation;
-	foreach(ConducerSegmentProfile *csp, c.segments) {
-		segments << new ConducerSegmentProfile(*csp);
-	}
-}
-
-/**
-	Operateur =
-	@param c autre conducteur
-*/
-ConducerProfile &ConducerProfile::operator=(const ConducerProfile &c) {
-	if (&c == this) return(*this);
-	
-	// supprime ses informations
-	setNull();
-	
-	// copie les informations de l'autre profil de conducteur
-	beginOrientation = c.beginOrientation;
-	endOrientation   = c.endOrientation;
-	foreach(ConducerSegmentProfile *csp, c.segments) {
-		segments << new ConducerSegmentProfile(*csp);
-	}
-	return(*this);
-}
-
-/// destructeur
-ConducerProfile::~ConducerProfile() {
-	setNull();
-}
-
-/// @return true si le profil est nul
-bool ConducerProfile::isNull() const {
-	return(segments.isEmpty());
-}
-
-/// supprime les segments du profil de conducteur
-void ConducerProfile::setNull() {
-	foreach(ConducerSegmentProfile *csp, segments) delete csp;
-	segments.clear();
-}
-
-/// @return la largeur occupee par le conducteur
-qreal ConducerProfile::width() const {
-	qreal width = 0.0;
-	foreach(ConducerSegmentProfile *csp, segments) {
-		if (csp -> isHorizontal) width += csp -> length;
-	}
-	return(width);
-}
-
-/// @return la hauteur occupee par le conducteur
-qreal ConducerProfile::height() const{
-	qreal height = 0.0;
-	foreach(ConducerSegmentProfile *csp, segments) {
-		if (!csp -> isHorizontal) height += csp -> length;
-	}
-	return(height);
-}
-
-/**
-	@param type Type de Segments
-	@return Le nombre de segments composant le conducteur.
-*/
-uint ConducerProfile::nbSegments(QET::ConducerSegmentType type) const {
-	if (type == QET::Both) return(segments.count());
-	uint nb_seg = 0;
-	foreach(ConducerSegmentProfile *csp, segments) {
-		if (type == QET::Horizontal && csp -> isHorizontal) ++ nb_seg;
-		else if (type == QET::Vertical && !csp -> isHorizontal) ++ nb_seg;
-	}
-	return(nb_seg);
-}
-
-/// @return les segments horizontaux de ce profil
-QList<ConducerSegmentProfile *> ConducerProfile::horizontalSegments() {
-	QList<ConducerSegmentProfile *> segments_list;
-	foreach(ConducerSegmentProfile *csp, segments) {
-		if (csp -> isHorizontal) segments_list << csp;
-	}
-	return(segments_list);
-}
-
-/// @return les segments verticaux de ce profil
-QList<ConducerSegmentProfile *> ConducerProfile::verticalSegments() {
-	QList<ConducerSegmentProfile *> segments_list;
-	foreach(ConducerSegmentProfile *csp, segments) {
-		if (!csp -> isHorizontal) segments_list << csp;
-	}
-	return(segments_list);
-}
-
-void ConducerProfile::fromConducer(Conducer *conducer) {
-	// supprime les segments precedents
-	setNull();
-	
-	foreach(ConducerSegment *conducer_segment, conducer -> segmentsList()) {
-		segments << new ConducerSegmentProfile(conducer_segment);
-	}
-	beginOrientation = conducer -> terminal1 -> orientation();
-	endOrientation   = conducer -> terminal2 -> orientation();
-}
-
-/**
-	Permet de debugger un profil de conducteur
-	@param d Object QDebug a utiliser pour l'affichage des informations de debug
-	@param t Profil de conducteur a debugger
-*/
-QDebug &operator<<(QDebug d, ConducerProfile &t) {
-	d << "ConducerProfile {";
-	foreach(ConducerSegmentProfile *csp, t.segments) {
-		d << "CSP" << (csp -> isHorizontal ? "horizontal" : "vertical") << ":" << csp -> length << ",";
-	}
-	d << "}";
-	return(d.space());
-}

conducerprofile.h

@@ -1,38 +0,0 @@
-#ifndef CONDUCER_PROFILE_H
-#define CONDUCER_PROFILE_H
-#include <QList>
-#include "qet.h"
-class Conducer;
-class ConducerSegmentProfile;
-/**
-	Cette classe contient le profil (= les caracteristiques essentielles) d'un
-	conducteur.
-*/
-class ConducerProfile {
-	public:
-	// constructeurs, destructeur
-	ConducerProfile();
-	ConducerProfile(Conducer *conducer);
-	ConducerProfile(const ConducerProfile &);
-	ConducerProfile &operator=(const ConducerProfile &);
-	virtual ~ConducerProfile();
-	
-	// attributs
-	public:
-	QList<ConducerSegmentProfile *> segments;
-	QET::Orientation beginOrientation;
-	QET::Orientation endOrientation;
-	
-	// methodes
-	public:
-	bool isNull() const;
-	void setNull();
-	qreal width() const;
-	qreal height() const;
-	uint nbSegments(QET::ConducerSegmentType) const;
-	QList<ConducerSegmentProfile *> horizontalSegments();
-	QList<ConducerSegmentProfile *> verticalSegments();
-	void fromConducer(Conducer *);
-};
-QDebug &operator<<(QDebug d, ConducerProfile &);
-#endif

conductor.cpp

@@ -1,15 +1,15 @@
 #include <QtDebug>
-#include "conducer.h"
+#include "conductor.h"
-#include "conducersegment.h"
+#include "conductorsegment.h"
-#include "conducersegmentprofile.h"
+#include "conductorsegmentprofile.h"
 #include "element.h"
 #include "diagram.h"
 #include "diagramcommands.h"
 #define PR(x) qDebug() << #x " = " << x;
 
-bool Conducer::pen_and_brush_initialized = false;
+bool Conductor::pen_and_brush_initialized = false;
-QPen Conducer::conducer_pen = QPen();
+QPen Conductor::conductor_pen = QPen();
-QBrush Conducer::conducer_brush = QBrush();
+QBrush Conductor::conductor_brush = QBrush();
 
 /**
 	Constructeur
@@ -18,7 +18,7 @@ QBrush Conducer::conducer_brush = QBrush();
 	@param parent Element parent du conducteur (0 par defaut)
 	@param scene  QGraphicsScene auquelle appartient le conducteur
 */
-Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *scene) :
+Conductor::Conductor(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *scene) :
 	QGraphicsPathItem(parent, scene),
 	terminal1(p1),
 	terminal2(p2),
@@ -29,26 +29,26 @@ Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *
 	has_to_save_profile(false)
 {
 	// ajout du conducteur a la liste de conducteurs de chacune des deux bornes
-	bool ajout_p1 = terminal1 -> addConducer(this);
+	bool ajout_p1 = terminal1 -> addConductor(this);
-	bool ajout_p2 = terminal2 -> addConducer(this);
+	bool ajout_p2 = terminal2 -> addConductor(this);
 	
 	// en cas d'echec de l'ajout (conducteur deja existant notamment)
 	if (!ajout_p1 || !ajout_p2) return;
 	
 	// attributs de dessin par defaut (communs a tous les conducteurs)
 	if (!pen_and_brush_initialized) {
-		conducer_pen.setJoinStyle(Qt::MiterJoin);
+		conductor_pen.setJoinStyle(Qt::MiterJoin);
-		conducer_pen.setCapStyle(Qt::SquareCap);
+		conductor_pen.setCapStyle(Qt::SquareCap);
-		conducer_pen.setColor(Qt::black);
+		conductor_pen.setColor(Qt::black);
-		conducer_pen.setStyle(Qt::SolidLine);
+		conductor_pen.setStyle(Qt::SolidLine);
-		conducer_pen.setWidthF(1.0);
+		conductor_pen.setWidthF(1.0);
-		conducer_brush.setColor(Qt::white);
+		conductor_brush.setColor(Qt::white);
-		conducer_brush.setStyle(Qt::NoBrush);
+		conductor_brush.setStyle(Qt::NoBrush);
 		pen_and_brush_initialized = true;
 	}
 	
 	// calcul du rendu du conducteur
-	priv_calculeConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation());
+	priv_calculeConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation());
 	setFlags(QGraphicsItem::ItemIsSelectable);
 	setAcceptsHoverEvents(true);
 	
@@ -65,7 +65,7 @@ Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *
 	Detruit le conducteur ainsi que ses segments. Il ne detruit pas les bornes
 	mais s'en detache
 */
-Conducer::~Conducer() {
+Conductor::~Conductor() {
 	// se detache des bornes
 	if (!isDestroyed()) destroy();
 	
@@ -78,15 +78,15 @@ Conducer::~Conducer() {
 	Met a jour la representation graphique du conducteur.
 	@param rect Rectangle a mettre a jour
 */
-void Conducer::update(const QRectF &rect) {
+void Conductor::update(const QRectF &rect) {
 	// utilise soit la fonction priv_modifieConducteur soit la fonction priv_calculeConducteur
-	void (Conducer::* fonction_update) (const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
+	void (Conductor::* fonction_update) (const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
-	fonction_update = (nbSegments() && modified_path) ? &Conducer::priv_modifieConducer : &Conducer::priv_calculeConducer;
+	fonction_update = (nbSegments() && modified_path) ? &Conductor::priv_modifieConductor : &Conductor::priv_calculeConductor;
 	
 	// appelle la bonne fonction pour calculer l'aspect du conducteur
 	(this ->* fonction_update)(
-		terminal1 -> amarrageConducer(), terminal1 -> orientation(),
+		terminal1 -> amarrageConductor(), terminal1 -> orientation(),
-		terminal2 -> amarrageConducer(), terminal2 -> orientation()
+		terminal2 -> amarrageConductor(), terminal2 -> orientation()
 	);
 	calculateTextItemPosition();
 	QGraphicsPathItem::update(rect);
@@ -99,22 +99,22 @@ void Conducer::update(const QRectF &rect) {
 	@param b Borne
 	@param newpos position de la borne b
 */
-void Conducer::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPointF &newpos) {
+void Conductor::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPointF &newpos) {
 	QPointF p1, p2;
 	if (b == terminal1) {
 		p1 = newpos;
-		p2 = terminal2 -> amarrageConducer();
+		p2 = terminal2 -> amarrageConductor();
 	} else if (b == terminal2) {
-		p1 = terminal1 -> amarrageConducer();
+		p1 = terminal1 -> amarrageConductor();
 		p2 = newpos;
 	} else {
-		p1 = terminal1 -> amarrageConducer();
+		p1 = terminal1 -> amarrageConductor();
-		p2 = terminal2 -> amarrageConducer();
+		p2 = terminal2 -> amarrageConductor();
 	}
 	if (nbSegments() && modified_path)
-		priv_modifieConducer(p1, terminal1 -> orientation(), p2, terminal2 -> orientation());
+		priv_modifieConductor(p1, terminal1 -> orientation(), p2, terminal2 -> orientation());
 	else
-		priv_calculeConducer(p1, terminal1 -> orientation(), p2, terminal2 -> orientation());
+		priv_calculeConductor(p1, terminal1 -> orientation(), p2, terminal2 -> orientation());
 	calculateTextItemPosition();
 	QGraphicsPathItem::update(rect);
 }
@@ -122,7 +122,7 @@ void Conducer::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPo
 /**
 	Genere le QPainterPath a partir de la liste des points
 */
-void Conducer::segmentsToPath() {
+void Conductor::segmentsToPath() {
 	// chemin qui sera dessine
 	QPainterPath path;
 	
@@ -133,7 +133,7 @@ void Conducer::segmentsToPath() {
 	path.moveTo(segments -> firstPoint());
 	
 	// parcourt les segments pour dessiner le chemin
-	ConducerSegment *segment = segments;
+	ConductorSegment *segment = segments;
 	while(segment -> hasNextSegment()) {
 		path.lineTo(segment -> secondPoint());
 		segment = segment -> nextSegment();
@@ -153,9 +153,9 @@ void Conducer::segmentsToPath() {
 	@param p2 Coordonnees du point d'amarrage de la borne 2
 	@param o2 Orientation de la borne 2
 */
-void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const QPointF &p2, QET::Orientation) {
+void Conductor::priv_modifieConductor(const QPointF &p1, QET::Orientation, const QPointF &p2, QET::Orientation) {
-	Q_ASSERT_X(conducer_profile.nbSegments(QET::Both) > 1, "Conducer::priv_modifieConducer", "pas de points a modifier");
+	Q_ASSERT_X(conductor_profile.nbSegments(QET::Both) > 1, "Conductor::priv_modifieConductor", "pas de points a modifier");
-	Q_ASSERT_X(!conducer_profile.isNull(),                 "Conducer::priv_modifieConducer", "pas de profil utilisable");
+	Q_ASSERT_X(!conductor_profile.isNull(),                 "Conductor::priv_modifieConductor", "pas de profil utilisable");
 	
 	// recupere les coordonnees fournies des bornes
 	QPointF new_p1 = mapFromScene(p1);
@@ -163,17 +163,17 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q
 	QRectF new_rect = QRectF(new_p1, new_p2);
 	
 	// recupere la largeur et la hauteur du profil
-	qreal profile_width  = conducer_profile.width();
+	qreal profile_width  = conductor_profile.width();
-	qreal profile_height = conducer_profile.height();
+	qreal profile_height = conductor_profile.height();
 	
 	// calcule les differences verticales et horizontales a appliquer
 	qreal h_diff = (qAbs(new_rect.width())  - qAbs(profile_width) ) * getSign(profile_width);
 	qreal v_diff = (qAbs(new_rect.height()) - qAbs(profile_height)) * getSign(profile_height);
 	
 	// applique les differences aux segments
-	QHash<ConducerSegmentProfile *, qreal> segments_lengths;
+	QHash<ConductorSegmentProfile *, qreal> segments_lengths;
-	segments_lengths.unite(shareOffsetBetweenSegments(h_diff, conducer_profile.horizontalSegments()));
+	segments_lengths.unite(shareOffsetBetweenSegments(h_diff, conductor_profile.horizontalSegments()));
-	segments_lengths.unite(shareOffsetBetweenSegments(v_diff, conducer_profile.verticalSegments()));
+	segments_lengths.unite(shareOffsetBetweenSegments(v_diff, conductor_profile.verticalSegments()));
 	
 	// en deduit egalement les coefficients d'inversion (-1 pour une inversion, +1 pour conserver le meme sens)
 	int horiz_coeff = getCoeff(new_rect.width(),  profile_width);
@@ -182,13 +182,13 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q
 	// genere les nouveaux points
 	QList<QPointF> points;
 	points << new_p1;
-	int limit = conducer_profile.segments.count() - 1;
+	int limit = conductor_profile.segments.count() - 1;
 	for (int i = 0 ; i < limit ; ++ i) {
 		// dernier point
 		QPointF previous_point = points.last();
 		
 		// profil de segment de conducteur en cours
-		ConducerSegmentProfile *csp = conducer_profile.segments.at(i);
+		ConductorSegmentProfile *csp = conductor_profile.segments.at(i);
 		
 		// coefficient et offset a utiliser pour ce point
 		qreal coeff = csp -> isHorizontal ? horiz_coeff : verti_coeff;
@@ -217,20 +217,20 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q
 	@param segments_list Segments sur lesquels il faut repartir la longueur
 	@param precision seuil en-deca duquel on considere qu'il ne reste rien a repartir
 */
-QHash<ConducerSegmentProfile *, qreal> Conducer::shareOffsetBetweenSegments(
+QHash<ConductorSegmentProfile *, qreal> Conductor::shareOffsetBetweenSegments(
 	const qreal &offset,
-	const QList<ConducerSegmentProfile *> &segments_list,
+	const QList<ConductorSegmentProfile *> &segments_list,
 	const qreal &precision
 ) const {
 	// construit le QHash qui sera retourne
-	QHash<ConducerSegmentProfile *, qreal> segments_hash;
+	QHash<ConductorSegmentProfile *, qreal> segments_hash;
-	foreach(ConducerSegmentProfile *csp, segments_list) {
+	foreach(ConductorSegmentProfile *csp, segments_list) {
 		segments_hash.insert(csp, csp -> length);
 	}
 	
 	// memorise le signe de la longueur de chaque segement
-	QHash<ConducerSegmentProfile *, int> segments_signs;
+	QHash<ConductorSegmentProfile *, int> segments_signs;
-	foreach(ConducerSegmentProfile *csp, segments_hash.keys()) {
+	foreach(ConductorSegmentProfile *csp, segments_hash.keys()) {
 		segments_signs.insert(csp, getSign(csp -> length));
 	}
 	
@@ -241,12 +241,12 @@ QHash<ConducerSegmentProfile *, qreal> Conducer::shareOffsetBetweenSegments(
 	while (remaining_offset > precision || remaining_offset < -precision) {
 		// recupere le nombre de segments differents ayant une longueur non nulle
 		uint segments_count = 0;
-		foreach(ConducerSegmentProfile *csp, segments_hash.keys()) if (segments_hash[csp]) ++ segments_count;
+		foreach(ConductorSegmentProfile *csp, segments_hash.keys()) if (segments_hash[csp]) ++ segments_count;
 		//qDebug() << "  remaining_offset =" << remaining_offset;
 		qreal local_offset = remaining_offset / segments_count;
 		//qDebug() << "  repartition d'un offset local de" << local_offset << "px sur" << segments_count << "segments";
 		remaining_offset = 0.0;
-		foreach(ConducerSegmentProfile *csp, segments_hash.keys()) {
+		foreach(ConductorSegmentProfile *csp, segments_hash.keys()) {
 			// ignore les segments de longueur nulle
 			if (!segments_hash[csp]) continue;
 			// applique l'offset au segment
@@ -276,7 +276,7 @@ QHash<ConducerSegmentProfile *, qreal> Conducer::shareOffsetBetweenSegments(
 	@param p2 Coordonnees du point d'amarrage de la borne 2
 	@param o2 Orientation de la borne 2
 */
-void Conducer::priv_calculeConducer(const QPointF &p1, QET::Orientation o1, const QPointF &p2, QET::Orientation o2) {
+void Conductor::priv_calculeConductor(const QPointF &p1, QET::Orientation o1, const QPointF &p2, QET::Orientation o2) {
 	QPointF sp1, sp2, depart, newp1, newp2, arrivee, depart0, arrivee0;
 	QET::Orientation ori_depart, ori_arrivee;
 	
@@ -375,7 +375,7 @@ void Conducer::priv_calculeConducer(const QPointF &p1, QET::Orientation o1, cons
 	@param ext_size la taille de la prolongation
 	@return le point correspondant a la borne apres prolongation
 */
-QPointF Conducer::extendTerminal(const QPointF &terminal, QET::Orientation terminal_orientation, qreal ext_size) {
+QPointF Conductor::extendTerminal(const QPointF &terminal, QET::Orientation terminal_orientation, qreal ext_size) {
 	QPointF extended_terminal;
 	switch(terminal_orientation) {
 		case QET::North:
@@ -401,13 +401,13 @@ QPointF Conducer::extendTerminal(const QPointF &terminal, QET::Orientation termi
 	@param qsogi Les options de style pour le conducteur
 	@param qw Le QWidget sur lequel on dessine 
 */
-void Conducer::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QWidget */*qw*/) {
+void Conductor::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QWidget */*qw*/) {
 	qp -> save();
 	qp -> setRenderHint(QPainter::Antialiasing, false);
 	
 	// affectation du QPen et de la QBrush modifies au QPainter
-	qp -> setBrush(conducer_brush);
+	qp -> setBrush(conductor_brush);
-	qp -> setPen(conducer_pen);
+	qp -> setPen(conductor_pen);
 	if (isSelected()) {
 		QPen tmp = qp -> pen();
 		tmp.setColor(Qt::red);
@@ -454,14 +454,14 @@ void Conducer::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QW
 /**
 	Methode de preparation a la destruction du conducteur ; le conducteur se detache de ses deux bornes
 */
-void Conducer::destroy() {
+void Conductor::destroy() {
 	destroyed = true;
-	terminal1 -> removeConducer(this);
+	terminal1 -> removeConductor(this);
-	terminal2 -> removeConducer(this);
+	terminal2 -> removeConductor(this);
 }
 
 /// @return le Diagram auquel ce conducteur appartient, ou 0 si ce conducteur est independant
-Diagram *Conducer::diagram() const {
+Diagram *Conductor::diagram() const {
 	return(qobject_cast<Diagram *>(scene()));
 }
 
@@ -470,9 +470,9 @@ Diagram *Conducer::diagram() const {
 	@param e Un element XML sense represente un Conducteur
 	@return true si l'element XML represente bien un Conducteur ; false sinon
 */
-bool Conducer::valideXml(QDomElement &e){
+bool Conductor::valideXml(QDomElement &e){
 	// verifie le nom du tag
-	if (e.tagName() != "conducer") return(false);
+	if (e.tagName() != "conductor") return(false);
 	
 	// verifie la presence des attributs minimaux
 	if (!e.hasAttribute("terminal1")) return(false);
@@ -493,7 +493,7 @@ bool Conducer::valideXml(QDomElement &e){
 	Gere les clics sur le conducteur.
 	@param e L'evenement decrivant le clic.
 */
-void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) {
+void Conductor::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	// clic gauche
 	if (e -> buttons() & Qt::LeftButton) {
 		// recupere les coordonnees du clic
@@ -505,7 +505,7 @@ void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 			- sur le milieu d'un segment
 			- ailleurs
 		*/
-		ConducerSegment *segment = segments;
+		ConductorSegment *segment = segments;
 		while (segment -> hasNextSegment()) {
 			if (hasClickedOn(press_point, segment -> secondPoint())) {
 				moving_point = true;
@@ -532,7 +532,7 @@ void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	Gere les deplacements de souris sur le conducteur.
 	@param e L'evenement decrivant le deplacement de souris.
 */
-void Conducer::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
+void Conductor::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	// clic gauche
 	if (e -> buttons() & Qt::LeftButton) {
 		// position pointee par la souris
@@ -578,7 +578,7 @@ void Conducer::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	Gere les relachements de boutons de souris sur le conducteur 
 	@param e L'evenement decrivant le lacher de bouton.
 */
-void Conducer::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
+void Conductor::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	// clic gauche
 	moving_point = false;
 	moving_segment = false;
@@ -595,11 +595,11 @@ void Conducer::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	Gere les mouvements de souris au dessus du conducteur
 	@param e Le QGraphicsSceneHoverEvent decrivant l'evenement
 */
-void Conducer::hoverMoveEvent(QGraphicsSceneHoverEvent *e) {
+void Conductor::hoverMoveEvent(QGraphicsSceneHoverEvent *e) {
 	/*
 	if (isSelected()) {
 		QPointF hover_point = mapFromScene(e -> pos());
-		ConducerSegment *segment = segments;
+		ConductorSegment *segment = segments;
 		bool cursor_set = false;
 		while (segment -> hasNextSegment()) {
 			if (hasClickedOn(hover_point, segment -> secondPoint())) {
@@ -620,7 +620,7 @@ void Conducer::hoverMoveEvent(QGraphicsSceneHoverEvent *e) {
 /**
 	@return Le rectangle delimitant l'espace de dessin du conducteur
 */
-QRectF Conducer::boundingRect() const {
+QRectF Conductor::boundingRect() const {
 	QRectF retour = QGraphicsPathItem::boundingRect();
 	retour.adjust(-5.0, -5.0, 5.0, 5.0);
 	return(retour);
@@ -629,7 +629,7 @@ QRectF Conducer::boundingRect() const {
 /**
 	@return La forme / zone "cliquable" du conducteur
 */
-QPainterPath Conducer::shape() const {
+QPainterPath Conductor::shape() const {
 	QList<QPointF> points = segmentsToPoints();
 	QPainterPath area;
 	QPointF previous_point;
@@ -675,7 +675,7 @@ QPainterPath Conducer::shape() const {
 	@param bound2 borne 2
 	@return La valeur bornee
 */
-qreal Conducer::conducer_bound(qreal tobound, qreal bound1, qreal bound2, qreal space) {
+qreal Conductor::conductor_bound(qreal tobound, qreal bound1, qreal bound2, qreal space) {
 	qDebug() << "will bound" << tobound << "between" << bound1 << "and" << bound2 ;
 	if (bound1 < bound2) {
 		return(qBound(bound1 + space, tobound, bound2 - space));
@@ -691,7 +691,7 @@ qreal Conducer::conducer_bound(qreal tobound, qreal bound1, qreal bound2, qreal
 	@param positive true pour borner la valeur avant la borne, false sinon
 	@return La valeur bornee
 */
-qreal Conducer::conducer_bound(qreal tobound, qreal bound, bool positive) {
+qreal Conductor::conductor_bound(qreal tobound, qreal bound, bool positive) {
 	qreal space = 5.0;
 	return(positive ? qMax(tobound, bound + space) : qMin(tobound, bound - space));
 }
@@ -700,12 +700,12 @@ qreal Conducer::conducer_bound(qreal tobound, qreal bound, bool positive) {
 	@param type Type de Segments
 	@return Le nombre de segments composant le conducteur.
 */
-uint Conducer::nbSegments(QET::ConducerSegmentType type) const {
+uint Conductor::nbSegments(QET::ConductorSegmentType type) const {
-	QList<ConducerSegment *> segments_list = segmentsList();
+	QList<ConductorSegment *> segments_list = segmentsList();
 	if (type == QET::Both) return(segments_list.count());
 	uint nb_seg = 0;
-	foreach(ConducerSegment *conducer_segment, segments_list) {
+	foreach(ConductorSegment *conductor_segment, segments_list) {
-		if (conducer_segment -> type() == type) ++ nb_seg;
+		if (conductor_segment -> type() == type) ++ nb_seg;
 	}
 	return(nb_seg);
 }
@@ -714,7 +714,7 @@ uint Conducer::nbSegments(QET::ConducerSegmentType type) const {
 	Genere une liste de points a partir des segments de ce conducteur
 	@return La liste de points representant ce conducteur
 */
-QList<QPointF> Conducer::segmentsToPoints() const {
+QList<QPointF> Conductor::segmentsToPoints() const {
 	// liste qui sera retournee
 	QList<QPointF> points_list;
 	
@@ -725,7 +725,7 @@ QList<QPointF> Conducer::segmentsToPoints() const {
 	points_list << segments -> firstPoint();
 	
 	// parcourt les segments pour recuperer les autres points
-	ConducerSegment *segment = segments;
+	ConductorSegment *segment = segments;
 	while(segment -> hasNextSegment()) {
 		points_list << segment -> secondPoint();
 		segment = segment -> nextSegment();
@@ -742,21 +742,21 @@ QList<QPointF> Conducer::segmentsToPoints() const {
 	Regenere les segments de ce conducteur a partir de la liste de points passee en parametre
 	@param points_list Liste de points a utiliser pour generer les segments
 */
-void Conducer::pointsToSegments(QList<QPointF> points_list) {
+void Conductor::pointsToSegments(QList<QPointF> points_list) {
 	// supprime les segments actuels
 	if (segments != NULL) {
-		ConducerSegment *segment = segments;
+		ConductorSegment *segment = segments;
 		while (segment -> hasNextSegment()) {
-			ConducerSegment *nextsegment = segment -> nextSegment();
+			ConductorSegment *nextsegment = segment -> nextSegment();
 			delete segment;
 			segment = nextsegment;
 		}
 	}
 	
 	// cree les segments a partir de la liste de points
-	ConducerSegment *last_segment = NULL;
+	ConductorSegment *last_segment = NULL;
 	for (int i = 0 ; i < points_list.size() - 1 ; ++ i) {
-		last_segment = new ConducerSegment(points_list.at(i), points_list.at(i + 1), last_segment);
+		last_segment = new ConductorSegment(points_list.at(i), points_list.at(i + 1), last_segment);
 		if (!i) segments = last_segment;
 	}
 }
@@ -768,7 +768,7 @@ void Conducer::pointsToSegments(QList<QPointF> points_list) {
 	@param point point cliquable
 	@return true si l'on peut considerer que le point a ete clique, false sinon
 */
-bool Conducer::hasClickedOn(QPointF press_point, QPointF point) const {
+bool Conductor::hasClickedOn(QPointF press_point, QPointF point) const {
 	return (
 		press_point.x() >= point.x() - 5.0 &&\
 		press_point.x() <  point.x() + 5.0 &&\
@@ -782,7 +782,7 @@ bool Conducer::hasClickedOn(QPointF press_point, QPointF point) const {
 	@param e Un element XML
 	@return true si le chargement a reussi, false sinon
 */
-bool Conducer::fromXml(QDomElement &e) {
+bool Conductor::fromXml(QDomElement &e) {
 	// recupere la "configuration" du conducteur
 	if (e.attribute("singleline") == "true") {
 		// recupere les parametres specifiques a un conducteur unifilaire
@@ -826,8 +826,8 @@ bool Conducer::fromXml(QDomElement &e) {
 	qreal width = 0.0, height = 0.0;
 	foreach (qreal t, segments_x) width  += t;
 	foreach (qreal t, segments_y) height += t;
-	QPointF t1 = terminal1 -> amarrageConducer();
+	QPointF t1 = terminal1 -> amarrageConductor();
-	QPointF t2 = terminal2 -> amarrageConducer();
+	QPointF t2 = terminal2 -> amarrageConductor();
 	qreal expected_width  = t2.x() - t1.x();
 	qreal expected_height = t2.y() - t1.y();
 	qreal precision = std::numeric_limits<qreal>::epsilon();
@@ -866,8 +866,8 @@ bool Conducer::fromXml(QDomElement &e) {
 	bornes dans le document XML et leur adresse en memoire
 	@return Un element XML representant le conducteur
 */
-QDomElement Conducer::toXml(QDomDocument &d, QHash<Terminal *, int> &table_adr_id) const {
+QDomElement Conductor::toXml(QDomDocument &d, QHash<Terminal *, int> &table_adr_id) const {
-	QDomElement e = d.createElement("conducer");
+	QDomElement e = d.createElement("conductor");
 	e.setAttribute("terminal1", table_adr_id.value(terminal1));
 	e.setAttribute("terminal2", table_adr_id.value(terminal2));
 	
@@ -876,7 +876,7 @@ QDomElement Conducer::toXml(QDomDocument &d, QHash<Terminal *, int> &table_adr_i
 	if (modified_path) {
 		// parcours et export des segments
 		QDomElement current_segment;
-		foreach(ConducerSegment *segment, segmentsList()) {
+		foreach(ConductorSegment *segment, segmentsList()) {
 			current_segment = d.createElement("segment");
 			current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical");
 			current_segment.setAttribute("length", segment -> length());
@@ -895,11 +895,11 @@ QDomElement Conducer::toXml(QDomDocument &d, QHash<Terminal *, int> &table_adr_i
 }
 
 /// @return les segments de ce conducteur
-const QList<ConducerSegment *> Conducer::segmentsList() const {
+const QList<ConductorSegment *> Conductor::segmentsList() const {
-	if (segments == NULL) return(QList<ConducerSegment *>());
+	if (segments == NULL) return(QList<ConductorSegment *>());
 	
-	QList<ConducerSegment *> segments_vector;
+	QList<ConductorSegment *> segments_vector;
-	ConducerSegment *segment = segments;
+	ConductorSegment *segment = segments;
 	
 	while (segment -> hasNextSegment()) {
 		segments_vector << segment;
@@ -912,10 +912,10 @@ const QList<ConducerSegment *> Conducer::segmentsList() const {
 /**
 	@return La longueur totale du conducteur
 */
-qreal Conducer::length() {
+qreal Conductor::length() {
 	qreal length = 0.0;
 	
-	ConducerSegment *s = segments;
+	ConductorSegment *s = segments;
 	while (s -> hasNextSegment()) {
 		length += qAbs(s -> length());
 		s = s -> nextSegment();
@@ -927,12 +927,12 @@ qreal Conducer::length() {
 /**
 	@return Le segment qui contient le point au milieu du conducteur
 */
-ConducerSegment *Conducer::middleSegment() {
+ConductorSegment *Conductor::middleSegment() {
 	if (segments == NULL) return(NULL);
 	
 	qreal half_length = length() / 2.0;
 	
-	ConducerSegment *s = segments;
+	ConductorSegment *s = segments;
 	qreal l = 0;
 	
 	while (s -> hasNextSegment()) {
@@ -949,20 +949,20 @@ ConducerSegment *Conducer::middleSegment() {
 	point au milieu du conducteur
 	@see middleSegment()
 */
-void Conducer::calculateTextItemPosition() {
+void Conductor::calculateTextItemPosition() {
 	text_item -> setPos(middleSegment() -> middle());
 }
 
 /**
 	Sauvegarde le profil courant du conducteur pour l'utiliser ulterieurement
-	dans priv_modifieConducer.
+	dans priv_modifieConductor.
 */
-void Conducer::saveProfile(bool undo) {
+void Conductor::saveProfile(bool undo) {
-	ConducerProfile old_profile = conducer_profile;
+	ConductorProfile old_profile = conductor_profile;
-	conducer_profile.fromConducer(this);
+	conductor_profile.fromConductor(this);
 	Diagram *dia = diagram();
 	if (undo && dia) {
-		dia -> undoStack().push(new ChangeConducerCommand(this, old_profile, conducer_profile));
+		dia -> undoStack().push(new ChangeConductorCommand(this, old_profile, conductor_profile));
 	}
 }
 
@@ -971,7 +971,7 @@ void Conducer::saveProfile(bool undo) {
 	@param value2 Deuxieme valeur
 	@return 1 si les deux valeurs sont de meme signe, -1 sinon
 */
-int Conducer::getCoeff(const qreal &value1, const qreal &value2) {
+int Conductor::getCoeff(const qreal &value1, const qreal &value2) {
 	return(getSign(value1) * getSign(value2));
 }
 
@@ -979,7 +979,7 @@ int Conducer::getCoeff(const qreal &value1, const qreal &value2) {
 	@param value valeur
 	@return 1 si valeur est negatif, 1 s'il est positif ou nul
 */
-int Conducer::getSign(const qreal &value) {
+int Conductor::getSign(const qreal &value) {
 	return(value < 0 ? -1 : 1);
 }
 
@@ -987,19 +987,19 @@ int Conducer::getSign(const qreal &value) {
 	Applique un nouveau profil a ce conducteur
 	@param cp Profil a appliquer a ce conducteur
 */
-void Conducer::setProfile(const ConducerProfile &cp) {
+void Conductor::setProfile(const ConductorProfile &cp) {
-	conducer_profile = cp;
+	conductor_profile = cp;
-	if (conducer_profile.isNull()) {
+	if (conductor_profile.isNull()) {
-		priv_calculeConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation());
+		priv_calculeConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation());
 		modified_path = false;
 	} else {
-		priv_modifieConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation());
+		priv_modifieConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation());
 		modified_path = true;
 	}
 	calculateTextItemPosition();
 }
 
-bool Conducer::isSingleLine() const {
+bool Conductor::isSingleLine() const {
 	return(is_single_line);
 }
 
@@ -1009,20 +1009,20 @@ bool Conducer::isSingleLine() const {
 	et vice-versa.
 	@param sl true pour un conducteur unifilaire, false pour un conducteur multifilaire
 */
-void Conducer::setSingleLine(bool sl) {
+void Conductor::setSingleLine(bool sl) {
 	is_single_line = sl;
 	text_item -> setVisible(!is_single_line);
 }
 
 /// @return le texte du conducteur
-QString Conducer::text() const {
+QString Conductor::text() const {
 	return(text_item -> toPlainText());
 }
 
 /**
 	@param t Nouveau texte du conducteur
 */
-void Conducer::setText(const QString &t) {
+void Conductor::setText(const QString &t) {
 	text_item -> setPlainText(t);
 	text_item -> previous_text = t;
 }
@@ -1061,7 +1061,7 @@ unsigned short int SingleLineProperties::phasesCount() {
 	@param direction direction du segment sur lequel les symboles apparaitront
 	@param rect rectangle englobant le dessin ; utilise pour specifier a la fois la position et la taille du dessin
 */
-void SingleLineProperties::draw(QPainter *painter, QET::ConducerSegmentType direction, const QRectF &rect) {
+void SingleLineProperties::draw(QPainter *painter, QET::ConductorSegmentType direction, const QRectF &rect) {
 	// s'il n'y a rien a dessiner, on retourne immediatement
 	if (!hasNeutral && !hasGround && !phases) return;
 	
@@ -1119,7 +1119,7 @@ void SingleLineProperties::draw(QPainter *painter, QET::ConducerSegmentType dire
 	@param center centre du segment
 	@param size taille du segment
 */
-void SingleLineProperties::drawGround(QPainter *painter, QET::ConducerSegmentType direction, QPointF center, qreal size) {
+void SingleLineProperties::drawGround(QPainter *painter, QET::ConductorSegmentType direction, QPointF center, qreal size) {
 	painter -> save();
 	
 	// prepare le QPainter
@@ -1151,7 +1151,7 @@ void SingleLineProperties::drawGround(QPainter *painter, QET::ConducerSegmentTyp
 	@param center centre du cercle
 	@param size diametre du cercle
 */
-void SingleLineProperties::drawNeutral(QPainter *painter, QET::ConducerSegmentType, QPointF center, qreal size) {
+void SingleLineProperties::drawNeutral(QPainter *painter, QET::ConductorSegmentType, QPointF center, qreal size) {
 	painter -> save();
 	
 	// prepare le QPainter

conductor.h

@@ -1,10 +1,10 @@
-#ifndef CONDUCTEUR_H
+#ifndef CONDUCTOR_H
-#define CONDUCTEUR_H
+#define CONDUCTOR_H
 #include <QtGui>
 #include "terminal.h"
-#include "conducerprofile.h"
+#include "conductorprofile.h"
 #include "diagramtextitem.h"
-class ConducerSegment;
+class ConductorSegment;
 class Element;
 /**
 	Cette classe represente les proprietes specifiques a un conducteur unifilaire
@@ -15,29 +15,29 @@ class SingleLineProperties {
 	virtual ~SingleLineProperties();
 	void setPhasesCount(int);
 	unsigned short int phasesCount();
-	void draw(QPainter *, QET::ConducerSegmentType, const QRectF &);
+	void draw(QPainter *, QET::ConductorSegmentType, const QRectF &);
 	void toXml(QDomDocument &, QDomElement &) const;
 	void fromXml(QDomElement &);
 	bool hasGround;
 	bool hasNeutral;
 	private:
 	unsigned short int phases;
-	void drawGround (QPainter *, QET::ConducerSegmentType, QPointF, qreal);
+	void drawGround (QPainter *, QET::ConductorSegmentType, QPointF, qreal);
-	void drawNeutral(QPainter *, QET::ConducerSegmentType, QPointF, qreal);
+	void drawNeutral(QPainter *, QET::ConductorSegmentType, QPointF, qreal);
 };
 
 /**
 	Cette classe represente un conducteur. Un conducteur relie deux bornes d'element.
 */
-class Conducer : public QGraphicsPathItem {
+class Conductor : public QGraphicsPathItem {
 	
 	// constructeurs, destructeur
 	public:
-	Conducer(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0);
+	Conductor(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0);
-	virtual ~Conducer();
+	virtual ~Conductor();
 	
 	private:
-	Conducer(const Conducer &);
+	Conductor(const Conductor &);
 	
 	// attributs
 	public:
@@ -62,14 +62,14 @@ class Conducer : public QGraphicsPathItem {
 	QRectF boundingRect() const;
 	virtual QPainterPath shape() const;
 	qreal length();
-	ConducerSegment *middleSegment();
+	ConductorSegment *middleSegment();
 	QString text() const;
 	void setText(const QString &);
 	static bool valideXml(QDomElement &);
 	bool fromXml(QDomElement &);
 	QDomElement toXml(QDomDocument &, QHash<Terminal *, int> &) const;
-	const QList<ConducerSegment *> segmentsList() const;
+	const QList<ConductorSegment *> segmentsList() const;
-	void setProfile(const ConducerProfile &);
+	void setProfile(const ConductorProfile &);
 	void setSingleLine(bool);
 	bool isSingleLine() const;
 	
@@ -87,40 +87,40 @@ class Conducer : public QGraphicsPathItem {
 	/// champ de texte editable pour les conducteurs non unifilaires
 	DiagramTextItem *text_item;
 	/// Segments composant le conducteur
-	ConducerSegment *segments;
+	ConductorSegment *segments;
 	/// Attributs lies aux manipulations a la souris
 	QPointF press_point;
 	bool moving_point;
 	bool moving_segment;
 	int moved_point;
 	qreal previous_z_value;
-	ConducerSegment *moved_segment;
+	ConductorSegment *moved_segment;
 	/// booleen indiquant si le conducteur a ete modifie manuellement par l'utilisateur
 	bool modified_path;
 	/// booleen indiquant s'il faut sauver le profil courant au plus tot
 	bool has_to_save_profile;
 	/// profil du conducteur : "photo" de ce a quoi le conducteur doit ressembler
-	ConducerProfile conducer_profile;
+	ConductorProfile conductor_profile;
 	/// QPen et QBrush utilises pour dessiner les conducteurs
-	static QPen conducer_pen;
+	static QPen conductor_pen;
-	static QBrush conducer_brush;
+	static QBrush conductor_brush;
 	static bool pen_and_brush_initialized;
 	
 	private:
 	void segmentsToPath();
 	void saveProfile(bool = true);
-	void priv_calculeConducer(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
+	void priv_calculeConductor(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
-	void priv_modifieConducer(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
+	void priv_modifieConductor(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation);
-	uint nbSegments(QET::ConducerSegmentType = QET::Both) const;
+	uint nbSegments(QET::ConductorSegmentType = QET::Both) const;
 	QList<QPointF> segmentsToPoints() const;
 	void pointsToSegments(QList<QPointF>);
 	bool hasClickedOn(QPointF, QPointF) const;
 	void calculateTextItemPosition();
 	static int getCoeff(const qreal &, const qreal &);
 	static int getSign(const qreal &);
-	QHash<ConducerSegmentProfile *, qreal> shareOffsetBetweenSegments(const qreal &offset, const QList<ConducerSegmentProfile *> &, const qreal & = 0.01) const;
+	QHash<ConductorSegmentProfile *, qreal> shareOffsetBetweenSegments(const qreal &offset, const QList<ConductorSegmentProfile *> &, const qreal & = 0.01) const;
 	static QPointF extendTerminal(const QPointF &, QET::Orientation, qreal = 12.0);
-	static qreal conducer_bound(qreal, qreal, qreal, qreal = 0.0);
+	static qreal conductor_bound(qreal, qreal, qreal, qreal = 0.0);
-	static qreal conducer_bound(qreal, qreal, bool);
+	static qreal conductor_bound(qreal, qreal, bool);
 };
 #endif

conductorprofile.cpp

@@ -0,0 +1,137 @@
+#include "conductorprofile.h"
+#include "conductor.h"
+#include "conductorsegmentprofile.h"
+
+/// Constructeur
+ConductorProfile::ConductorProfile() {
+}
+
+/**
+	Constructeur
+	@param Conductor conducteur dont il faut extraire le profil
+*/
+ConductorProfile::ConductorProfile(Conductor *conductor) {
+	fromConductor(conductor);
+}
+
+/**
+	Constructeur de copie
+	@param c autre conducteur
+*/
+ConductorProfile::ConductorProfile(const ConductorProfile &c) {
+	beginOrientation = c.beginOrientation;
+	endOrientation   = c.endOrientation;
+	foreach(ConductorSegmentProfile *csp, c.segments) {
+		segments << new ConductorSegmentProfile(*csp);
+	}
+}
+
+/**
+	Operateur =
+	@param c autre conducteur
+*/
+ConductorProfile &ConductorProfile::operator=(const ConductorProfile &c) {
+	if (&c == this) return(*this);
+	
+	// supprime ses informations
+	setNull();
+	
+	// copie les informations de l'autre profil de conducteur
+	beginOrientation = c.beginOrientation;
+	endOrientation   = c.endOrientation;
+	foreach(ConductorSegmentProfile *csp, c.segments) {
+		segments << new ConductorSegmentProfile(*csp);
+	}
+	return(*this);
+}
+
+/// destructeur
+ConductorProfile::~ConductorProfile() {
+	setNull();
+}
+
+/// @return true si le profil est nul
+bool ConductorProfile::isNull() const {
+	return(segments.isEmpty());
+}
+
+/// supprime les segments du profil de conducteur
+void ConductorProfile::setNull() {
+	foreach(ConductorSegmentProfile *csp, segments) delete csp;
+	segments.clear();
+}
+
+/// @return la largeur occupee par le conducteur
+qreal ConductorProfile::width() const {
+	qreal width = 0.0;
+	foreach(ConductorSegmentProfile *csp, segments) {
+		if (csp -> isHorizontal) width += csp -> length;
+	}
+	return(width);
+}
+
+/// @return la hauteur occupee par le conducteur
+qreal ConductorProfile::height() const{
+	qreal height = 0.0;
+	foreach(ConductorSegmentProfile *csp, segments) {
+		if (!csp -> isHorizontal) height += csp -> length;
+	}
+	return(height);
+}
+
+/**
+	@param type Type de Segments
+	@return Le nombre de segments composant le conducteur.
+*/
+uint ConductorProfile::nbSegments(QET::ConductorSegmentType type) const {
+	if (type == QET::Both) return(segments.count());
+	uint nb_seg = 0;
+	foreach(ConductorSegmentProfile *csp, segments) {
+		if (type == QET::Horizontal && csp -> isHorizontal) ++ nb_seg;
+		else if (type == QET::Vertical && !csp -> isHorizontal) ++ nb_seg;
+	}
+	return(nb_seg);
+}
+
+/// @return les segments horizontaux de ce profil
+QList<ConductorSegmentProfile *> ConductorProfile::horizontalSegments() {
+	QList<ConductorSegmentProfile *> segments_list;
+	foreach(ConductorSegmentProfile *csp, segments) {
+		if (csp -> isHorizontal) segments_list << csp;
+	}
+	return(segments_list);
+}
+
+/// @return les segments verticaux de ce profil
+QList<ConductorSegmentProfile *> ConductorProfile::verticalSegments() {
+	QList<ConductorSegmentProfile *> segments_list;
+	foreach(ConductorSegmentProfile *csp, segments) {
+		if (!csp -> isHorizontal) segments_list << csp;
+	}
+	return(segments_list);
+}
+
+void ConductorProfile::fromConductor(Conductor *conductor) {
+	// supprime les segments precedents
+	setNull();
+	
+	foreach(ConductorSegment *conductor_segment, conductor -> segmentsList()) {
+		segments << new ConductorSegmentProfile(conductor_segment);
+	}
+	beginOrientation = conductor -> terminal1 -> orientation();
+	endOrientation   = conductor -> terminal2 -> orientation();
+}
+
+/**
+	Permet de debugger un profil de conducteur
+	@param d Object QDebug a utiliser pour l'affichage des informations de debug
+	@param t Profil de conducteur a debugger
+*/
+QDebug &operator<<(QDebug d, ConductorProfile &t) {
+	d << "ConductorProfile {";
+	foreach(ConductorSegmentProfile *csp, t.segments) {
+		d << "CSP" << (csp -> isHorizontal ? "horizontal" : "vertical") << ":" << csp -> length << ",";
+	}
+	d << "}";
+	return(d.space());
+}

conductorprofile.h

@@ -0,0 +1,38 @@
+#ifndef CONDUCTOR_PROFILE_H
+#define CONDUCTOR_PROFILE_H
+#include <QList>
+#include "qet.h"
+class Conductor;
+class ConductorSegmentProfile;
+/**
+	Cette classe contient le profil (= les caracteristiques essentielles) d'un
+	conducteur.
+*/
+class ConductorProfile {
+	public:
+	// constructeurs, destructeur
+	ConductorProfile();
+	ConductorProfile(Conductor *conductor);
+	ConductorProfile(const ConductorProfile &);
+	ConductorProfile &operator=(const ConductorProfile &);
+	virtual ~ConductorProfile();
+	
+	// attributs
+	public:
+	QList<ConductorSegmentProfile *> segments;
+	QET::Orientation beginOrientation;
+	QET::Orientation endOrientation;
+	
+	// methodes
+	public:
+	bool isNull() const;
+	void setNull();
+	qreal width() const;
+	qreal height() const;
+	uint nbSegments(QET::ConductorSegmentType) const;
+	QList<ConductorSegmentProfile *> horizontalSegments();
+	QList<ConductorSegmentProfile *> verticalSegments();
+	void fromConductor(Conductor *);
+};
+QDebug &operator<<(QDebug d, ConductorProfile &);
+#endif

conductorproperties.cpp

@@ -1,13 +1,13 @@
-#include "conducerproperties.h"
+#include "conductorproperties.h"
-#include "conducer.h"
+#include "conductor.h"
 
-ConducerPropertiesWidget::ConducerPropertiesWidget(QWidget *parent) :
+ConductorPropertiesWidget::ConductorPropertiesWidget(QWidget *parent) :
 	QWidget(parent)
 {
 	buildInterface();
 }
 
-void ConducerPropertiesWidget::buildInterface() {
+void ConductorPropertiesWidget::buildInterface() {
 	
 	setFixedSize(380, 245);
 	
@@ -64,7 +64,7 @@ void ConducerPropertiesWidget::buildInterface() {
 	setSingleLine(false);
 }
 
-void ConducerPropertiesWidget::buildConnections() {
+void ConductorPropertiesWidget::buildConnections() {
 	connect(phase_slider,      SIGNAL(valueChanged(int)),  phase_spinbox, SLOT(setValue(int)));
 	connect(phase_spinbox,     SIGNAL(valueChanged(int)),  phase_slider,  SLOT(setValue(int)));
 	connect(ground_checkbox,   SIGNAL(toggled(bool)),      this,          SLOT(updateSingleLineConfig()));
@@ -75,7 +75,7 @@ void ConducerPropertiesWidget::buildConnections() {
 	
 }
 
-void ConducerPropertiesWidget::destroyConnections() {
+void ConductorPropertiesWidget::destroyConnections() {
 	disconnect(phase_slider,      SIGNAL(valueChanged(int)),  phase_spinbox, SLOT(setValue(int)));
 	disconnect(phase_spinbox,     SIGNAL(valueChanged(int)),  phase_slider,  SLOT(setValue(int)));
 	disconnect(ground_checkbox,   SIGNAL(toggled(bool)),      this,          SLOT(updateSingleLineConfig()));
@@ -85,18 +85,18 @@ void ConducerPropertiesWidget::destroyConnections() {
 	disconnect(singleline,        SIGNAL(toggled(bool)),      this,          SLOT(setSingleLine(bool)));
 }
 
-ConducerPropertiesWidget::~ConducerPropertiesWidget() {
+ConductorPropertiesWidget::~ConductorPropertiesWidget() {
 }
 
 
-void ConducerPropertiesWidget::updateSingleLineConfig() {
+void ConductorPropertiesWidget::updateSingleLineConfig() {
 	slp.hasGround = ground_checkbox -> isChecked();
 	slp.hasNeutral = neutral_checkbox -> isChecked();
 	slp.setPhasesCount(phase_checkbox -> isChecked() ? phase_spinbox -> value() : 0);
 	updatePreview();
 }
 
-void ConducerPropertiesWidget::updateSingleLineDisplay() {
+void ConductorPropertiesWidget::updateSingleLineDisplay() {
 	destroyConnections();
 	ground_checkbox -> setChecked(slp.hasGround);
 	neutral_checkbox -> setChecked(slp.hasNeutral);
@@ -106,7 +106,7 @@ void ConducerPropertiesWidget::updateSingleLineDisplay() {
 	updatePreview();
 }
 
-void ConducerPropertiesWidget::updatePreview() {
+void ConductorPropertiesWidget::updatePreview() {
 	const QRect pixmap_rect(0, 0, 96, 96);
 	QPixmap pixmap(pixmap_rect.width(), pixmap_rect.height());
 	QPainter painter;
@@ -119,11 +119,11 @@ void ConducerPropertiesWidget::updatePreview() {
 	preview -> setPixmap(pixmap);
 }
 
-bool ConducerPropertiesWidget::isSingleLine() const {
+bool ConductorPropertiesWidget::isSingleLine() const {
 	return(singleline -> isChecked());
 }
 
-void ConducerPropertiesWidget::setSingleLine(bool sl) {
+void ConductorPropertiesWidget::setSingleLine(bool sl) {
 	singleline       -> setChecked(sl);
 	multiline        -> setChecked(!sl);
 	text_field       -> setEnabled(!sl);
@@ -137,22 +137,22 @@ void ConducerPropertiesWidget::setSingleLine(bool sl) {
 }
 
 /// @param prop Les nouvelles proprietes unifilaires de ce conducteur
-void ConducerPropertiesWidget::setSingleLineProperties(const SingleLineProperties &prop) {
+void ConductorPropertiesWidget::setSingleLineProperties(const SingleLineProperties &prop) {
 	slp = prop;
 	updateSingleLineDisplay();
 }
 
 /// @return les proprietes unifilaires de ce conducteur
-SingleLineProperties ConducerPropertiesWidget::singleLineProperties() const {
+SingleLineProperties ConductorPropertiesWidget::singleLineProperties() const {
 	return(slp);
 }
 
 /// @param text Le texte de ce conducteur
-void ConducerPropertiesWidget::setConducerText(const QString &text) {
+void ConductorPropertiesWidget::setConductorText(const QString &text) {
 	text_field -> setText(text);
 }
 
 /// @return Le texte de ce conducteur
-QString ConducerPropertiesWidget::conducerText() const {
+QString ConductorPropertiesWidget::conductorText() const {
 	return(text_field -> text());
 }

conductorproperties.h

@@ -1,24 +1,24 @@
-#ifndef CONDUCER_PROPERTIES_WIDGET_H
+#ifndef CONDUCTOR_PROPERTIES_WIDGET_H
-#define CONDUCER_PROPERTIES_WIDGET_H
+#define CONDUCTOR_PROPERTIES_WIDGET_H
-#include "conducer.h"
+#include "conductor.h"
 #include <QtGui>
-class ConducerPropertiesWidget : public QWidget {
+class ConductorPropertiesWidget : public QWidget {
 	Q_OBJECT
 	// constructeurs, destructeur
 	public:
-	ConducerPropertiesWidget(QWidget * = 0);
+	ConductorPropertiesWidget(QWidget * = 0);
-	virtual ~ConducerPropertiesWidget();
+	virtual ~ConductorPropertiesWidget();
 	
 	private:
-	ConducerPropertiesWidget(const ConducerPropertiesWidget  &);
+	ConductorPropertiesWidget(const ConductorPropertiesWidget  &);
 	
 	// methodes
 	public:
 	bool isSingleLine() const;
 	void setSingleLineProperties(const SingleLineProperties &);
 	SingleLineProperties singleLineProperties() const;
-	QString conducerText() const;
+	QString conductorText() const;
-	void setConducerText(const QString &);
+	void setConductorText(const QString &);
 	
 	public slots:
 	void updatePreview();
@@ -39,7 +39,7 @@ class ConducerPropertiesWidget : public QWidget {
 	QLabel *preview;
 	
 	SingleLineProperties slp;
-	QString conducer_text;
+	QString conductor_text;
 	
 	// methodes privees
 	void buildInterface();

conductorsegment.cpp

@@ -1,4 +1,4 @@
-#include "conducersegment.h"
+#include "conductorsegment.h"
 #include <QDebug>
 
 /**
@@ -8,11 +8,11 @@
 	@param cs1 Le segment precedent
 	@param cs2 Le segment suivant
 */
-ConducerSegment::ConducerSegment(
+ConductorSegment::ConductorSegment(
 	const QPointF &p1,
 	const QPointF &p2,
-	ConducerSegment *cs1,
+	ConductorSegment *cs1,
-	ConducerSegment *cs2
+	ConductorSegment *cs2
 ) :
 	point1(p1),
 	point2(p2)
@@ -24,7 +24,7 @@ ConducerSegment::ConducerSegment(
 /**
 	Destructeur - Relie le segment precedent au suivant
 */
-ConducerSegment::~ConducerSegment() {
+ConductorSegment::~ConductorSegment() {
 	if (hasPreviousSegment()) previousSegment() -> setNextSegment(nextSegment());
 	if (hasNextSegment()) nextSegment() -> setPreviousSegment(previousSegment());
 }
@@ -38,9 +38,9 @@ ConducerSegment::~ConducerSegment() {
 	@param possible_dx La valeur du mouvement possible (au maximum)
 	@return true si le mouvement est possible ; false s'il doit etre limite
 */
-bool ConducerSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx) const {
+bool ConductorSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx) const {
 	
-	Q_ASSERT_X(isVertical(), "ConducerSegment::canMove1stPointX", "segment non vertical");
+	Q_ASSERT_X(isVertical(), "ConductorSegment::canMove1stPointX", "segment non vertical");
 	
 	/// On ne bouge jamais le premier point d'un segment statique.
 	if (isStatic()) {
@@ -97,9 +97,9 @@ bool ConducerSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx
 	@param possible_dx La valeur du mouvement possible (au maximum)
 	@return true si le mouvement est possible ; false s'il doit etre limite
 */
-bool ConducerSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx) const {
+bool ConductorSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx) const {
 	
-	Q_ASSERT_X(isVertical(), "ConducerSegment::canMove2ndPointX", "segment non vertical");
+	Q_ASSERT_X(isVertical(), "ConductorSegment::canMove2ndPointX", "segment non vertical");
 	
 	/// On ne modifie jamais l'abscisse du second point d'un segment statique.
 	if (isStatic()) {
@@ -156,9 +156,9 @@ bool ConducerSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx
 	@param possible_dy La valeur du mouvement possible (au maximum)
 	@return true si le mouvement est possible ; false s'il doit etre limite
 */
-bool ConducerSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy) const {
+bool ConductorSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy) const {
 	
-	Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove1stPointY", "segment non horizontal");
+	Q_ASSERT_X(isHorizontal(), "ConductorSegment::canMove1stPointY", "segment non horizontal");
 	
 	/// On ne bouge jamais le premier point d'un segment statique.
 	if (isStatic()) {
@@ -215,9 +215,9 @@ bool ConducerSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy
 	@param possible_dy La valeur du mouvement possible (au maximum)
 	@return true si le mouvement est possible ; false s'il doit etre limite
 */
-bool ConducerSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy) const {
+bool ConductorSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy) const {
 	
-	Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove2ndPointY", "segment non horizontal");
+	Q_ASSERT_X(isHorizontal(), "ConductorSegment::canMove2ndPointY", "segment non horizontal");
 	
 	/// On ne modifie jamais l'abscisse du second point d'un segment statique.
 	if (isStatic()) {
@@ -270,9 +270,9 @@ bool ConducerSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy
 	Gere les mouvements sur l'axe horizontal
 	@param dx taille du deplacement en pixels
 */
-void ConducerSegment::moveX(const qreal &dx) {
+void ConductorSegment::moveX(const qreal &dx) {
 	if (isHorizontal()) return;
-	Q_ASSERT_X(isVertical(), "ConducerSegment::moveX", "segment non vertical");
+	Q_ASSERT_X(isVertical(), "ConductorSegment::moveX", "segment non vertical");
 	
 	bool has_prev_segment = hasPreviousSegment();
 	bool has_next_segment = hasNextSegment();
@@ -291,7 +291,7 @@ void ConducerSegment::moveX(const qreal &dx) {
 	if (has_prev_segment) {
 		point1.rx() += final_movement;
 		if (previous_segment -> isFirstSegment()) {
-			new ConducerSegment(
+			new ConductorSegment(
 				previous_segment -> point2,
 				point1,
 				previous_segment,
@@ -304,7 +304,7 @@ void ConducerSegment::moveX(const qreal &dx) {
 	if (has_next_segment) {
 		point2.rx() += final_movement;
 		if (next_segment -> isLastSegment()) {
-			new ConducerSegment(
+			new ConductorSegment(
 				point2,
 				next_segment -> point1,
 				this,
@@ -318,9 +318,9 @@ void ConducerSegment::moveX(const qreal &dx) {
 	Gere les mouvements sur l'axe vertical
 	@param dx taille du deplacement en pixels
 */
-void ConducerSegment::moveY(const qreal &dy) {
+void ConductorSegment::moveY(const qreal &dy) {
 	if (isVertical()) return;
-	Q_ASSERT_X(isHorizontal(), "ConducerSegment::moveY", "segment non horizontal");
+	Q_ASSERT_X(isHorizontal(), "ConductorSegment::moveY", "segment non horizontal");
 	
 	bool has_prev_segment = hasPreviousSegment();
 	bool has_next_segment = hasNextSegment();
@@ -339,7 +339,7 @@ void ConducerSegment::moveY(const qreal &dy) {
 	if (has_prev_segment) {
 		point1.ry() += final_movement;
 		if (previous_segment -> isFirstSegment()) {
-			new ConducerSegment(
+			new ConductorSegment(
 				previous_segment -> point2,
 				point1,
 				previous_segment,
@@ -352,7 +352,7 @@ void ConducerSegment::moveY(const qreal &dy) {
 	if (has_next_segment) {
 		point2.ry() += final_movement;
 		if (next_segment -> isLastSegment()) {
-			new ConducerSegment(
+			new ConductorSegment(
 				point2,
 				next_segment -> point1,
 				this,
@@ -366,7 +366,7 @@ void ConducerSegment::moveY(const qreal &dy) {
 	Change le segment precedent
 	@param ps Le nouveau segment precedent
 */
-void ConducerSegment::setPreviousSegment(ConducerSegment *ps) {
+void ConductorSegment::setPreviousSegment(ConductorSegment *ps) {
 	previous_segment = ps;
 	if (hasPreviousSegment()) {
 		if (previousSegment() -> nextSegment() != this) previousSegment() -> setNextSegment(this);
@@ -377,7 +377,7 @@ void ConducerSegment::setPreviousSegment(ConducerSegment *ps) {
 	Change le segment suivant
 	@param ps Le nouveau segment suivant
 */
-void ConducerSegment::setNextSegment(ConducerSegment *ns) {
+void ConductorSegment::setNextSegment(ConductorSegment *ns) {
 	next_segment = ns;
 	if (hasNextSegment()) {
 		if (nextSegment() -> previousSegment() != this) nextSegment() -> setPreviousSegment(this);
@@ -385,59 +385,59 @@ void ConducerSegment::setNextSegment(ConducerSegment *ns) {
 }
 
 /// @return true si ce segment est un segment statique, cad un segment relie a une borne
-bool ConducerSegment::isStatic() const {
+bool ConductorSegment::isStatic() const {
 	return(isFirstSegment() || isLastSegment());
 }
 
 /// @return true si ce segment est le premier du conducteur
-bool ConducerSegment::isFirstSegment() const {
+bool ConductorSegment::isFirstSegment() const {
 	return(!hasPreviousSegment());
 }
 
 /// @return true si ce segment est le dernier du conducteur
-bool ConducerSegment::isLastSegment() const {
+bool ConductorSegment::isLastSegment() const {
 	return(!hasNextSegment());
 }
 
 /**
 	@return Le segment precedent
 */
-ConducerSegment *ConducerSegment::previousSegment()  const {
+ConductorSegment *ConductorSegment::previousSegment()  const {
 	return(previous_segment);
 }
 
 /**
 	@return Le segment suivant
 */
-ConducerSegment *ConducerSegment::nextSegment()  const {
+ConductorSegment *ConductorSegment::nextSegment()  const {
 	return(next_segment);
 }
 
 /**
 	@return true si le segment est vertical, false sinon
 */
-bool ConducerSegment::isVertical() const {
+bool ConductorSegment::isVertical() const {
 	return(point1.x() == point2.x());
 }
 
 /**
 	@return true si le segment est horizontal, false sinon
 */
-bool ConducerSegment::isHorizontal() const {
+bool ConductorSegment::isHorizontal() const {
 	return(point1.y() == point2.y());
 }
 
 /**
 	@return le premier point du segment
 */
-QPointF ConducerSegment::firstPoint() const {
+QPointF ConductorSegment::firstPoint() const {
 	return(point1);
 }
 
 /**
 	@return le second point du segment
 */
-QPointF ConducerSegment::secondPoint() const {
+QPointF ConductorSegment::secondPoint() const {
 	return(point2);
 }
 
@@ -445,7 +445,7 @@ QPointF ConducerSegment::secondPoint() const {
 	Permet de changer la position du premier point du segment
 	@param p La nouvelle position du premier point
 */
-void ConducerSegment::setFirstPoint(const QPointF &p) {
+void ConductorSegment::setFirstPoint(const QPointF &p) {
 	point1 = p;
 }
 
@@ -453,28 +453,28 @@ void ConducerSegment::setFirstPoint(const QPointF &p) {
 	Permet de changer la position du second point du segment
 	@param p La nouvelle position du second point
 */
-void ConducerSegment::setSecondPoint(const QPointF &p) {
+void ConductorSegment::setSecondPoint(const QPointF &p) {
 	point2 = p;
 }
 
 /**
 	@return true si le segment a un segment precedent, false sinon
 */
-bool ConducerSegment::hasPreviousSegment() const {
+bool ConductorSegment::hasPreviousSegment() const {
 	return(previous_segment != NULL);
 }
 
 /**
 	@return true si le segment a un segment suivant, false sinon
 */
-bool ConducerSegment::hasNextSegment() const {
+bool ConductorSegment::hasNextSegment() const {
 	return(next_segment != NULL);
 }
 
 /**
 	@return Le centre du rectangle delimitant le conducteur
 */
-QPointF ConducerSegment::middle() const {
+QPointF ConductorSegment::middle() const {
 	return(
 		QPointF(
 			(point1.x() + point2.x()) / 2.0,
@@ -486,7 +486,7 @@ QPointF ConducerSegment::middle() const {
 /**
 	@return La longueur du conducteur
 */
-qreal ConducerSegment::length() const {
+qreal ConductorSegment::length() const {
 	if (isHorizontal()) {
 		return(secondPoint().x() - firstPoint().x());
 	} else {
@@ -494,6 +494,6 @@ qreal ConducerSegment::length() const {
 	}
 }
 
-QET::ConducerSegmentType ConducerSegment::type() const {
+QET::ConductorSegmentType ConductorSegment::type() const {
 	return(isHorizontal() ? QET::Horizontal : QET::Vertical);
 }

conductorsegment.h

@@ -1,24 +1,24 @@
-#ifndef CONDUCER_SEGMENT_H
+#ifndef CONDUCTOR_SEGMENT_H
-#define CONDUCER_SEGMENT_H
+#define CONDUCTOR_SEGMENT_H
 #include <QPointF>
 #include "qet.h"
 /**
 	Cette classe represente un segment de conducteur.
 */
-class ConducerSegment {
+class ConductorSegment {
 	
 	// constructeurs, destructeur
 	public:
-	ConducerSegment(const QPointF &, const QPointF &, ConducerSegment * = NULL, ConducerSegment * = NULL);
+	ConductorSegment(const QPointF &, const QPointF &, ConductorSegment * = NULL, ConductorSegment * = NULL);
-	virtual ~ConducerSegment();
+	virtual ~ConductorSegment();
 	
 	private:
-	ConducerSegment(const ConducerSegment &);
+	ConductorSegment(const ConductorSegment &);
 	
 	// attributs
 	private:
-	ConducerSegment *previous_segment;
+	ConductorSegment *previous_segment;
-	ConducerSegment *next_segment;
+	ConductorSegment *next_segment;
 	QPointF point1;
 	QPointF point2;
 	
@@ -26,12 +26,12 @@ class ConducerSegment {
 	public:
 	void moveX(const qreal &);
 	void moveY(const qreal &);
-	ConducerSegment *previousSegment() const;
+	ConductorSegment *previousSegment() const;
-	ConducerSegment *nextSegment()  const;
+	ConductorSegment *nextSegment()  const;
 	bool hasPreviousSegment() const;
 	bool hasNextSegment() const;
-	void setPreviousSegment(ConducerSegment *);
+	void setPreviousSegment(ConductorSegment *);
-	void setNextSegment(ConducerSegment *);
+	void setNextSegment(ConductorSegment *);
 	bool isStatic() const;
 	bool isFirstSegment() const;
 	bool isLastSegment() const;
@@ -42,7 +42,7 @@ class ConducerSegment {
 	QPointF middle() const;
 	bool isHorizontal() const;
 	bool isVertical() const;
-	QET::ConducerSegmentType type() const;
+	QET::ConductorSegmentType type() const;
 	qreal length() const;
 	bool canMove1stPointX(const qreal &, qreal &) const;
 	bool canMove2ndPointX(const qreal &, qreal &) const;

conductorsegmentprofile.h

@@ -1,12 +1,12 @@
-#ifndef CONDUCER_SEGMENT_PROFILE_H
+#ifndef CONDUCTOR_SEGMENT_PROFILE_H
-#define CONDUCER_SEGMENT_PROFILE_H
+#define CONDUCTOR_SEGMENT_PROFILE_H
 #include <QtCore>
-#include "conducersegment.h"
+#include "conductorsegment.h"
 /**
 	Cette classe contient le profil (= les caracteristiques essentielles) d'un
 	segment de conducteur.
 */
-class ConducerSegmentProfile {
+class ConductorSegmentProfile {
 	// constructeurs, destructeur
 	public:
 	/**
@@ -14,7 +14,7 @@ class ConducerSegmentProfile {
 		@param l longueur du segment
 		@param ori true si le segment est horizontal, false s'il est vertical
 	*/
-	ConducerSegmentProfile(qreal l, bool ori = true) :
+	ConductorSegmentProfile(qreal l, bool ori = true) :
 		length(l),
 		isHorizontal(ori)
 	{
@@ -22,16 +22,16 @@ class ConducerSegmentProfile {
 	
 	/**
 		Constructeur
-		@param segment ConducerSegment dont il faut extraire le profil
+		@param segment ConductorSegment dont il faut extraire le profil
 	*/
-	ConducerSegmentProfile(ConducerSegment *segment) :
+	ConductorSegmentProfile(ConductorSegment *segment) :
 		length(segment -> length()),
 		isHorizontal(segment -> isHorizontal())
 	{
 	}
 	
 	/// Destructeur
-	virtual ~ConducerSegmentProfile() {
+	virtual ~ConductorSegmentProfile() {
 	}
 	
 	// attributs

customelement.cpp

@@ -145,10 +145,10 @@ QList<Terminal *> CustomElement::terminals() const {
 	return(list_terminals);
 }
 
-QList<Conducer *> CustomElement::conducers() const {
+QList<Conductor *> CustomElement::conductors() const {
-	QList<Conducer *> conducers;
+	QList<Conductor *> conductors;
-	foreach(Terminal *t, list_terminals) conducers << t -> conducers();
+	foreach(Terminal *t, list_terminals) conductors << t -> conductors();
-	return(conducers);
+	return(conductors);
 }
 
 /**

customelement.h

@@ -34,7 +34,7 @@ class CustomElement : public FixedElement {
 	// methodes
 	public:
 	virtual QList<Terminal *> terminals() const;
-	virtual QList<Conducer *> conducers() const;
+	virtual QList<Conductor *> conductors() const;
 	virtual int nbTerminals() const;
 	virtual void paint(QPainter *, const QStyleOptionGraphicsItem *);
 	QString typeId() const;

diagram.cpp

@@ -1,6 +1,6 @@
 #include <math.h>
 #include "qetapp.h"
-#include "conducer.h"
+#include "conductor.h"
 #include "customelement.h"
 #include "diagram.h"
 #include "exportdialog.h"
@@ -12,14 +12,14 @@
 */
 Diagram::Diagram(QObject *parent) : QGraphicsScene(parent), qgi_manager(this) {
 	setBackgroundBrush(Qt::white);
-	conducer_setter = new QGraphicsLineItem(0, 0);
+	conductor_setter = new QGraphicsLineItem(0, 0);
-	conducer_setter -> setZValue(1000000);
+	conductor_setter -> setZValue(1000000);
 	QPen t;
 	t.setColor(Qt::black);
 	t.setWidthF(1.5);
 	t.setStyle(Qt::DashLine);
-	conducer_setter -> setPen(t);
+	conductor_setter -> setPen(t);
-	conducer_setter -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
+	conductor_setter -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
 	draw_grid  = true;
 	use_border = true;
 	moved_elements_fetched = false;
@@ -112,8 +112,8 @@ void Diagram::keyReleaseEvent(QKeyEvent *e) {
 			new MoveElementsCommand(
 				this,
 				elementsToMove(),
-				conducersToMove(),
+				conductorsToMove(),
-				conducersToUpdate(),
+				conductorsToUpdate(),
 				current_movement
 			)
 		);
@@ -227,18 +227,18 @@ QDomDocument Diagram::toXml(bool diagram) {
 	
 	// creation de deux listes : une qui contient les elements, une qui contient les conducteurs
 	QList<Element *> liste_elements;
-	QList<Conducer *> liste_conducers;
+	QList<Conductor *> liste_conductors;
 	
 	// Determine les elements a <20> XMLiser <20>
 	foreach(QGraphicsItem *qgi, items()) {
 		if (Element *elmt = qgraphicsitem_cast<Element *>(qgi)) {
 			if (diagram) liste_elements << elmt;
 			else if (elmt -> isSelected()) liste_elements << elmt;
-		} else if (Conducer *f = qgraphicsitem_cast<Conducer *>(qgi)) {
+		} else if (Conductor *f = qgraphicsitem_cast<Conductor *>(qgi)) {
-			if (diagram) liste_conducers << f;
+			if (diagram) liste_conductors << f;
 			// lorsqu'on n'exporte pas tout le diagram, il faut retirer les conducteurs non selectionnes
 			// et pour l'instant, les conducteurs non selectionnes sont les conducteurs dont un des elements n'est pas relie
-			else if (f -> terminal1 -> parentItem() -> isSelected() && f -> terminal2 -> parentItem() -> isSelected()) liste_conducers << f;
+			else if (f -> terminal1 -> parentItem() -> isSelected() && f -> terminal2 -> parentItem() -> isSelected()) liste_conductors << f;
 		}
 	}
 	
@@ -254,12 +254,12 @@ QDomDocument Diagram::toXml(bool diagram) {
 	racine.appendChild(elements);
 	
 	// enregistrement des conducteurs
-	if (liste_conducers.isEmpty()) return(document);
+	if (liste_conductors.isEmpty()) return(document);
-	QDomElement conducers = document.createElement("conducers");
+	QDomElement conductors = document.createElement("conductors");
-	foreach(Conducer *cond, liste_conducers) {
+	foreach(Conductor *cond, liste_conductors) {
-		conducers.appendChild(cond -> toXml(document, table_adr_id));
+		conductors.appendChild(cond -> toXml(document, table_adr_id));
 	}
-	racine.appendChild(conducers);
+	racine.appendChild(conductors);
 	
 	// on retourne le document XML ainsi genere
 	return(document);
@@ -281,7 +281,7 @@ QDomDocument Diagram::toXml(bool diagram) {
 	fromXml
 	@return true si l'import a reussi, false sinon
 */
-bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList<Element *> *added_elements, QList<Conducer *> *added_conducers) {
+bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList<Element *> *added_elements, QList<Conductor *> *added_conductors) {
 	QDomElement racine = document.documentElement();
 	// le premier element doit etre un schema
 	if (racine.tagName() != "diagram") return(false);
@@ -381,13 +381,13 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in
 	// chargement de tous les Conducteurs du fichier XML
 	for (QDomNode node = racine.firstChild() ; !node.isNull() ; node = node.nextSibling()) {
 		// on s'interesse a l'element XML "conducteurs" (= groupe de conducteurs)
-		QDomElement conducers = node.toElement();
+		QDomElement conductors = node.toElement();
-		if(conducers.isNull() || conducers.tagName() != "conducers") continue;
+		if(conductors.isNull() || conductors.tagName() != "conductors") continue;
 		// parcours des enfants de l'element XML "conducteurs"
-		for (QDomNode n = conducers.firstChild() ; !n.isNull() ; n = n.nextSibling()) {
+		for (QDomNode n = conductors.firstChild() ; !n.isNull() ; n = n.nextSibling()) {
 			// on s'interesse a l'element XML "element" (elements eux-memes)
 			QDomElement f = n.toElement();
-			if (f.isNull() || !Conducer::valideXml(f)) continue;
+			if (f.isNull() || !Conductor::valideXml(f)) continue;
 			// verifie que les bornes que le conducteur relie sont connues
 			int id_p1 = f.attribute("terminal1").toInt();
 			int id_p2 = f.attribute("terminal2").toInt();
@@ -396,16 +396,16 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in
 				Terminal *p1 = table_adr_id.value(id_p1);
 				Terminal *p2 = table_adr_id.value(id_p2);
 				if (p1 != p2) {
-					bool peut_poser_conducer = true;
+					bool peut_poser_conductor = true;
 					bool cia = ((Element *)p2 -> parentItem()) -> connexionsInternesAcceptees();
-					if (!cia) foreach(QGraphicsItem *item, p2 -> parentItem() -> children()) if (item == p1) peut_poser_conducer = false;
+					if (!cia) foreach(QGraphicsItem *item, p2 -> parentItem() -> children()) if (item == p1) peut_poser_conductor = false;
-					if (peut_poser_conducer) {
+					if (peut_poser_conductor) {
-						Conducer *c = new Conducer(table_adr_id.value(id_p1), table_adr_id.value(id_p2), 0, this);
+						Conductor *c = new Conductor(table_adr_id.value(id_p1), table_adr_id.value(id_p2), 0, this);
 						c -> fromXml(f);
-						if (added_conducers) (*added_conducers) << c;
+						if (added_conductors) (*added_conductors) << c;
 					}
 				}
-			} else qDebug() << "Le chargement du conducer" << id_p1 << id_p2 << "a echoue";
+			} else qDebug() << "Le chargement du conductor" << id_p1 << id_p2 << "a echoue";
 		}
 	}
 	return(true);
@@ -444,8 +444,8 @@ void Diagram::invalidateMovedElements() {
 	if (!moved_elements_fetched) return;
 	moved_elements_fetched = false;
 	elements_to_move.clear();
-	conducers_to_move.clear();
+	conductors_to_move.clear();
-	conducers_to_update.clear();
+	conductors_to_update.clear();
 }
 
 /// reconstruit la liste des elements et conducteurs en mouvement
@@ -460,18 +460,18 @@ void Diagram::fetchMovedElements() {
 	// pour chaque element deplace, determine les conducteurs qui seront modifies
 	foreach(Element *elmt, elements_to_move) {
 		foreach(Terminal *terminal, elmt -> terminals()) {
-			foreach(Conducer *conducer, terminal -> conducers()) {
+			foreach(Conductor *conductor, terminal -> conductors()) {
 				Terminal *other_terminal;
-				if (conducer -> terminal1 == terminal) {
+				if (conductor -> terminal1 == terminal) {
-					other_terminal = conducer -> terminal2;
+					other_terminal = conductor -> terminal2;
 				} else {
-					other_terminal = conducer -> terminal1;
+					other_terminal = conductor -> terminal1;
 				}
 				// si les deux elements du conducteur sont deplaces
 				if (elements_to_move.contains(static_cast<Element *>(other_terminal -> parentItem()))) {
-					conducers_to_move << conducer;
+					conductors_to_move << conductor;
 				} else {
-					conducers_to_update.insert(conducer, terminal);
+					conductors_to_update.insert(conductor, terminal);
 				}
 			}
 		}
@@ -487,12 +487,12 @@ void Diagram::setDrawTerminals(bool dt) {
 	}
 }
 
-QSet<Conducer *> Diagram::selectedConducers() const {
+QSet<Conductor *> Diagram::selectedConductors() const {
-	QSet<Conducer *> conducers_set;
+	QSet<Conductor *> conductors_set;
 	foreach(QGraphicsItem *qgi, selectedItems()) {
-		if (Conducer *c = qgraphicsitem_cast<Conducer *>(qgi)) {
+		if (Conductor *c = qgraphicsitem_cast<Conductor *>(qgi)) {
-			conducers_set << c;
+			conductors_set << c;
 		}
 	}
-	return(conducers_set);
+	return(conductors_set);
 }

diagram.h

@@ -10,7 +10,7 @@
 #include "qgimanager.h"
 class Element;
 class Terminal;
-class Conducer;
+class Conductor;
 class Diagram : public QGraphicsScene {
 	Q_OBJECT
 	
@@ -29,13 +29,13 @@ class Diagram : public QGraphicsScene {
 	QPointF current_movement;
 	
 	private:
-	QGraphicsLineItem *conducer_setter;
+	QGraphicsLineItem *conductor_setter;
 	bool draw_grid;
 	bool use_border;
 	bool moved_elements_fetched;
 	QSet<Element *> elements_to_move;
-	QSet<Conducer *> conducers_to_move;
+	QSet<Conductor *> conductors_to_move;
-	QHash<Conducer *, Terminal *> conducers_to_update;
+	QHash<Conductor *, Terminal *> conductors_to_update;
 	QGIManager qgi_manager;
 	QUndoStack undo_stack;
 	bool draw_terminals;
@@ -47,13 +47,13 @@ class Diagram : public QGraphicsScene {
 	void keyReleaseEvent(QKeyEvent *);
 	
 	// fonctions relatives a la pose de conducteurs
-	void setConducer(bool);
+	void setConductor(bool);
-	void setConducerStart (QPointF);
+	void setConductorStart (QPointF);
-	void setConducerStop(QPointF);
+	void setConductorStop(QPointF);
 	
 	// fonctions relatives a l'import / export XML
 	QDomDocument toXml(bool = true);
-	bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList<Element *> * = NULL, QList<Conducer *> * = NULL);
+	bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList<Element *> * = NULL, QList<Conductor *> * = NULL);
 	
 	// fonctions relatives aux options graphiques
 	void setDisplayGrid(bool);
@@ -73,9 +73,9 @@ class Diagram : public QGraphicsScene {
 	void invalidateMovedElements();
 	void fetchMovedElements();
 	const QSet<Element *> &elementsToMove();
-	const QSet<Conducer *> &conducersToMove();
+	const QSet<Conductor *> &conductorsToMove();
-	const QHash<Conducer *, Terminal *> &conducersToUpdate();
+	const QHash<Conductor *, Terminal *> &conductorsToUpdate();
-	QSet<Conducer *> selectedConducers() const;
+	QSet<Conductor *> selectedConductors() const;
 	
 	QUndoStack &undoStack();
 	QGIManager &qgiManager();
@@ -93,11 +93,11 @@ class Diagram : public QGraphicsScene {
 	bornes.
 	@param true pour ajouter le poseur de conducteur, false pour l'enlever
 */
-inline void Diagram::setConducer(bool pf) {
+inline void Diagram::setConductor(bool pf) {
 	if (pf) {
-		if (!conducer_setter -> scene()) addItem(conducer_setter);
+		if (!conductor_setter -> scene()) addItem(conductor_setter);
 	} else {
-		if (conducer_setter -> scene()) removeItem(conducer_setter);
+		if (conductor_setter -> scene()) removeItem(conductor_setter);
 	}
 }
 
@@ -105,16 +105,16 @@ inline void Diagram::setConducer(bool pf) {
 	Specifie les coordonnees du point de depart du poseur de conducteur
 	@param d Le nouveau point de depart du poseur de conducteur
 */
-inline void Diagram::setConducerStart(QPointF d) {
+inline void Diagram::setConductorStart(QPointF d) {
-	conducer_setter -> setLine(QLineF(d, conducer_setter -> line().p2()));
+	conductor_setter -> setLine(QLineF(d, conductor_setter -> line().p2()));
 }
 
 /**
 	Specifie les coordonnees du point d'arrivee du poseur de conducteur
 	@param d Le nouveau point d'arrivee du poseur de conducteur
 */
-inline void Diagram::setConducerStop(QPointF a) {
+inline void Diagram::setConductorStop(QPointF a) {
-	conducer_setter -> setLine(QLineF(conducer_setter -> line().p1(), a));
+	conductor_setter -> setLine(QLineF(conductor_setter -> line().p1(), a));
 }
 
 /**
@@ -181,15 +181,15 @@ inline const QSet<Element *> &Diagram::elementsToMove() {
 }
 
 /// @return la liste des conducteurs a deplacer
-inline const QSet<Conducer *> &Diagram::conducersToMove() {
+inline const QSet<Conductor *> &Diagram::conductorsToMove() {
 	if (!moved_elements_fetched) fetchMovedElements();
-	return(conducers_to_move);
+	return(conductors_to_move);
 }
 
 /// @return la liste des conducteurs a modifier (typiquement les conducteurs dont seul un element est deplace)
-inline const QHash<Conducer *, Terminal *> &Diagram::conducersToUpdate() {
+inline const QHash<Conductor *, Terminal *> &Diagram::conductorsToUpdate() {
 	if (!moved_elements_fetched) fetchMovedElements();
-	return(conducers_to_update);
+	return(conductors_to_update);
 }
 
 /// @return la pile d'annulations de ce schema

diagramcommands.cpp

@@ -1,6 +1,6 @@
 #include "diagramcommands.h"
 #include "element.h"
-#include "conducer.h"
+#include "conductor.h"
 #include "diagram.h"
 #include "qgimanager.h"
 /**
@@ -47,63 +47,63 @@ void AddElementCommand::redo() {
 	@param t2 Seconde borne du conducteur
 	@param parent QUndoCommand parent
 */
-AddConducerCommand::AddConducerCommand(
+AddConductorCommand::AddConductorCommand(
 	Diagram *d,
-	Conducer *c,
+	Conductor *c,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(QObject::tr("ajouter un conducteur"), parent),
-	conducer(c),
+	conductor(c),
 	diagram(d)
 {
-	diagram -> qgiManager().manage(conducer);
+	diagram -> qgiManager().manage(conductor);
 }
 
 /// Destructeur
-AddConducerCommand::~AddConducerCommand() {
+AddConductorCommand::~AddConductorCommand() {
-	diagram -> qgiManager().release(conducer);
+	diagram -> qgiManager().release(conductor);
 }
 
 /// Annule l'ajout
-void AddConducerCommand::undo() {
+void AddConductorCommand::undo() {
 	// detache le conducteur sans le detruire
-	conducer -> terminal1 -> removeConducer(conducer);
+	conductor -> terminal1 -> removeConductor(conductor);
-	conducer -> terminal2 -> removeConducer(conducer);
+	conductor -> terminal2 -> removeConductor(conductor);
-	diagram -> removeItem(conducer);
+	diagram -> removeItem(conductor);
 }
 
 /// Refait l'ajout
-void AddConducerCommand::redo() {
+void AddConductorCommand::redo() {
-	diagram -> addItem(conducer);
+	diagram -> addItem(conductor);
 }
 
 /**
 	Constructeur
 	@param dia Schema dont on supprime des elements et conducteurs
 	@param elements Elements supprimes
-	@param conducers Conducteurs supprimes
+	@param conductors Conducteurs supprimes
 	@param parent QUndoCommand parent
 */
 DeleteElementsCommand::DeleteElementsCommand(
 	Diagram *dia,
 	QSet<Element *> elements,
-	QSet<Conducer *> conducers,
+	QSet<Conductor *> conductors,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
 	removed_elements(elements),
-	removed_conducers(conducers),
+	removed_conductors(conductors),
 	diagram(dia)
 {
-	setText(QObject::tr("supprimer ") + QET::ElementsAndConducersSentence(removed_elements.count(), removed_conducers.count()));
+	setText(QObject::tr("supprimer ") + QET::ElementsAndConductorsSentence(removed_elements.count(), removed_conductors.count()));
 	foreach(QGraphicsItem *qgi, removed_elements)  diagram -> qgiManager().manage(qgi);
-	foreach(QGraphicsItem *qgi, removed_conducers) diagram -> qgiManager().manage(qgi);
+	foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().manage(qgi);
 }
 
 /// Destructeur
 DeleteElementsCommand::~DeleteElementsCommand() {
 	foreach(QGraphicsItem *qgi, removed_elements)  diagram -> qgiManager().release(qgi);
-	foreach(QGraphicsItem *qgi, removed_conducers) diagram -> qgiManager().release(qgi);
+	foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().release(qgi);
 }
 
 /// annule les suppressions
@@ -114,19 +114,19 @@ void DeleteElementsCommand::undo() {
 	}
 	
 	// remet les conducteurs
-	foreach(Conducer *c, removed_conducers) {
+	foreach(Conductor *c, removed_conductors) {
 		diagram -> addItem(c);
-		c -> terminal1 -> addConducer(c);
+		c -> terminal1 -> addConductor(c);
-		c -> terminal2 -> addConducer(c);
+		c -> terminal2 -> addConductor(c);
 	}
 }
 
 /// refait les suppressions
 void DeleteElementsCommand::redo() {
 	// enleve les conducteurs
-	foreach(Conducer *c, removed_conducers) {
+	foreach(Conductor *c, removed_conductors) {
-		c -> terminal1 -> removeConducer(c);
+		c -> terminal1 -> removeConductor(c);
-		c -> terminal2 -> removeConducer(c);
+		c -> terminal2 -> removeConductor(c);
 		diagram -> removeItem(c);
 	}
 	
@@ -146,32 +146,32 @@ void DeleteElementsCommand::redo() {
 PasteDiagramCommand::PasteDiagramCommand(
 	Diagram *dia,
 	const QList<Element *> &e,
-	const QList<Conducer *> &c,
+	const QList<Conductor *> &c,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
 	elements(e),
-	conducers(c),
+	conductors(c),
 	diagram(dia),
 	first_redo(true)
 {
-	setText(QObject::tr("coller ") + QET::ElementsAndConducersSentence(elements.count(), conducers.count()));
+	setText(QObject::tr("coller ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count()));
 	foreach(QGraphicsItem *qgi, elements)  diagram -> qgiManager().manage(qgi);
-	foreach(QGraphicsItem *qgi, conducers) diagram -> qgiManager().manage(qgi);
+	foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().manage(qgi);
 }
 
 /// Destructeur
 PasteDiagramCommand::~PasteDiagramCommand() {
 	foreach(QGraphicsItem *qgi, elements)  diagram -> qgiManager().release(qgi);
-	foreach(QGraphicsItem *qgi, conducers) diagram -> qgiManager().release(qgi);
+	foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().release(qgi);
 }
 
 /// annule le coller
 void PasteDiagramCommand::undo() {
 	// enleve les conducteurs
-	foreach(Conducer *c, conducers) {
+	foreach(Conductor *c, conductors) {
-		c -> terminal1 -> removeConducer(c);
+		c -> terminal1 -> removeConductor(c);
-		c -> terminal2 -> removeConducer(c);
+		c -> terminal2 -> removeConductor(c);
 		diagram -> removeItem(c);
 	}
 	
@@ -187,32 +187,32 @@ void PasteDiagramCommand::redo() {
 		foreach(Element *e, elements)  diagram -> addItem(e);
 		
 		// pose les conducteurs
-		foreach(Conducer *c, conducers) {
+		foreach(Conductor *c, conductors) {
 			diagram -> addItem(c);
-			c -> terminal1 -> addConducer(c);
+			c -> terminal1 -> addConductor(c);
-			c -> terminal2 -> addConducer(c);
+			c -> terminal2 -> addConductor(c);
 		}
 	}
 	foreach(Element *e, elements)   e -> setSelected(true);
-	foreach(Conducer *c, conducers) c -> setSelected(true);
+	foreach(Conductor *c, conductors) c -> setSelected(true);
 }
 
 /**
 	Constructeur
 	@param dia Schema dont on supprime des elements et conducteurs
 	@param elements Elements supprimes
-	@param conducers Conducteurs supprimes
+	@param conductors Conducteurs supprimes
 	@param parent QUndoCommand parent
 */
 CutDiagramCommand::CutDiagramCommand(
 	Diagram *dia,
 	QSet<Element *> elements,
-	QSet<Conducer *> conducers,
+	QSet<Conductor *> conductors,
 	QUndoCommand *parent
 ) : 
-	DeleteElementsCommand(dia, elements, conducers, parent)
+	DeleteElementsCommand(dia, elements, conductors, parent)
 {
-	setText(QObject::tr("couper ") + QET::ElementsAndConducersSentence(elements.count(), conducers.count()));
+	setText(QObject::tr("couper ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count()));
 }
 
 /// Destructeur
@@ -223,27 +223,27 @@ CutDiagramCommand::~CutDiagramCommand() {
 	Constructeur
 	@param dia Schema sur lequel on deplace des elements
 	@param move_elements Elements a deplacer
-	@param move_conducers Conducteurs a deplacer
+	@param move_conductors Conducteurs a deplacer
-	@param modify_conducers Conducteurs a mettre a jour
+	@param modify_conductors Conducteurs a mettre a jour
 	@param m translation subie par les elements
 	@param parent QUndoCommand parent
 */
 MoveElementsCommand::MoveElementsCommand(
 	Diagram *dia,
 	const QSet<Element *> &move_elements,
-	const QSet<Conducer *> &move_conducers,
+	const QSet<Conductor *> &move_conductors,
-	const QHash<Conducer *, Terminal *> &modify_conducers,
+	const QHash<Conductor *, Terminal *> &modify_conductors,
 	const QPointF &m,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(parent),
 	diagram(dia),
 	elements_to_move(move_elements),
-	conducers_to_move(move_conducers),
+	conductors_to_move(move_conductors),
-	conducers_to_update(modify_conducers),
+	conductors_to_update(modify_conductors),
 	movement(m)
 {
-	setText(QObject::tr("d\351placer ") + QET::ElementsAndConducersSentence(elements_to_move.count(), conducers_to_move.count()));
+	setText(QObject::tr("d\351placer ") + QET::ElementsAndConductorsSentence(elements_to_move.count(), conductors_to_move.count()));
 }
 
 /// Destructeur
@@ -272,13 +272,13 @@ void MoveElementsCommand::move(const QPointF &actual_movement) {
 	}
 	
 	// deplace certains conducteurs
-	foreach(Conducer *conducer, conducers_to_move) {
+	foreach(Conductor *conductor, conductors_to_move) {
-		conducer -> setPos(conducer -> pos() + actual_movement);
+		conductor -> setPos(conductor -> pos() + actual_movement);
 	}
 	
 	// recalcule les autres conducteurs
-	foreach(Conducer *conducer, conducers_to_update.keys()) {
+	foreach(Conductor *conductor, conductors_to_update.keys()) {
-		conducer -> updateWithNewPos(QRectF(), conducers_to_update[conducer], conducers_to_update[conducer] -> amarrageConducer());
+		conductor -> updateWithNewPos(QRectF(), conductors_to_update[conductor], conductors_to_update[conductor] -> amarrageConductor());
 	}
 }
 
@@ -328,7 +328,7 @@ void ChangeDiagramTextCommand::redo() {
 	@param parent QUndoCommand parent
 */
 RotateElementsCommand::RotateElementsCommand(const QHash<Element *, QET::Orientation> &elements, QUndoCommand *parent) :
-	QUndoCommand(QObject::tr("pivoter ") + QET::ElementsAndConducersSentence(elements.count(), 0), parent),
+	QUndoCommand(QObject::tr("pivoter ") + QET::ElementsAndConductorsSentence(elements.count(), 0), parent),
 	elements_to_rotate(elements)
 {
 }
@@ -359,14 +359,14 @@ void RotateElementsCommand::redo() {
 	@param new_p nouveau profil du conducteur
 	@param parent QUndoCommand parent
 */
-ChangeConducerCommand::ChangeConducerCommand(
+ChangeConductorCommand::ChangeConductorCommand(
-	Conducer *c,
+	Conductor *c,
-	const ConducerProfile &old_p,
+	const ConductorProfile &old_p,
-	const ConducerProfile &new_p,
+	const ConductorProfile &new_p,
 	QUndoCommand *parent
 ) :
 	QUndoCommand(QObject::tr("modifier un conducteur"), parent),
-	conducer(c),
+	conductor(c),
 	old_profile(old_p),
 	new_profile(new_p),
 	first_redo(true)
@@ -374,18 +374,18 @@ ChangeConducerCommand::ChangeConducerCommand(
 }
 
 /// Destructeur
-ChangeConducerCommand::~ChangeConducerCommand() {
+ChangeConductorCommand::~ChangeConductorCommand() {
 }
 
 /// Annule la modification du conducteur
-void ChangeConducerCommand::undo() {
+void ChangeConductorCommand::undo() {
-	conducer -> setProfile(old_profile);
+	conductor -> setProfile(old_profile);
 }
 
 /// Refait la modification du conducteur
-void ChangeConducerCommand::redo() {
+void ChangeConductorCommand::redo() {
 	if (first_redo) first_redo = false;
-	else conducer -> setProfile(new_profile);
+	else conductor -> setProfile(new_profile);
 }
 
 /**
@@ -473,45 +473,45 @@ void ChangeBorderCommand::redo() {
 	applyChanges(1);
 }
 
-ChangeConducerPropertiesCommand::ChangeConducerPropertiesCommand(Conducer *c, QUndoCommand *parent) :
+ChangeConductorPropertiesCommand::ChangeConductorPropertiesCommand(Conductor *c, QUndoCommand *parent) :
 	QUndoCommand(QObject::tr("modifier les propri\351t\351s d'un conducteur"), parent),
-	conducer(c),
+	conductor(c),
 	old_settings_set(false),
 	new_settings_set(false)
 {
 }
 
-ChangeConducerPropertiesCommand::~ChangeConducerPropertiesCommand() {
+ChangeConductorPropertiesCommand::~ChangeConductorPropertiesCommand() {
 }
 
-void ChangeConducerPropertiesCommand::setOldSettings(bool single, const QString &text, const SingleLineProperties &slp) {
+void ChangeConductorPropertiesCommand::setOldSettings(bool single, const QString &text, const SingleLineProperties &slp) {
 	old_is_single_line = single;
-	old_conducer_text = text;
+	old_conductor_text = text;
 	old_slp = slp;
 	old_settings_set = true;
 }
 
-void ChangeConducerPropertiesCommand::setNewSettings(bool single, const QString &text, const SingleLineProperties &slp) {
+void ChangeConductorPropertiesCommand::setNewSettings(bool single, const QString &text, const SingleLineProperties &slp) {
 	new_is_single_line = single;
-	new_conducer_text = text;
+	new_conductor_text = text;
 	new_slp = slp;
 	new_settings_set = true;
 }
 
-void ChangeConducerPropertiesCommand::undo() {
+void ChangeConductorPropertiesCommand::undo() {
 	if (old_settings_set && new_settings_set) {
-		conducer -> setSingleLine(old_is_single_line);
+		conductor -> setSingleLine(old_is_single_line);
-		conducer -> setText(old_conducer_text);
+		conductor -> setText(old_conductor_text);
-		conducer -> singleLineProperties = old_slp;
+		conductor -> singleLineProperties = old_slp;
-		conducer -> update();
+		conductor -> update();
 	}
 }
 
-void ChangeConducerPropertiesCommand::redo() {
+void ChangeConductorPropertiesCommand::redo() {
 	if (old_settings_set && new_settings_set) {
-		conducer -> setSingleLine(new_is_single_line);
+		conductor -> setSingleLine(new_is_single_line);
-		conducer -> setText(new_conducer_text);
+		conductor -> setText(new_conductor_text);
-		conducer -> singleLineProperties = new_slp;
+		conductor -> singleLineProperties = new_slp;
-		conducer -> update();
+		conductor -> update();
 	}
 }

diagramcommands.h

@@ -3,7 +3,7 @@
 #include "qet.h"
 #include "diagram.h"
 #include "diagramtextitem.h"
-#include "conducer.h"
+#include "conductor.h"
 #include <QtGui>
 /**
 	Cette classe represente l'action d'ajouter un element au schema
@@ -34,13 +34,13 @@ class AddElementCommand : public QUndoCommand {
 /**
 	Cette classe represente l'action d'ajouter un conducteur au schema
 */
-class AddConducerCommand : public QUndoCommand {
+class AddConductorCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	AddConducerCommand(Diagram *, Conducer *, QUndoCommand * = 0);
+	AddConductorCommand(Diagram *, Conductor *, QUndoCommand * = 0);
-	virtual ~AddConducerCommand();
+	virtual ~AddConductorCommand();
 	private:
-	AddConducerCommand(const AddConducerCommand &);
+	AddConductorCommand(const AddConductorCommand &);
 	
 	// methodes
 	public:
@@ -50,7 +50,7 @@ class AddConducerCommand : public QUndoCommand {
 	// attributs
 	private:
 	/// Conducteur ajoute
-	Conducer *conducer;
+	Conductor *conductor;
 	/// schema auquel on ajoute le conducteur
 	Diagram *diagram;
 };
@@ -62,7 +62,7 @@ class AddConducerCommand : public QUndoCommand {
 class DeleteElementsCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	DeleteElementsCommand(Diagram *, QSet<Element *>, QSet<Conducer *>, QUndoCommand * = 0);
+	DeleteElementsCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, QUndoCommand * = 0);
 	virtual ~DeleteElementsCommand();
 	private:
 	DeleteElementsCommand(const DeleteElementsCommand &);
@@ -77,7 +77,7 @@ class DeleteElementsCommand : public QUndoCommand {
 	/// Liste des elements enleves
 	QSet<Element *> removed_elements;
 	/// List des conducteurs enleves
-	QSet<Conducer *> removed_conducers;
+	QSet<Conductor *> removed_conductors;
 	/// schema dont on supprime des elements et conducteurs
 	Diagram *diagram;
 };
@@ -88,7 +88,7 @@ class DeleteElementsCommand : public QUndoCommand {
 class PasteDiagramCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	PasteDiagramCommand(Diagram *, const QList<Element *> &, const QList<Conducer *> &, QUndoCommand * = 0);
+	PasteDiagramCommand(Diagram *, const QList<Element *> &, const QList<Conductor *> &, QUndoCommand * = 0);
 	virtual ~PasteDiagramCommand();
 	private:
 	PasteDiagramCommand(const PasteDiagramCommand &);
@@ -103,7 +103,7 @@ class PasteDiagramCommand : public QUndoCommand {
 	/// Elements ajoutes
 	QList<Element *> elements;
 	/// conducteurs ajoutes
-	QList<Conducer *> conducers;
+	QList<Conductor *> conductors;
 	/// schema sur lequel on colle les elements et conducteurs
 	Diagram *diagram;
 	/// booleen pour empecher le premier appel a redo
@@ -117,7 +117,7 @@ class PasteDiagramCommand : public QUndoCommand {
 class CutDiagramCommand : public DeleteElementsCommand {
 	// constructeurs, destructeur
 	public:
-	CutDiagramCommand(Diagram *, QSet<Element *>, QSet<Conducer *>, QUndoCommand * = 0);
+	CutDiagramCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, QUndoCommand * = 0);
 	virtual ~CutDiagramCommand();
 	private:
 	CutDiagramCommand(const CutDiagramCommand &);
@@ -130,7 +130,7 @@ class CutDiagramCommand : public DeleteElementsCommand {
 class MoveElementsCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	MoveElementsCommand(Diagram *, const QSet<Element *> &, const QSet<Conducer *> &, const QHash<Conducer *, Terminal *> &, const QPointF &m, QUndoCommand * = 0);
+	MoveElementsCommand(Diagram *, const QSet<Element *> &, const QSet<Conductor *> &, const QHash<Conductor *, Terminal *> &, const QPointF &m, QUndoCommand * = 0);
 	virtual ~MoveElementsCommand();
 	private:
 	MoveElementsCommand(const MoveElementsCommand &);
@@ -148,9 +148,9 @@ class MoveElementsCommand : public QUndoCommand {
 	/// Elements a deplacer
 	QSet<Element *> elements_to_move;
 	/// Conducteurs a deplacer
-	QSet<Conducer *> conducers_to_move;
+	QSet<Conductor *> conductors_to_move;
 	/// Conducteurs a actualiser
-	QHash<Conducer *, Terminal *> conducers_to_update;
+	QHash<Conductor *, Terminal *> conductors_to_update;
 	/// mouvement effectue
 	QPointF movement;
 	/// booleen pour ne pas executer le premier redo()
@@ -210,13 +210,13 @@ class RotateElementsCommand : public QUndoCommand {
 /**
 	Cette classe represente l'action de modifier un conducteur
 */
-class ChangeConducerCommand : public QUndoCommand {
+class ChangeConductorCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	ChangeConducerCommand(Conducer *, const ConducerProfile &, const ConducerProfile &, QUndoCommand * = 0);
+	ChangeConductorCommand(Conductor *, const ConductorProfile &, const ConductorProfile &, QUndoCommand * = 0);
-	virtual ~ChangeConducerCommand();
+	virtual ~ChangeConductorCommand();
 	private:
-	ChangeConducerCommand(const ChangeConducerCommand &);
+	ChangeConductorCommand(const ChangeConductorCommand &);
 	
 	// methodes
 	public:
@@ -226,11 +226,11 @@ class ChangeConducerCommand : public QUndoCommand {
 	// attributs
 	private:
 	/// DiagramTextItem modifie
-	Conducer *conducer;
+	Conductor *conductor;
 	/// texte avant changement
-	ConducerProfile old_profile;
+	ConductorProfile old_profile;
 	/// texte apres changement
-	ConducerProfile new_profile;
+	ConductorProfile new_profile;
 	/// booleen pour ne pas executer le premier redo()
 	bool first_redo;
 };
@@ -301,13 +301,13 @@ class ChangeBorderCommand : public QUndoCommand {
 /**
 	Cette classe represente l'action de modifier les proprietes d'un conducteur
 */
-class ChangeConducerPropertiesCommand : public QUndoCommand {
+class ChangeConductorPropertiesCommand : public QUndoCommand {
 	// constructeurs, destructeur
 	public:
-	ChangeConducerPropertiesCommand(Conducer *, QUndoCommand * = 0);
+	ChangeConductorPropertiesCommand(Conductor *, QUndoCommand * = 0);
-	virtual ~ChangeConducerPropertiesCommand();
+	virtual ~ChangeConductorPropertiesCommand();
 	private:
-	ChangeConducerPropertiesCommand(const ChangeConducerPropertiesCommand &);
+	ChangeConductorPropertiesCommand(const ChangeConductorPropertiesCommand &);
 	
 	// methodes
 	public:
@@ -319,14 +319,14 @@ class ChangeConducerPropertiesCommand : public QUndoCommand {
 	// attributs
 	private:
 	/// Conducteur modifie
-	Conducer *conducer;
+	Conductor *conductor;
 	/// anciennes proprietes
 	bool old_is_single_line;
-	QString old_conducer_text;
+	QString old_conductor_text;
 	SingleLineProperties old_slp;
 	/// nouvelles proprietes
 	bool new_is_single_line;
-	QString new_conducer_text;
+	QString new_conductor_text;
 	SingleLineProperties new_slp;
 	bool old_settings_set;
 	bool new_settings_set;

diagramview.cpp

@@ -2,9 +2,9 @@
 #include "diagram.h"
 #include "customelement.h"
 #include "exportdialog.h"
-#include "conducer.h"
+#include "conductor.h"
 #include "diagramcommands.h"
-#include "conducerproperties.h"
+#include "conductorproperties.h"
 
 /**
 	Constructeur
@@ -72,22 +72,22 @@ void DiagramView::selectInvert() {
 void DiagramView::deleteSelection() {
 	
 	QSet<Element *> garbage_elmt;
-	QSet<Conducer *> garbage_conducers;
+	QSet<Conductor *> garbage_conductors;
 	
 	// 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 (Conducer * c = qgraphicsitem_cast<Conducer *>(qgi)) {
+		if (Conductor * c = qgraphicsitem_cast<Conductor *>(qgi)) {
 			// s'il s'agit d'un conducteur, on le met dans la liste des conducteurs
-			garbage_conducers << c;
+			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_conducers += e -> conducers().toSet();
+			garbage_conductors += e -> conductors().toSet();
 		}
 	}
 	scene -> clearSelection();
-	scene -> undoStack().push(new DeleteElementsCommand(scene, garbage_elmt, garbage_conducers));
+	scene -> undoStack().push(new DeleteElementsCommand(scene, garbage_elmt, garbage_conductors));
 }
 
 /**
@@ -206,22 +206,22 @@ void DiagramView::zoomReset() {
 void DiagramView::cut() {
 	copy();
 	QSet<Element *> cut_elmt;
-	QSet<Conducer *> cut_conducers;
+	QSet<Conductor *> cut_conductors;
 	
 	// 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 (Conducer * c = qgraphicsitem_cast<Conducer *>(qgi)) {
+		if (Conductor * c = qgraphicsitem_cast<Conductor *>(qgi)) {
 			// s'il s'agit d'un conducteur, on le met dans la liste des conducteurs
-			cut_conducers << c;
+			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_conducers += e -> conducers().toSet();
+			cut_conductors += e -> conductors().toSet();
 		}
 	}
 	scene -> clearSelection();
-	scene -> undoStack().push(new CutDiagramCommand(scene, cut_elmt, cut_conducers));
+	scene -> undoStack().push(new CutDiagramCommand(scene, cut_elmt, cut_conductors));
 }
 
 /**
@@ -245,13 +245,13 @@ void DiagramView::paste() {
 	
 	// listes pour recupere les elements et conducteurs ajoutes au schema par le coller
 	QList<Element *> elements_pasted;
-	QList<Conducer *> conducers_pasted;
+	QList<Conductor *> conductors_pasted;
-	scene -> fromXml(document_xml, QPointF(), false, &elements_pasted, &conducers_pasted);
+	scene -> fromXml(document_xml, QPointF(), false, &elements_pasted, &conductors_pasted);
 	
 	// si quelque chose a effectivement ete ajoute au schema, on cree
-	if (elements_pasted.count() || conducers_pasted.count()) {
+	if (elements_pasted.count() || conductors_pasted.count()) {
 		scene -> clearSelection();
-		scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conducers_pasted));
+		scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conductors_pasted));
 	}
 }
 
@@ -267,13 +267,13 @@ void DiagramView::mousePressEvent(QMouseEvent *e) {
 		
 		// listes pour recupere les elements et conducteurs ajoutes au schema par le coller
 		QList<Element *> elements_pasted;
-		QList<Conducer *> conducers_pasted;
+		QList<Conductor *> conductors_pasted;
-		scene -> fromXml(document_xml, mapToScene(e -> pos()), false, &elements_pasted, &conducers_pasted);
+		scene -> fromXml(document_xml, mapToScene(e -> pos()), false, &elements_pasted, &conductors_pasted);
 		
 		// si quelque chose a effectivement ete ajoute au schema, on cree
-		if (elements_pasted.count() || conducers_pasted.count()) {
+		if (elements_pasted.count() || conductors_pasted.count()) {
 			scene -> clearSelection();
-			scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conducers_pasted));
+			scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conductors_pasted));
 		}
 	} else {
 		QGraphicsView::mousePressEvent(e);
@@ -605,36 +605,36 @@ QRectF DiagramView::viewedSceneRect() const {
 	return(QRectF(scene_left_top, scene_right_bottom));
 }
 
-void DiagramView::editConducer() {
+void DiagramView::editConductor() {
-	QList<Conducer *> selected_conducers(scene -> selectedConducers().toList());
+	QList<Conductor *> selected_conductors(scene -> selectedConductors().toList());
 	
 	// on ne peut editer qu'un conducteur a la fois
-	if (selected_conducers.count() != 1) return;
+	if (selected_conductors.count() != 1) return;
-	Conducer *edited_conducer = selected_conducers.first();
+	Conductor *edited_conductor = selected_conductors.first();
 	
 	// initialise l'editeur de proprietes pour le conducteur
-	ConducerPropertiesWidget *cpw = new ConducerPropertiesWidget();
+	ConductorPropertiesWidget *cpw = new ConductorPropertiesWidget();
-	cpw -> setSingleLine(edited_conducer -> isSingleLine());
+	cpw -> setSingleLine(edited_conductor -> isSingleLine());
-	cpw -> setConducerText(edited_conducer -> text());
+	cpw -> setConductorText(edited_conductor -> text());
-	cpw -> setSingleLineProperties(edited_conducer -> singleLineProperties);
+	cpw -> setSingleLineProperties(edited_conductor -> singleLineProperties);
 	
 	// initialise egalement l'objet UndoCommand correspondant
-	ChangeConducerPropertiesCommand *ccpc = new ChangeConducerPropertiesCommand(edited_conducer);
+	ChangeConductorPropertiesCommand *ccpc = new ChangeConductorPropertiesCommand(edited_conductor);
-	ccpc -> setOldSettings(edited_conducer -> isSingleLine(), edited_conducer -> text(), edited_conducer -> singleLineProperties);
+	ccpc -> setOldSettings(edited_conductor -> isSingleLine(), edited_conductor -> text(), edited_conductor -> singleLineProperties);
 	
 	// l'insere dans un dialogue
-	QDialog conducer_dialog;
+	QDialog conductor_dialog;
-	conducer_dialog.setWindowTitle(tr("\311diter les propri\351t\351s d'un conducteur"));
+	conductor_dialog.setWindowTitle(tr("\311diter les propri\351t\351s d'un conducteur"));
-	QVBoxLayout *dialog_layout = new QVBoxLayout(&conducer_dialog);
+	QVBoxLayout *dialog_layout = new QVBoxLayout(&conductor_dialog);
 	dialog_layout -> addWidget(cpw);
 	QDialogButtonBox *dbb = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 	dialog_layout -> addWidget(dbb);
-	connect(dbb, SIGNAL(accepted()), &conducer_dialog, SLOT(accept()));
+	connect(dbb, SIGNAL(accepted()), &conductor_dialog, SLOT(accept()));
-	connect(dbb, SIGNAL(rejected()), &conducer_dialog, SLOT(reject()));
+	connect(dbb, SIGNAL(rejected()), &conductor_dialog, SLOT(reject()));
 	
 	// execute le dialogue et met a jour le conducteur
-	if (conducer_dialog.exec() == QDialog::Accepted) {
+	if (conductor_dialog.exec() == QDialog::Accepted) {
-		ccpc -> setNewSettings(cpw -> isSingleLine(), cpw -> conducerText(), cpw -> singleLineProperties());
+		ccpc -> setNewSettings(cpw -> isSingleLine(), cpw -> conductorText(), cpw -> singleLineProperties());
 		diagram() -> undoStack().push(ccpc);
 	} else {
 		delete ccpc;

diagramview.h

@@ -70,7 +70,7 @@ class DiagramView : public QGraphicsView {
 	void paste();
 	void adjustSceneRect();
 	void updateWindowTitle();
-	void editConducer();
+	void editConductor();
 	
 	private slots:
 	void slot_selectionChanged();

element.cpp

@@ -1,7 +1,7 @@
 #include "element.h"
 #include "qetapp.h"
 #include "diagram.h"
-#include "conducer.h"
+#include "conductor.h"
 #include "elementtextitem.h"
 #include "diagramcommands.h"
 #include <QtDebug>
@@ -121,7 +121,7 @@ bool Element::setOrientation(QET::Orientation o) {
 	ori.setCurrent(o);
 	update();
 	foreach(QGraphicsItem *qgi, children()) {
-		if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConducer();
+		if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConductor();
 		else if (ElementTextItem *eti = qgraphicsitem_cast<ElementTextItem *>(qgi)) {
 			// applique une rotation contraire si besoin
 			if (!eti -> followParentRotations())  {
@@ -251,14 +251,14 @@ void Element::moveOtherElements(const QPointF &diff) {
 	}
 	
 	// deplace certains conducteurs
-	foreach(Conducer *conducer, diagram_ptr -> conducersToMove()) {
+	foreach(Conductor *conductor, diagram_ptr -> conductorsToMove()) {
-		conducer -> setPos(conducer -> pos() + diff);
+		conductor -> setPos(conductor -> pos() + diff);
 	}
 	
 	// recalcule les autres conducteurs
-	const QHash<Conducer *, Terminal *> &conducers_modify = diagram_ptr -> conducersToUpdate();
+	const QHash<Conductor *, Terminal *> &conductors_modify = diagram_ptr -> conductorsToUpdate();
-	foreach(Conducer *conducer, conducers_modify.keys()) {
+	foreach(Conductor *conductor, conductors_modify.keys()) {
-		conducer -> updateWithNewPos(QRectF(), conducers_modify[conducer], conducers_modify[conducer] -> amarrageConducer());
+		conductor -> updateWithNewPos(QRectF(), conductors_modify[conductor], conductors_modify[conductor] -> amarrageConductor());
 	}
 }
 
@@ -270,8 +270,8 @@ void Element::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 				new MoveElementsCommand(
 					diagram_ptr,
 					diagram_ptr -> elementsToMove(),
-					diagram_ptr -> conducersToMove(),
+					diagram_ptr -> conductorsToMove(),
-					diagram_ptr -> conducersToUpdate(),
+					diagram_ptr -> conductorsToUpdate(),
 					diagram_ptr -> current_movement
 				)
 			);

element.h

@@ -36,7 +36,7 @@ class Element : public QGraphicsItem {
 	
 	// methodes virtuelles pures a definir dans les classes enfants
 	virtual QList<Terminal *> terminals() const = 0;
-	virtual QList<Conducer *> conducers() const = 0;
+	virtual QList<Conductor *> conductors() const = 0;
 	virtual int nbTerminals() const = 0;
 	virtual int nbTerminalsMin() const = 0;
 	virtual int nbTerminalsMax() const = 0;

lang/qet_en.ts

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS><TS version="1.1" language="en">
+<defaultcodec></defaultcodec>
 <context>
     <name>AboutQET</name>
     <message>
@@ -219,25 +220,63 @@ Whoops, we have no website</translation>
         <translation>diameter</translation>
     </message>
 </context>
+<context>
+    <name>ConductorPropertiesWidget</name>
+    <message>
+        <location filename="../conductorproperties.cpp" line="16"/>
+        <source>Type de conducteur</source>
+        <translation>Conductor Type</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="22"/>
+        <source>Multifilaire</source>
+        <translation>Multiline</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="25"/>
+        <source>Texte :</source>
+        <translation>Text :</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="30"/>
+        <source>Unifilaire</source>
+        <translation>SIngleline</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="33"/>
+        <source>phase</source>
+        <translation>phase</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="44"/>
+        <source>terre</source>
+        <translation>ground</translation>
+    </message>
+    <message>
+        <location filename="../conductorproperties.cpp" line="46"/>
+        <source>neutre</source>
+        <translation>neutral</translation>
+    </message>
+</context>
 <context>
     <name>DiagramView</name>
     <message>
-        <location filename="../diagramview.cpp" line="345"/>
+        <location filename="../diagramview.cpp" line="347"/>
         <source> ?</source>
         <translation> ?</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="478"/>
+        <location filename="../diagramview.cpp" line="480"/>
         <source>Auteur : </source>
         <translation>Author : </translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="464"/>
+        <location filename="../diagramview.cpp" line="466"/>
         <source>Cartouche du sch&#xe9;ma</source>
         <translation>Diagram inset</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="480"/>
+        <location filename="../diagramview.cpp" line="482"/>
         <source>Date : </source>
         <translation>Date : </translation>
     </message>
@@ -247,32 +286,32 @@ Whoops, we have no website</translation>
         <translation type="obsolete">Diagram QElectroTech (*.qet)</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="344"/>
+        <location filename="../diagramview.cpp" line="346"/>
         <source>Enregistrer le sch&#xe9;ma en cours ?</source>
         <translation>Save the current diagram ?</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="385"/>
+        <location filename="../diagramview.cpp" line="387"/>
         <source>Enregistrer sous</source>
         <translation>Save as</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="414"/>
+        <location filename="../diagramview.cpp" line="416"/>
         <source>Erreur</source>
         <translation>Error</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="482"/>
+        <location filename="../diagramview.cpp" line="484"/>
         <source>Fichier : </source>
         <translation>File : </translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="484"/>
+        <location filename="../diagramview.cpp" line="486"/>
         <source>Folio : </source>
         <translation>Folio : </translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="414"/>
+        <location filename="../diagramview.cpp" line="416"/>
         <source>Impossible d&apos;ecrire dans ce fichier</source>
         <translation>Can&apos;t write to the file</translation>
     </message>
@@ -287,25 +326,30 @@ Whoops, we have no website</translation>
         <translation type="obsolete">Diagram QElectroTech (*.qet)</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="388"/>
+        <location filename="../diagramview.cpp" line="390"/>
         <source>Sch&#xe9;ma QElectroTech (*.qet)</source>
         <translation>QElectroTech Diagram (*.qet)</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="476"/>
+        <location filename="../diagramview.cpp" line="478"/>
         <source>Titre : </source>
         <translation>Title :</translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="345"/>
+        <location filename="../diagramview.cpp" line="347"/>
         <source>Voulez-vous enregistrer le sch&#xe9;ma </source>
         <translation>Do you wish to save the diagram </translation>
     </message>
     <message>
-        <location filename="../diagramview.cpp" line="579"/>
+        <location filename="../diagramview.cpp" line="581"/>
         <source>nouveau sch&#xe9;ma</source>
         <translation>new diagram</translation>
     </message>
+    <message>
+        <location filename="../diagramview.cpp" line="627"/>
+        <source>&#xc9;diter les propri&#xe9;t&#xe9;s d&apos;un conducteur</source>
+        <translation>Edit conductor properties</translation>
+    </message>
 </context>
 <context>
     <name>ElementDeleter</name>
@@ -1383,17 +1427,17 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Render the current plan with or without antialiasing</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="773"/>
+        <location filename="../qetdiagrameditor.cpp" line="780"/>
         <source>Active la fen&#xea;tre </source>
         <translation>Activates the window </translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="265"/>
+        <location filename="../qetdiagrameditor.cpp" line="268"/>
         <source>Active la fen&#xea;tre pr&#xe9;c&#xe9;dente</source>
         <translation>Activates the previous window</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="264"/>
+        <location filename="../qetdiagrameditor.cpp" line="267"/>
         <source>Active la fen&#xea;tre suivante</source>
         <translation>Activates the next window</translation>
     </message>
@@ -1403,87 +1447,87 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Render with &amp;Antialiasing</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="251"/>
+        <location filename="../qetdiagrameditor.cpp" line="254"/>
         <source>Adapte la taille du sch&#xe9;ma afin qu&apos;il soit enti&#xe8;rement visible</source>
         <translation>Changes the size of the plan so that it fits in the view</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="325"/>
+        <location filename="../qetdiagrameditor.cpp" line="329"/>
         <source>Afficha&amp;ge</source>
         <translation>Displ&amp;ay</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="268"/>
+        <location filename="../qetdiagrameditor.cpp" line="271"/>
         <source>Affiche des informations sur la biblioth&#xe8;que Qt</source>
         <translation>Displays informations about Qt library</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="267"/>
+        <location filename="../qetdiagrameditor.cpp" line="270"/>
         <source>Affiche des informations sur QElectroTech</source>
         <translation>Displays informations about QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="379"/>
+        <location filename="../qetdiagrameditor.cpp" line="385"/>
         <source>Affiche ou non la barre d&apos;outils</source>
         <translation>Displays or not the toolbar</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="381"/>
+        <location filename="../qetdiagrameditor.cpp" line="387"/>
         <source>Affiche ou non le panel d&apos;appareils</source>
         <translation>Displays or not the elements panel</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="258"/>
+        <location filename="../qetdiagrameditor.cpp" line="261"/>
         <source>Affiche QElectroTech en mode fen&#xea;tr&#xe9;</source>
         <translation>Displays QElectroTech in windowed mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="257"/>
+        <location filename="../qetdiagrameditor.cpp" line="260"/>
         <source>Affiche QElectroTech en mode plein &#xe9;cran</source>
         <translation>Displays QELectroTech in full screen mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="376"/>
+        <location filename="../qetdiagrameditor.cpp" line="382"/>
         <source>Afficher</source>
         <translation>Display</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="166"/>
+        <location filename="../qetdiagrameditor.cpp" line="168"/>
         <source>Agrandir le sch&#xe9;ma</source>
         <translation>Expand the diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="249"/>
+        <location filename="../qetdiagrameditor.cpp" line="252"/>
         <source>Agrandit le sch&#xe9;ma</source>
         <translation>Expand the diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="246"/>
+        <location filename="../qetdiagrameditor.cpp" line="249"/>
         <source>Agrandit le sch&#xe9;ma en hauteur</source>
         <translation>Expand the diagram&apos;s height</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="329"/>
+        <location filename="../qetdiagrameditor.cpp" line="333"/>
         <source>&amp;Aide</source>
         <translation>&amp;Help</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="164"/>
+        <location filename="../qetdiagrameditor.cpp" line="166"/>
         <source>Ajouter une colonne</source>
         <translation>Add a column</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="244"/>
+        <location filename="../qetdiagrameditor.cpp" line="247"/>
         <source>Ajoute une colonne au sch&#xe9;ma</source>
         <translation>Add a column to the diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="263"/>
+        <location filename="../qetdiagrameditor.cpp" line="266"/>
         <source>Aligne les fen&#xea;tres r&#xe9;duites</source>
         <translation>Arranges all iconized windows at the bottom of the workspace</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="233"/>
+        <location filename="../qetdiagrameditor.cpp" line="235"/>
         <source>Annule l&apos;action pr&#xe9;c&#xe9;dente</source>
         <translation>Undoes the previous action</translation>
     </message>
@@ -1493,17 +1537,17 @@ Please check rights of the directory </translation>
         <translation type="obsolete">&amp;Undo</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="187"/>
+        <location filename="../qetdiagrameditor.cpp" line="189"/>
         <source>&#xc0; &amp;propos de QElectroTech</source>
         <translation>A&amp;bout QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="188"/>
+        <location filename="../qetdiagrameditor.cpp" line="190"/>
         <source>&#xc0; propos de &amp;Qt</source>
         <translation>About &amp;Qt</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="183"/>
+        <location filename="../qetdiagrameditor.cpp" line="185"/>
         <source>Arranger les fen&#xea;tres r&#xe9;duites</source>
         <translation>Arranges iconized windows</translation>
     </message>
@@ -1513,27 +1557,27 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Hide Too&amp;lbar</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="182"/>
+        <location filename="../qetdiagrameditor.cpp" line="184"/>
         <source>&amp;Cascade</source>
         <translation>&amp;Cascade</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="517"/>
+        <location filename="../qetdiagrameditor.cpp" line="523"/>
         <source>Ce fichier n&apos;est pas un document XML valide.</source>
         <translation>This file is not a valid XML Document.</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="515"/>
+        <location filename="../qetdiagrameditor.cpp" line="521"/>
         <source>Ce fichier n&apos;existe pas.</source>
         <translation>This file does not exist.</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="157"/>
+        <location filename="../qetdiagrameditor.cpp" line="158"/>
         <source>C&amp;oller</source>
         <translation>&amp;Paste</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="327"/>
+        <location filename="../qetdiagrameditor.cpp" line="331"/>
         <source>&amp;Configuration</source>
         <translation>&amp;Settings</translation>
     </message>
@@ -1543,77 +1587,77 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Configure tool&amp;bars</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="179"/>
+        <location filename="../qetdiagrameditor.cpp" line="181"/>
         <source>&amp;Configurer QElectroTech</source>
         <translation>&amp;Configure QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="236"/>
+        <location filename="../qetdiagrameditor.cpp" line="238"/>
         <source>Copie les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s dans le presse-papier</source>
         <translation>Copies selected elements</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="156"/>
+        <location filename="../qetdiagrameditor.cpp" line="157"/>
         <source>Cop&amp;ier</source>
         <translation>&amp;Copy</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="155"/>
+        <location filename="../qetdiagrameditor.cpp" line="156"/>
         <source>Co&amp;uper</source>
         <translation>Cu&amp;t</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="223"/>
+        <location filename="../qetdiagrameditor.cpp" line="225"/>
         <source>Cr&#xe9;e un nouveau sch&#xe9;ma</source>
         <translation>Opens a new diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="214"/>
+        <location filename="../qetdiagrameditor.cpp" line="216"/>
         <source>Ctrl+0</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="213"/>
+        <location filename="../qetdiagrameditor.cpp" line="215"/>
         <source>Ctrl+9</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="207"/>
+        <location filename="../qetdiagrameditor.cpp" line="209"/>
         <source>Ctrl+I</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="198"/>
+        <location filename="../qetdiagrameditor.cpp" line="200"/>
         <source>Ctrl+Q</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="209"/>
+        <location filename="../qetdiagrameditor.cpp" line="211"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="206"/>
+        <location filename="../qetdiagrameditor.cpp" line="208"/>
         <source>Ctrl+Shift+A</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="217"/>
+        <location filename="../qetdiagrameditor.cpp" line="219"/>
         <source>Ctrl+Shift+F</source>
         <translation>Ctrl+Shift+F</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="195"/>
+        <location filename="../qetdiagrameditor.cpp" line="197"/>
         <source>Ctrl+Shift+I</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="196"/>
+        <location filename="../qetdiagrameditor.cpp" line="198"/>
         <source>Ctrl+Shift+X</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="208"/>
+        <location filename="../qetdiagrameditor.cpp" line="210"/>
         <source>Ctrl+Suppr</source>
         <translation>Ctrl+Suppr</translation>
     </message>
@@ -1623,17 +1667,17 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Render without &amp;Antialiasing</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="240"/>
+        <location filename="../qetdiagrameditor.cpp" line="242"/>
         <source>D&#xe9;s&#xe9;lectionne les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s et s&#xe9;lectionne les &#xe9;l&#xe9;ments non s&#xe9;lectionn&#xe9;s</source>
         <translation>Deselects selected elements and select non-selected elements</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="159"/>
+        <location filename="../qetdiagrameditor.cpp" line="160"/>
         <source>D&#xe9;s&#xe9;lectionner tout</source>
         <translation>Select none</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="239"/>
+        <location filename="../qetdiagrameditor.cpp" line="241"/>
         <source>D&#xe9;s&#xe9;lectionne tous les &#xe9;l&#xe9;ments du sch&#xe9;ma</source>
         <translation>Deselect all elements on the plan</translation>
     </message>
@@ -1643,52 +1687,52 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Diagram QelectroTech (*.qet);;XML Files(*.xml);;All files (*)</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="262"/>
+        <location filename="../qetdiagrameditor.cpp" line="265"/>
         <source>Dispose les fen&#xea;tres en cascade</source>
         <translation>Arranges windows in a cascade pattern</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="261"/>
+        <location filename="../qetdiagrameditor.cpp" line="264"/>
         <source>Dispose les fen&#xea;tres en mosa&#xef;que</source>
         <translation>Arranges windows in a tile pattern</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="243"/>
+        <location filename="../qetdiagrameditor.cpp" line="246"/>
         <source>&#xc9;dite les informations affich&#xe9;es par le cartouche</source>
         <translation>Edit informations displayed by the inset</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="324"/>
+        <location filename="../qetdiagrameditor.cpp" line="328"/>
         <source>&amp;&#xc9;dition</source>
         <translation>&amp;Edit</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="241"/>
+        <location filename="../qetdiagrameditor.cpp" line="243"/>
         <source>Enl&#xe8;ve les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s du sch&#xe9;ma</source>
         <translation>Removes selected elements from the plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="165"/>
+        <location filename="../qetdiagrameditor.cpp" line="167"/>
         <source>Enlever une colonne</source>
         <translation>Remove a column</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="245"/>
+        <location filename="../qetdiagrameditor.cpp" line="248"/>
         <source>Enl&#xe8;ve une colonne au sch&#xe9;ma</source>
         <translation>Remove a column from the diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="226"/>
+        <location filename="../qetdiagrameditor.cpp" line="228"/>
         <source>Enregistre le sch&#xe9;ma courant</source>
         <translation>Saves the current plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="227"/>
+        <location filename="../qetdiagrameditor.cpp" line="229"/>
         <source>Enregistre le sch&#xe9;ma courant avec un autre nom de fichier</source>
         <translation>Saves the current plan as another filename</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="144"/>
+        <location filename="../qetdiagrameditor.cpp" line="145"/>
         <source>&amp;Enregistrer</source>
         <translation>&amp;Save</translation>
     </message>
@@ -1698,22 +1742,22 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Save the current schema ?</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="145"/>
+        <location filename="../qetdiagrameditor.cpp" line="146"/>
         <source>Enregistrer sous</source>
         <translation>Save as</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="520"/>
+        <location filename="../qetdiagrameditor.cpp" line="526"/>
         <source>Erreur</source>
         <translation>Error</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="229"/>
+        <location filename="../qetdiagrameditor.cpp" line="231"/>
         <source>Exporte le sch&#xe9;ma courant dans un autre format</source>
         <translation>Exports the curent plan to another format</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="147"/>
+        <location filename="../qetdiagrameditor.cpp" line="148"/>
         <source>E&amp;xporter</source>
         <translation>&amp;Export</translation>
     </message>
@@ -1723,37 +1767,37 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Export to file</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="185"/>
+        <location filename="../qetdiagrameditor.cpp" line="187"/>
         <source>Fen&#xea;tre pr&#xe9;c&#xe9;dente</source>
         <translation>Previous Window</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="328"/>
+        <location filename="../qetdiagrameditor.cpp" line="332"/>
         <source>Fe&amp;n&#xea;tres</source>
         <translation>Wi&amp;ndows</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="184"/>
+        <location filename="../qetdiagrameditor.cpp" line="186"/>
         <source>Fen&#xea;tre suivante</source>
         <translation>Next Window</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="231"/>
+        <location filename="../qetdiagrameditor.cpp" line="233"/>
         <source>Ferme l&apos;application QElectroTech</source>
         <translation>Closes QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="225"/>
+        <location filename="../qetdiagrameditor.cpp" line="227"/>
         <source>Ferme le sch&#xe9;ma courant</source>
         <translation>Closes the current plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="143"/>
+        <location filename="../qetdiagrameditor.cpp" line="144"/>
         <source>&amp;Fermer</source>
         <translation>&amp;Close</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="323"/>
+        <location filename="../qetdiagrameditor.cpp" line="327"/>
         <source>&amp;Fichier</source>
         <translation>&amp;File</translation>
     </message>
@@ -1763,12 +1807,12 @@ Please check rights of the directory </translation>
         <translation type="obsolete">PNG Picture (*.png)</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="146"/>
+        <location filename="../qetdiagrameditor.cpp" line="147"/>
         <source>&amp;Importer</source>
         <translation>&amp;Import</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="228"/>
+        <location filename="../qetdiagrameditor.cpp" line="230"/>
         <source>Importe un sch&#xe9;ma dans le sch&#xe9;ma courant</source>
         <translation>Imports a plan into the current plan</translation>
     </message>
@@ -1783,27 +1827,27 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Can&apos;t read that file</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="516"/>
+        <location filename="../qetdiagrameditor.cpp" line="522"/>
         <source>Impossible de lire ce fichier.</source>
         <translation>Could not read file.</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="230"/>
+        <location filename="../qetdiagrameditor.cpp" line="232"/>
         <source>Imprime le sch&#xe9;ma courant</source>
         <translation>Prints the current plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="148"/>
+        <location filename="../qetdiagrameditor.cpp" line="149"/>
         <source>Imprimer</source>
         <translation>Print</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="163"/>
+        <location filename="../qetdiagrameditor.cpp" line="165"/>
         <source>Informations sur le sch&#xe9;ma</source>
         <translation>Diagram informations</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="160"/>
+        <location filename="../qetdiagrameditor.cpp" line="161"/>
         <source>Inverser la s&#xe9;lection</source>
         <translation>Invert selection</translation>
     </message>
@@ -1818,47 +1862,47 @@ Please check rights of the directory </translation>
         <translation type="obsolete">&amp;Fullscreen Mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="174"/>
+        <location filename="../qetdiagrameditor.cpp" line="176"/>
         <source>Mode Selection</source>
         <translation>Selection Mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="175"/>
+        <location filename="../qetdiagrameditor.cpp" line="177"/>
         <source>Mode Visualisation</source>
         <translation>View Mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="181"/>
+        <location filename="../qetdiagrameditor.cpp" line="183"/>
         <source>&amp;Mosa&#xef;que</source>
         <translation>&amp;Tile</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="141"/>
+        <location filename="../qetdiagrameditor.cpp" line="142"/>
         <source>&amp;Nouveau</source>
         <translation>&amp;New</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="326"/>
+        <location filename="../qetdiagrameditor.cpp" line="330"/>
         <source>O&amp;utils</source>
         <translation>&amp;Tools</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="411"/>
+        <location filename="../qetdiagrameditor.cpp" line="417"/>
         <source>Outils</source>
         <translation>Tools</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="224"/>
+        <location filename="../qetdiagrameditor.cpp" line="226"/>
         <source>Ouvre un sch&#xe9;ma existant</source>
         <translation>Open an existing diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="142"/>
+        <location filename="../qetdiagrameditor.cpp" line="143"/>
         <source>&amp;Ouvrir</source>
         <translation>&amp;Open</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="490"/>
+        <location filename="../qetdiagrameditor.cpp" line="496"/>
         <source>Ouvrir un fichier</source>
         <translation>Open a file</translation>
     </message>
@@ -1868,47 +1912,47 @@ Please check rights of the directory </translation>
         <translation type="obsolete">P</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="55"/>
+        <location filename="../qetdiagrameditor.cpp" line="56"/>
         <source>Panel d&apos;appareils</source>
         <translation>Elements Panel</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="172"/>
+        <location filename="../qetdiagrameditor.cpp" line="174"/>
         <source>Pas de zoom</source>
         <translation>Reset zoom</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="177"/>
+        <location filename="../qetdiagrameditor.cpp" line="179"/>
         <source>Passer en &amp;mode plein &#xe9;cran</source>
-        <translation>F&amp;ullScreen Screen Mode</translation>
+        <translation>F&amp;ullScreen Mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="259"/>
+        <location filename="../qetdiagrameditor.cpp" line="262"/>
         <source>Permet de r&#xe9;gler diff&#xe9;rents param&#xe8;tres de QElectroTech</source>
         <translation>Allows to specify various parameters for QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="254"/>
+        <location filename="../qetdiagrameditor.cpp" line="257"/>
         <source>Permet de s&#xe9;lectionner les &#xe9;l&#xe9;ments</source>
         <translation>Allows to select elements</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="255"/>
+        <location filename="../qetdiagrameditor.cpp" line="258"/>
         <source>Permet de visualiser le sch&#xe9;ma sans pouvoir le modifier</source>
         <translation>Allows to view the plan without modifying it</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="242"/>
+        <location filename="../qetdiagrameditor.cpp" line="244"/>
         <source>Pivote les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s</source>
         <translation>Rotates selected elements</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="162"/>
+        <location filename="../qetdiagrameditor.cpp" line="163"/>
         <source>Pivoter</source>
         <translation>Rotate</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="237"/>
+        <location filename="../qetdiagrameditor.cpp" line="239"/>
         <source>Place les &#xe9;l&#xe9;ments du presse-papier sur le sch&#xe9;ma</source>
         <translation>Pastes elements from the clipboard into the plan</translation>
     </message>
@@ -1918,7 +1962,7 @@ Please check rights of the directory </translation>
         <translation type="obsolete">QElectrotech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="52"/>
+        <location filename="../qetdiagrameditor.cpp" line="53"/>
         <source>QElectroTech</source>
         <translation>QElectroTech</translation>
     </message>
@@ -1928,7 +1972,7 @@ Please check rights of the directory </translation>
         <translation type="obsolete">QElectrotech : Size of the drawing area  :</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="149"/>
+        <location filename="../qetdiagrameditor.cpp" line="150"/>
         <source>&amp;Quitter</source>
         <translation>&amp;Quit</translation>
     </message>
@@ -1943,12 +1987,12 @@ Please check rights of the directory </translation>
         <translation type="obsolete">&amp;Redo</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="234"/>
+        <location filename="../qetdiagrameditor.cpp" line="236"/>
         <source>Restaure l&apos;action annul&#xe9;e</source>
         <translation>Restores the undone action</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="252"/>
+        <location filename="../qetdiagrameditor.cpp" line="255"/>
         <source>Restaure le zoom par d&#xe9;faut</source>
         <translation>Restores default zoom level</translation>
     </message>
@@ -1963,17 +2007,17 @@ Please check rights of the directory </translation>
         <translation type="obsolete">Restore QElectroTech</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="167"/>
+        <location filename="../qetdiagrameditor.cpp" line="169"/>
         <source>R&#xe9;tr&#xe9;cir le sch&#xe9;ma</source>
         <translation>Shrink the diagram</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="250"/>
+        <location filename="../qetdiagrameditor.cpp" line="253"/>
         <source>R&#xe9;tr&#xe9;cit le sch&#xe9;ma</source>
         <translation>Shrinks the plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="247"/>
+        <location filename="../qetdiagrameditor.cpp" line="250"/>
         <source>R&#xe9;tr&#xe9;cit le sch&#xe9;ma en hauteur</source>
         <translation>Shrink the diagram&apos;s height</translation>
     </message>
@@ -1998,37 +2042,37 @@ Please check rights of the directory </translation>
         <translation type="obsolete">QElectroTech Diagram (*.qet);;XML Files (*.xml);;All files (*)</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="493"/>
+        <location filename="../qetdiagrameditor.cpp" line="499"/>
         <source>Sch&#xe9;mas QElectroTech (*.qet);;Fichiers XML (*.xml);;Tous les fichiers (*)</source>
         <translation>QElectroTech Diagrams (*.qet);;XML Files (*.xml);;All files (*)</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="238"/>
+        <location filename="../qetdiagrameditor.cpp" line="240"/>
         <source>S&#xe9;lectionne tous les &#xe9;l&#xe9;ments du sch&#xe9;ma</source>
         <translation>Selects all elements on the plan</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="178"/>
+        <location filename="../qetdiagrameditor.cpp" line="180"/>
         <source>Sortir du &amp;mode plein &#xe9;cran</source>
         <translation>Exit F&amp;ullScreen Screen Mode</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="161"/>
+        <location filename="../qetdiagrameditor.cpp" line="162"/>
         <source>Supprimer</source>
         <translation>Delete</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="158"/>
+        <location filename="../qetdiagrameditor.cpp" line="159"/>
         <source>Tout s&#xe9;lectionner</source>
         <translation>Select All</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="235"/>
+        <location filename="../qetdiagrameditor.cpp" line="237"/>
         <source>Transf&#xe8;re les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s dans le presse-papier</source>
         <translation>Puts selected elements into the clipboard</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="518"/>
+        <location filename="../qetdiagrameditor.cpp" line="524"/>
         <source>Une erreur s&apos;est produite lors de l&apos;ouverture du fichier.</source>
         <translation>An error occured while opening the file.</translation>
     </message>
@@ -2043,30 +2087,40 @@ Please check rights of the directory </translation>
         <translation type="obsolete">x</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="171"/>
+        <location filename="../qetdiagrameditor.cpp" line="173"/>
         <source>Zoom adapt&#xe9;</source>
         <translation>Fit in view</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="170"/>
+        <location filename="../qetdiagrameditor.cpp" line="172"/>
         <source>Zoom arri&#xe8;re</source>
         <translation>Zoom Out</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="169"/>
+        <location filename="../qetdiagrameditor.cpp" line="171"/>
         <source>Zoom avant</source>
         <translation>Zoom In</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="151"/>
+        <location filename="../qetdiagrameditor.cpp" line="152"/>
         <source>Annuler</source>
         <translation>Undo</translation>
     </message>
     <message>
-        <location filename="../qetdiagrameditor.cpp" line="153"/>
+        <location filename="../qetdiagrameditor.cpp" line="154"/>
         <source>Refaire</source>
         <translation>Redo</translation>
     </message>
+    <message>
+        <location filename="../qetdiagrameditor.cpp" line="164"/>
+        <source>Propri&#xe9;t&#xe9;s du conducteur</source>
+        <translation>Conductor properties</translation>
+    </message>
+    <message>
+        <location filename="../qetdiagrameditor.cpp" line="245"/>
+        <source>&#xc9;dite les propri&#xe9;t&#xe9;s du conducteur s&#xe9;lectionn&#xe9;</source>
+        <translation>Edit the selected conductor properties</translation>
+    </message>
 </context>
 <context>
     <name>QETElementEditor</name>
@@ -2441,7 +2495,7 @@ Please check rights of the directory </translation>
     <message>
         <location filename="../diagramcommands.cpp" line="55"/>
         <source>ajouter un conducteur</source>
-        <translation>add a conducer</translation>
+        <translation>add a conductor</translation>
     </message>
     <message>
         <location filename="../diagramcommands.cpp" line="98"/>
@@ -2476,7 +2530,7 @@ Please check rights of the directory </translation>
     <message>
         <location filename="../diagramcommands.cpp" line="368"/>
         <source>modifier un conducteur</source>
-        <translation>modify a conducer</translation>
+        <translation>modify a conductor</translation>
     </message>
     <message>
         <location filename="../diagramcommands.cpp" line="404"/>
@@ -2521,18 +2575,23 @@ Please check rights of the directory </translation>
     <message>
         <location filename="../qet.cpp" line="142"/>
         <source>conducteurs</source>
-        <translation>conducers</translation>
+        <translation>conductors</translation>
     </message>
     <message>
         <location filename="../qet.cpp" line="142"/>
         <source>conducteur</source>
-        <translation>conducer</translation>
+        <translation>conductor</translation>
     </message>
     <message>
         <location filename="../terminal.cpp" line="44"/>
         <source>Borne</source>
         <translation>Terminal</translation>
     </message>
+    <message>
+        <location filename="../diagramcommands.cpp" line="477"/>
+        <source>modifier les propri&#xe9;t&#xe9;s d&apos;un conducteur</source>
+        <translation>modify conductor properties</translation>
+    </message>
 </context>
 <context>
     <name>Schema</name>

qelectrotech.pro

@@ -10,10 +10,10 @@ INCLUDEPATH += . editor
 # Input
 HEADERS += aboutqet.h \
            borderinset.h \
-           conducer.h \
+           conductor.h \
-           conducerprofile.h \
+           conductorprofile.h \
-           conducersegment.h \
+           conductorsegment.h \
-           conducersegmentprofile.h \
+           conductorsegmentprofile.h \
            customelement.h \
            diagram.h \
            diagramview.h \
@@ -67,12 +67,12 @@ HEADERS += aboutqet.h \
  diagramcommands.h \
  diagramtextitem.h \
  insetproperties.h \
- conducerproperties.h
+ conductorproperties.h
 SOURCES += aboutqet.cpp \
            borderinset.cpp \
-           conducer.cpp \
+           conductor.cpp \
-           conducerprofile.cpp \
+           conductorprofile.cpp \
-           conducersegment.cpp \
+           conductorsegment.cpp \
            customelement.cpp \
            diagram.cpp \
            diagramview.cpp \
@@ -126,7 +126,7 @@ SOURCES += aboutqet.cpp \
            editor/textfieldeditor.cpp \
            diagramcommands.cpp \
  diagramtextitem.cpp \
- conducerproperties.cpp
+ conductorproperties.cpp
 RESOURCES += qelectrotech.qrc
 TRANSLATIONS += lang/qet_en.ts lang/qt_fr.ts
 RC_FILE = ico/windows_icon/application_icon/qelectrotech.rc

qet.cpp

@@ -127,19 +127,19 @@ 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 <20>lements
-	@param conducers_count nombre de conducteurs
+	@param conductors_count nombre de conducteurs
 	@return la proposition decrivant le nombre d'elements et de conducteurs
 */
-QString QET::ElementsAndConducersSentence(int elements_count, int conducers_count) {
+QString QET::ElementsAndConductorsSentence(int elements_count, int conductors_count) {
 	QString text;
 	if (elements_count) {
 		text += QString::number(elements_count) + " ";
 		text += elements_count > 1 ? QObject::tr("\351l\351ments") : QObject::tr("\351l\351ment");
-		if (conducers_count) text += QObject::tr(" et ");
+		if (conductors_count) text += QObject::tr(" et ");
 	}
-	if (conducers_count) {
+	if (conductors_count) {
-		text += QString::number(conducers_count) + " ";
+		text += QString::number(conductors_count) + " ";
-		text += conducers_count > 1 ? QObject::tr("conducteurs") : QObject::tr("conducteur");
+		text += conductors_count > 1 ? QObject::tr("conducteurs") : QObject::tr("conducteur");
 	}
 	return(text);
 }

qet.h

@@ -8,7 +8,7 @@
 */
 namespace QET {
 	enum Orientation {North, East, South, West};
-	enum ConducerSegmentType { Horizontal = 1, Vertical = 2, Both = 3 };
+	enum ConductorSegmentType { Horizontal = 1, Vertical = 2, Both = 3 };
 	QET::Orientation nextOrientation(QET::Orientation);
 	QET::Orientation previousOrientation(QET::Orientation);
 	QET::Orientation orientationFromString(const QString &);
@@ -18,6 +18,6 @@ namespace QET {
 	bool estVerticale(QET::Orientation);
 	bool attributeIsAnInteger(const QDomElement &, QString , int * = NULL);
 	bool attributeIsAReal(const QDomElement &, QString , double * = NULL);
-	QString ElementsAndConducersSentence(int, int);
+	QString ElementsAndConductorsSentence(int, int);
 }
 #endif

qetdiagrameditor.cpp

@@ -4,7 +4,7 @@
 #include "diagram.h"
 #include "elementspanelwidget.h"
 #include "aboutqet.h"
-#include "conducerproperties.h"
+#include "conductorproperties.h"
 
 /**
 	constructeur
@@ -161,7 +161,7 @@ void QETDiagramEditor::actions() {
 	select_invert     = new QAction(                               tr("Inverser la s\351lection"),             this);
 	delete_selection  = new QAction(QIcon(":/ico/delete.png"),     tr("Supprimer"),                            this);
 	rotate_selection  = new QAction(QIcon(":/ico/pivoter.png"),    tr("Pivoter"),                              this);
-	conducer_prop     = new QAction(QIcon(":/ico/conductor.png"),  tr("Propri\351t\351s du conducteur"),       this);
+	conductor_prop     = new QAction(QIcon(":/ico/conductor.png"),  tr("Propri\351t\351s du conducteur"),       this);
 	infos_diagram     = new QAction(QIcon(":/ico/info.png"),       tr("Informations sur le sch\351ma"),        this);
 	add_column        = new QAction(QIcon(":/ico/add_col.png"),    tr("Ajouter une colonne"),                  this);
 	remove_column     = new QAction(QIcon(":/ico/remove_col.png"), tr("Enlever une colonne"),                  this);
@@ -242,7 +242,7 @@ void QETDiagramEditor::actions() {
 	select_invert     -> setStatusTip(tr("D\351s\351lectionne les \351l\351ments s\351lectionn\351s et s\351lectionne les \351l\351ments non s\351lectionn\351s"));
 	delete_selection  -> setStatusTip(tr("Enl\350ve les \351l\351ments s\351lectionn\351s du sch\351ma"));
 	rotate_selection  -> setStatusTip(tr("Pivote les \351l\351ments s\351lectionn\351s"));
-	conducer_prop     -> setStatusTip(tr("\311dite les propri\351t\351s du conducteur s\351lectionn\351"));
+	conductor_prop     -> setStatusTip(tr("\311dite les propri\351t\351s du conducteur s\351lectionn\351"));
 	infos_diagram     -> setStatusTip(tr("\311dite les informations affich\351es par le cartouche"));
 	add_column        -> setStatusTip(tr("Ajoute une colonne au sch\351ma"));
 	remove_column     -> setStatusTip(tr("Enl\350ve une colonne au sch\351ma"));
@@ -312,7 +312,7 @@ void QETDiagramEditor::actions() {
 	connect(arrange_window,   SIGNAL(triggered()), &workspace, SLOT(arrangeIcons())             );
 	connect(next_window,      SIGNAL(triggered()), &workspace, SLOT(activateNextWindow())       );
 	connect(prev_window,      SIGNAL(triggered()), &workspace, SLOT(activatePreviousWindow())   );
-	connect(conducer_prop,    SIGNAL(triggered()), this,       SLOT(slot_editConducer())        );
+	connect(conductor_prop,    SIGNAL(triggered()), this,       SLOT(slot_editConductor())        );
 	connect(infos_diagram,    SIGNAL(triggered()), this,       SLOT(slot_editInfos())           );
 	connect(add_column,       SIGNAL(triggered()), this,       SLOT(slot_addColumn())           );
 	connect(remove_column,    SIGNAL(triggered()), this,       SLOT(slot_removeColumn())        );
@@ -370,7 +370,7 @@ void QETDiagramEditor::menus() {
 	menu_edition -> addAction(delete_selection);
 	menu_edition -> addAction(rotate_selection);
 	menu_edition -> addSeparator();
-	menu_edition -> addAction(conducer_prop);
+	menu_edition -> addAction(conductor_prop);
 	menu_edition -> addSeparator();
 	menu_edition -> addAction(infos_diagram);
 	menu_edition -> addAction(add_column);
@@ -666,7 +666,7 @@ void QETDiagramEditor::slot_updateActions() {
 	zoom_out         -> setEnabled(opened_document);
 	zoom_fit         -> setEnabled(opened_document);
 	zoom_reset       -> setEnabled(opened_document);
-	conducer_prop    -> setEnabled(opened_document && sv -> diagram() -> selectedConducers().count() == 1);
+	conductor_prop    -> setEnabled(opened_document && sv -> diagram() -> selectedConductors().count() == 1);
 	infos_diagram    -> setEnabled(opened_document);
 	add_column       -> setEnabled(opened_document);
 	remove_column    -> setEnabled(opened_document);
@@ -830,8 +830,8 @@ void QETDiagramEditor::slot_shrink() {
 	sv -> shrink();
 }
 
-void QETDiagramEditor::slot_editConducer() {
+void QETDiagramEditor::slot_editConductor() {
 	if (DiagramView *dv = currentDiagram()) {
-		dv -> editConducer();
+		dv -> editConductor();
 	}
 }

qetdiagrameditor.h

@@ -65,7 +65,7 @@ class QETDiagramEditor : public QMainWindow {
 	void slot_removeColumn();
 	void slot_expand();
 	void slot_shrink();
-	void slot_editConducer();
+	void slot_editConductor();
 	
 	// attributs
 	protected:
@@ -91,7 +91,7 @@ class QETDiagramEditor : public QMainWindow {
 	QAction *select_invert;
 	QAction *delete_selection;
 	QAction *rotate_selection;
-	QAction *conducer_prop;
+	QAction *conductor_prop;
 	QAction *infos_diagram;
 	QAction *add_column;
 	QAction *remove_column;

terminal.cpp

@@ -1,7 +1,7 @@
 #include "terminal.h"
 #include "diagram.h"
 #include "element.h"
-#include "conducer.h"
+#include "conductor.h"
 #include "diagramcommands.h"
 
 QColor Terminal::couleur_neutre   = QColor(Qt::blue);
@@ -16,14 +16,14 @@ QColor Terminal::couleur_interdit = QColor(Qt::red);
 */
 void Terminal::initialise(QPointF pf, QET::Orientation o) {
 	// definition du pount d'amarrage pour un conducteur
-	amarrage_conducer  = pf;
+	amarrage_conductor  = pf;
 	
 	// definition de l'orientation de la terminal (par defaut : sud)
 	if (o < QET::North || o > QET::West) sens = QET::South;
 	else sens = o;
 	
 	// calcul de la position du point d'amarrage a l'element
-	amarrage_elmt = amarrage_conducer;
+	amarrage_elmt = amarrage_conductor;
 	switch(sens) {
 		case QET::North: amarrage_elmt += QPointF(0, TAILLE_BORNE);  break;
 		case QET::East : amarrage_elmt += QPointF(-TAILLE_BORNE, 0); break;
@@ -90,7 +90,7 @@ Terminal::Terminal(qreal pf_x, qreal pf_y, QET::Orientation o, Element *e, Diagr
 */
 Terminal::~Terminal() {
 	//qDebug() << "Terminal::~Terminal" << (void *)this;
-	foreach(Conducer *c, liste_conducers) delete c;
+	foreach(Conductor *c, liste_conductors) delete c;
 	delete br;
 }
 
@@ -118,30 +118,30 @@ QET::Orientation Terminal::orientation() const {
 }
 
 /**
-	Attribue un conducer a la borne
+	Attribue un conductor a la borne
 	@param f Le conducteur a rattacher a cette borne
 */
-bool Terminal::addConducer(Conducer *f) {
+bool Terminal::addConductor(Conductor *f) {
 	// pointeur 0 refuse
 	if (!f) return(false);
 	
 	// une seule des deux bornes du conducteur doit etre this
-	Q_ASSERT_X((f -> terminal1 == this ^ f -> terminal2 == this), "Terminal::addConducer", "Le conducer devrait etre relie exactement une fois a la terminal en cours");
+	Q_ASSERT_X((f -> terminal1 == this ^ f -> terminal2 == this), "Terminal::addConductor", "Le conductor devrait etre relie exactement une fois a la terminal en cours");
 	
 	// determine l'autre borne a laquelle cette borne va etre relie grace au conducteur
 	Terminal *autre_terminal = (f -> terminal1 == this) ? f -> terminal2 : f -> terminal1;
 	
 	// verifie que la borne n'est pas deja reliee avec l'autre borne
 	bool deja_liees = false;
-	foreach (Conducer* conducer, liste_conducers) {
+	foreach (Conductor* conductor, liste_conductors) {
-		if (conducer -> terminal1 == autre_terminal || conducer -> terminal2 == autre_terminal) deja_liees = true;
+		if (conductor -> terminal1 == autre_terminal || conductor -> terminal2 == autre_terminal) deja_liees = true;
 	}
 	
 	// si les deux bornes sont deja reliees, on refuse d'ajouter le conducteur
 	if (deja_liees) return(false);
 	
 	// sinon on ajoute le conducteur
-	liste_conducers.append(f);
+	liste_conductors.append(f);
 	return(true);
 }
 
@@ -149,11 +149,11 @@ bool Terminal::addConducer(Conducer *f) {
 	Enleve un conducteur donne a la borne
 	@param f Conducteur a enlever
 */
-void Terminal::removeConducer(Conducer *f) {
+void Terminal::removeConductor(Conductor *f) {
-	//qDebug() << "Terminal::removeConducer" << (void *)this;
+	//qDebug() << "Terminal::removeConductor" << (void *)this;
-	int index = liste_conducers.indexOf(f);
+	int index = liste_conductors.indexOf(f);
 	if (index == -1) return;
-	liste_conducers.removeAt(index);
+	liste_conductors.removeAt(index);
 }
 
 /**
@@ -171,7 +171,7 @@ void Terminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *) {
 	p -> setRenderHint(QPainter::SmoothPixmapTransform, false);
 	
 	// on travaille avec les coordonnees de l'element parent
-	QPointF f = mapFromParent(amarrage_conducer);
+	QPointF f = mapFromParent(amarrage_conductor);
 	QPointF e = mapFromParent(amarrage_elmt);
 	
 	QPen t;
@@ -199,12 +199,12 @@ void Terminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *) {
 */
 QRectF Terminal::boundingRect() const {
 	if (br -> isNull()) {
-		qreal afx = amarrage_conducer.x();
+		qreal afx = amarrage_conductor.x();
-		qreal afy = amarrage_conducer.y();
+		qreal afy = amarrage_conductor.y();
 		qreal aex = amarrage_elmt.x();
 		qreal aey = amarrage_elmt.y();
 		QPointF origine;
-		origine = (afx <= aex && afy <= aey ? amarrage_conducer : amarrage_elmt);
+		origine = (afx <= aex && afy <= aey ? amarrage_conductor : amarrage_elmt);
 		origine += QPointF(-3.0, -3.0);
 		qreal w = qAbs((int)(afx - aex)) + 7;
 		qreal h = qAbs((int)(afy - aey)) + 7;
@@ -241,9 +241,9 @@ void Terminal::hoverLeaveEvent(QGraphicsSceneHoverEvent *) {
 */
 void Terminal::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	if (Diagram *s = diagram()) {
-		s -> setConducerStart(mapToScene(QPointF(amarrage_conducer)));
+		s -> setConductorStart(mapToScene(QPointF(amarrage_conductor)));
-		s -> setConducerStop(e -> scenePos());
+		s -> setConductorStop(e -> scenePos());
-		s -> setConducer(true);
+		s -> setConductor(true);
 		//setCursor(Qt::CrossCursor);
 	}
 }
@@ -268,13 +268,13 @@ void Terminal::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	Diagram *s = diagram();
 	if (!s) return;
 	// si la scene est un Diagram, on actualise le poseur de conducteur
-	s -> setConducerStop(e -> scenePos());
+	s -> setConductorStop(e -> scenePos());
 	
 	// on recupere la liste des qgi sous le pointeur
 	QList<QGraphicsItem *> qgis = s -> items(e -> scenePos());
 	
 	/* le qgi le plus haut
-	   = le poseur de conducer
+	   = le poseur de conductor
 	   = le premier element de la liste
 	   = la liste ne peut etre vide
 	   = on prend le deuxieme element de la liste
@@ -296,11 +296,11 @@ void Terminal::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 				if (((Element *)parentItem()) -> connexionsInternesAcceptees())
 					p -> couleur_hovered = p -> couleur_autorise;
 				else p -> couleur_hovered = p -> couleur_interdit;
-			} else if (p -> nbConducers()) {
+			} else if (p -> nbConductors()) {
 				// si la borne a deja un conducteur
 				// verifie que cette borne n'est pas deja reliee a l'autre borne
 				bool deja_reliee = false;
-				foreach (Conducer *f, liste_conducers) {
+				foreach (Conductor *f, liste_conductors) {
 					if (f -> terminal1 == p || f -> terminal2 == p) {
 						deja_reliee = true;
 						break;
@@ -330,7 +330,7 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	// verifie que la scene est bien un Diagram
 	if (Diagram *s = diagram()) {
 		// on arrete de dessiner l'apercu du conducteur
-		s -> setConducer(false);
+		s -> setConductor(false);
 		// on recupere l'element sous le pointeur lors du MouseReleaseEvent
 		QGraphicsItem *qgi = s -> itemAt(e -> scenePos());
 		// s'il n'y a rien, on arrete la
@@ -346,9 +346,9 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 		bool cia = ((Element *)parentItem()) -> connexionsInternesAcceptees();
 		if (!cia) foreach(QGraphicsItem *item, parentItem() -> children()) if (item == p) return;
 		// derniere verification : verifier que cette borne n'est pas deja reliee a l'autre borne
-		foreach (Conducer *f, liste_conducers) if (f -> terminal1 == p || f -> terminal2 == p) return;
+		foreach (Conductor *f, liste_conductors) if (f -> terminal1 == p || f -> terminal2 == p) return;
 		// autrement, on pose un conducteur
-		s -> undoStack().push(new AddConducerCommand(s, new Conducer(this, p)));
+		s -> undoStack().push(new AddConductorCommand(s, new Conductor(this, p)));
 	}
 }
 
@@ -356,16 +356,16 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	Met a jour l'eventuel conducteur relie a la Terminal.
 	@param newpos Position de l'element parent a prendre en compte
 */
-void Terminal::updateConducer(QPointF newpos) {
+void Terminal::updateConductor(QPointF newpos) {
 	if (!scene() || !parentItem()) return;
-	foreach (Conducer *conducer, liste_conducers) {
+	foreach (Conductor *conductor, liste_conductors) {
-		if (conducer -> isDestroyed()) continue;
+		if (conductor -> isDestroyed()) continue;
-		if (newpos == QPointF()) conducer -> update(QRectF());
+		if (newpos == QPointF()) conductor -> update(QRectF());
 		else {
 			// determine la translation subie par l'element parent
 			QPointF translation = newpos - parentItem() -> pos();
 			// rafraichit le conducteur en tenant compte de la translation
-			conducer -> updateWithNewPos(QRectF(), this, amarrageConducer() + translation);
+			conductor -> updateWithNewPos(QRectF(), this, amarrageConductor() + translation);
 		}
 	}
 }
@@ -373,8 +373,8 @@ void Terminal::updateConducer(QPointF newpos) {
 /**
 	@return La liste des conducteurs lies a cette borne
 */
-QList<Conducer *> Terminal::conducers() const {
+QList<Conductor *> Terminal::conductors() const {
-	return(liste_conducers);
+	return(liste_conductors);
 }
 
 /**

terminal.h

@@ -4,7 +4,7 @@
 #include <QtGui>
 #include <QtXml>
 #include "qet.h"
-class Conducer;
+class Conductor;
 class Diagram;
 class Element;
 /**
@@ -33,16 +33,16 @@ class Terminal : public QGraphicsItem {
 	QRectF boundingRect() const;
 	
 	// methodes de manipulation des conducteurs lies a cette borne
-	bool addConducer(Conducer *);
+	bool addConductor(Conductor *);
-	void removeConducer(Conducer *);
+	void removeConductor(Conductor *);
-	int nbConducers() const;
+	int nbConductors() const;
 	Diagram *diagram() const;
 	
 	// methodes de lecture
-	QList<Conducer *> conducers() const;
+	QList<Conductor *> conductors() const;
 	QET::Orientation orientation() const;
-	QPointF amarrageConducer() const;
+	QPointF amarrageConductor() const;
-	void updateConducer(QPointF = QPointF());
+	void updateConductor(QPointF = QPointF());
 	
 	// methodes relatives a l'import/export au format XML
 	static bool valideXml(QDomElement  &);
@@ -70,12 +70,12 @@ class Terminal : public QGraphicsItem {
 	
 	private:
 	// coordonnees des points d'amarrage
-	QPointF amarrage_conducer;
+	QPointF amarrage_conductor;
 	QPointF amarrage_elmt;
 	// orientation de la borne
 	QET::Orientation sens;
-	// liste des conducers lies a cette borne
+	// liste des conductors lies a cette borne
-	QList<Conducer *> liste_conducers;
+	QList<Conductor *> liste_conductors;
 	// pointeur vers un rectangle correspondant au bounding rect ; permet de ne calculer le bounding rect qu'une seule fois ; le pointeur c'est parce que le compilo exige une methode const
 	QRectF *br;
 	Terminal *terminal_precedente;
@@ -89,15 +89,15 @@ class Terminal : public QGraphicsItem {
 /**
 	@return Le nombre de conducteurs associes a la borne
 */
-inline int Terminal::nbConducers() const {
+inline int Terminal::nbConductors() const {
-	return(liste_conducers.size());
+	return(liste_conductors.size());
 }
 
 /**
 	@return La position du point d'amarrage de la borne
 */
-inline QPointF Terminal::amarrageConducer() const {
+inline QPointF Terminal::amarrageConductor() const {
-	return(mapToScene(amarrage_conducer));
+	return(mapToScene(amarrage_conductor));
 }
 
 #endif