Nettoyage

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

aboutqet.cpp

@@ -30,6 +30,12 @@ AboutQET::AboutQET(QWidget *parent) : QDialog(parent) {
 	setLayout(disposition);
 }
 
+/**
+	Destructeur
+*/
+AboutQET::~AboutQET() {
+}
+
 /**
 	@return Le titre QElectroTech avec son icone
 */
@@ -58,7 +64,7 @@ QWidget *AboutQET::ongletAPropos() const {
 	QLabel *apropos = new QLabel(
 		tr("QElectroTech, une application de r\351alisation de sch\351mas \351lectriques.") +
 		"<br><br>" +
-		tr("\251 2006 Les d\351veloppeurs de QElectroTech") +
+		tr("\251 2006-2007 Les d\351veloppeurs de QElectroTech") +
 		"<br><br>"
 		"<a href=\"http://qelectrotech.tuxfamily.org/\">"
 		"http://qelectrotech.tuxfamily.org/</a>"

aboutqet.h

@@ -1,18 +1,26 @@
 #ifndef ABOUTQET_H
-	#define ABOUTQET_H
+#define ABOUTQET_H
-	#include <QtGui>
+#include <QtGui>
-	/**
+/**
-		Cette classe represente la boite de dialogue
+	Cette classe represente la boite de dialogue
-		« A propos de QElectroTech »
+	« A propos de QElectroTech »
-	*/
+*/
-	class AboutQET : public QDialog {
+class AboutQET : public QDialog {
-		Q_OBJECT
+	Q_OBJECT
-		public:
+	
-		AboutQET(QWidget * = 0);
+	// constructeurs, destructeur
-		private:
+	public:
-		QWidget *titre() const;
+	AboutQET(QWidget * = 0);
-		QWidget *ongletAPropos() const;
+	virtual ~AboutQET();
-		QWidget *ongletAuteurs() const;
+	
-		QWidget *ongletLicence() const;
+	private:
-	};
+	AboutQET(AboutQET &);
+	
+	// methodes
+	private:
+	QWidget *titre() const;
+	QWidget *ongletAPropos() const;
+	QWidget *ongletAuteurs() const;
+	QWidget *ongletLicence() const;
+};
 #endif

borderinset.h

@@ -1,98 +1,108 @@
 #ifndef BORDERINSET_H
-	#define BORDERINSET_H
+#define BORDERINSET_H
-	#include <QObject>
+#include <QObject>
-	#include <QRectF>
+#include <QRectF>
-	#include <QPainter>
+#include <QPainter>
-	#include <QDate>
+#include <QDate>
-	/**
+/**
-		Cette classe represente l'ensemble bordure + cartouche qui encadre le
+	Cette classe represente l'ensemble bordure + cartouche qui encadre le
-		schema electrique.
+	schema electrique.
-	*/
+*/
-	class BorderInset : public QObject {
+class BorderInset : public QObject {
-		Q_OBJECT
+	Q_OBJECT
-		public:
+	
-		BorderInset(QObject * = 0);
+	// constructeurs, destructeur
-		~BorderInset();
+	public:
-		void draw(QPainter *, qreal = 0.0, qreal = 0.0);
+	BorderInset(QObject * = 0);
-		
+	virtual ~BorderInset();
-		// methodes d'acces en lecture aux dimensions
+	
-		int     nbColumn()            const { return(nb_columns);                    }
+	private:
-		qreal   columnsWidth()        const { return(columns_width);                 }
+	BorderInset(const BorderInset &);
-		qreal   columnsHeaderHeight() const { return(columns_header_height);         }
+	
-		qreal   columnsHeight()       const { return(columns_height);                }
+	// methodes
-		qreal   borderWidth()         const { return(nb_columns * columns_width);    }
+	public:
-		qreal   borderHeight()        const { return(columns_height + inset_height); }
+	void draw(QPainter *, qreal = 0.0, qreal = 0.0);
-		qreal   insetWidth()          const { return(inset_width);                   }
+	
-		qreal   insetHeight()         const { return(inset_height);                  }
+	// methodes d'acces en lecture aux dimensions
-		qreal   minColumnsHeight()    const { return(min_columns_height);            }
+	int     nbColumn()            const { return(nb_columns);                    }
-		int     minNbColumns()        const { return(min_nb_columns);                }
+	qreal   columnsWidth()        const { return(columns_width);                 }
-		
+	qreal   columnsHeaderHeight() const { return(columns_header_height);         }
-		// methodes d'acces en lecture aux informations du cartouche
+	qreal   columnsHeight()       const { return(columns_height);                }
-		QString author()              const { return(bi_author);             }
+	qreal   borderWidth()         const { return(nb_columns * columns_width);    }
-		QDate   date()                const { return(bi_date);               }
+	qreal   borderHeight()        const { return(columns_height + inset_height); }
-		QString title()               const { return(bi_title);              }
+	qreal   insetWidth()          const { return(inset_width);                   }
-		QString folio()               const { return(bi_folio);              }
+	qreal   insetHeight()         const { return(inset_height);                  }
-		QString fileName()            const { return(bi_filename);           }
+	qreal   minColumnsHeight()    const { return(min_columns_height);            }
-		
+	int     minNbColumns()        const { return(min_nb_columns);                }
-		// methodes d'acces en lecture aux options
+	
-		bool    insetIsDisplayed()    const { return(display_inset);         }
+	// methodes d'acces en lecture aux informations du cartouche
-		bool    columnsAreDisplayed() const { return(display_columns);       }
+	QString author()              const { return(bi_author);             }
-		bool    borderIsDisplayed()   const { return(display_border);        }
+	QDate   date()                const { return(bi_date);               }
-		
+	QString title()               const { return(bi_title);              }
-		// methodes d'acces en ecriture aux dimensions
+	QString folio()               const { return(bi_folio);              }
-		void addColumn             ();
+	QString fileName()            const { return(bi_filename);           }
-		void removeColumn          ();
+	
-		void setNbColumns          (int);
+	// methodes d'acces en lecture aux options
-		void setColumnsWidth       (const qreal &);
+	bool    insetIsDisplayed()    const { return(display_inset);         }
-		void setColumnsHeaderHeight(const qreal &);
+	bool    columnsAreDisplayed() const { return(display_columns);       }
-		void setColumnsHeight      (const qreal &);
+	bool    borderIsDisplayed()   const { return(display_border);        }
-		void setInsetWidth         (const qreal &);
+	
-		void setInsetHeight        (const qreal &);
+	// methodes d'acces en ecriture aux dimensions
-		
+	void addColumn             ();
-		// methodes d'acces en ecriture aux informations du cartouche
+	void removeColumn          ();
-		void setAuthor             (const QString &author)   { bi_author       = author;   }
+	void setNbColumns          (int);
-		void setDate               (const QDate   &date)     { bi_date         = date;     }
+	void setColumnsWidth       (const qreal &);
-		void setTitle              (const QString &title)    { bi_title        = title;    }
+	void setColumnsHeaderHeight(const qreal &);
-		void setFolio              (const QString &folio)    { bi_folio        = folio;    }
+	void setColumnsHeight      (const qreal &);
-		void setFileName           (const QString &filename) { bi_filename     = filename; }
+	void setInsetWidth         (const qreal &);
-		
+	void setInsetHeight        (const qreal &);
-		// methodes d'acces en ecriture aux options
+	
-		void displayInset          (bool di)                 { display_inset   = di;       }
+	// methodes d'acces en ecriture aux informations du cartouche
-		void displayColumns        (bool dc)                 { display_columns = dc;       }
+	void setAuthor             (const QString &author)   { bi_author       = author;   }
-		void displayBorder         (bool db)                 { display_border  = db;       }
+	void setDate               (const QDate   &date)     { bi_date         = date;     }
-		
+	void setTitle              (const QString &title)    { bi_title        = title;    }
-		private:
+	void setFolio              (const QString &folio)    { bi_folio        = folio;    }
-		// informations du cartouche
+	void setFileName           (const QString &filename) { bi_filename     = filename; }
-		QString bi_author;
+	
-		QDate   bi_date;
+	// methodes d'acces en ecriture aux options
-		QString bi_title;
+	void displayInset          (bool di)                 { display_inset   = di;       }
-		QString bi_folio;       // vraiment necessaire ce truc ?
+	void displayColumns        (bool dc)                 { display_columns = dc;       }
-		QString bi_filename;    // meme remarque
+	void displayBorder         (bool db)                 { display_border  = db;       }
-		
+	
-		// dimensions du cadre et du cartouche
+	private:
-		int    nb_columns;
+	void updateRectangles();
-		int    min_nb_columns;
+	
-		qreal  columns_width;
+	// attributs
-		qreal  columns_header_height;
+	private:
-		qreal  columns_height;
+	// informations du cartouche
-		qreal  min_columns_height;
+	QString bi_author;
-		qreal  inset_width;
+	QDate   bi_date;
-		qreal  inset_height;
+	QString bi_title;
-		
+	QString bi_folio;       // vraiment necessaire ce truc ?
-		// rectangles utilises pour le dessin
+	QString bi_filename;    // meme remarque
-		QRectF  border;
+	
-		QRectF  inset;
+	// dimensions du cadre et du cartouche
-		QRectF  inset_author;
+	int    nb_columns;
-		QRectF  inset_date;
+	int    min_nb_columns;
-		QRectF  inset_title;
+	qreal  columns_width;
-		QRectF  inset_file;
+	qreal  columns_header_height;
-		QRectF  inset_folio;
+	qreal  columns_height;
-		
+	qreal  min_columns_height;
-		// booleens pour les options de dessin
+	qreal  inset_width;
-		bool display_inset;
+	qreal  inset_height;
-		bool display_columns;
+	
-		bool display_border;
+	// rectangles utilises pour le dessin
-		
+	QRectF  border;
-		void updateRectangles();
+	QRectF  inset;
-	};
+	QRectF  inset_author;
+	QRectF  inset_date;
+	QRectF  inset_title;
+	QRectF  inset_file;
+	QRectF  inset_folio;
+	
+	// booleens pour les options de dessin
+	bool display_inset;
+	bool display_columns;
+	bool display_border;
+};
 #endif

conducer.cpp

@@ -51,6 +51,21 @@ Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *
 	calculateTextItemPosition();
 }
 
+/**
+	Destructeur
+	Detruit le conducteur ainsi que ses segments. Il ne detruit pas les bornes
+	mais s'en detache
+*/
+Conducer::~Conducer() {
+// 	qDebug() << "~Conducer()" << (void *)this;
+	// se detache des bornes
+	if (!isDestroyed()) destroy();
+	
+	// supprime les segments
+	while (segments -> hasNextSegment()) delete segments -> nextSegment();
+	delete segments;
+}
+
 /**
 	Met a jour la representation graphique du conducteur.
 	@param rect Rectangle a mettre a jour
@@ -632,7 +647,7 @@ qreal Conducer::conducer_bound(qreal tobound, qreal bound, bool positive) {
 /**
 	@return Le nombre de segments composant le conducteur.
 */
-int Conducer::nbSegments() {
+int Conducer::nbSegments() const {
 	if (segments == NULL) return(0);
 	int nb_seg = 1;
 	ConducerSegment *segment = segments;
@@ -701,7 +716,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) {
+bool Conducer::hasClickedOn(QPointF press_point, QPointF point) const {
 	return (
 		press_point.x() >= point.x() - 5.0 &&\
 		press_point.x() <  point.x() + 5.0 &&\

conducer.h

@@ -1,79 +1,88 @@
 #ifndef CONDUCTEUR_H
-	#define CONDUCTEUR_H
+#define CONDUCTEUR_H
-	#include <QtGui>
+#include <QtGui>
-	#include "terminal.h"
+#include "terminal.h"
-	class ConducerSegment;
+class ConducerSegment;
-	class Element;
+class Element;
-	/**
+/**
-		Cette classe represente un conducteur. Un conducteur relie deux bornes d'element.
+	Cette classe represente un conducteur. Un conducteur relie deux bornes d'element.
-	*/
+*/
-	class Conducer : public QGraphicsPathItem {
+class Conducer : public QGraphicsPathItem {
-		public:
+	
-		enum { Type = UserType + 1001 };
+	// constructeurs, destructeur
-    	virtual int type() const { return Type; }
+	public:
-		Conducer(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0);
+	Conducer(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0);
-		//virtual ~Conducer();
+	virtual ~Conducer();
-		
+	
-		void destroy();
+	private:
-		bool isDestroyed() const { return(destroyed); }
+	Conducer(const Conducer &);
-		void updateWithNewPos(const QRectF &, const Terminal *, const QPointF &);
+	
-		void update(const QRectF & = QRectF());
+	// attributs
-		void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
+	public:
-		QRectF boundingRect() const;
+	enum { Type = UserType + 1001 };
-		virtual QPainterPath shape() const;
+	///Premiere borne a laquelle le fil est rattache
-		qreal length();
+	Terminal *terminal1;
-		ConducerSegment *middleSegment();
+	///Deuxieme borne a laquelle le fil est rattache
-		static bool valideXml(QDomElement &);
+	Terminal *terminal2;
-		bool fromXml(QDomElement &);
+	
-		QDomElement toXml(QDomDocument &, QHash<Terminal *, int> &) const;
+	private:
-		
+	/// booleen indiquant si le fil est encore valide
-		///Premiere borne a laquelle le fil est rattache
+	bool destroyed;
-		Terminal *terminal1;
+	QGraphicsTextItem *text_item;
-		///Deuxieme borne a laquelle le fil est rattache
+	ConducerSegment *segments;
-		Terminal *terminal2;
+	QList<qreal> moves_x;
-		
+	QList<qreal> moves_y;
-		protected:
+	qreal orig_dist_2_terms_x;
-		void mousePressEvent(QGraphicsSceneMouseEvent *);
+	qreal orig_dist_2_terms_y;
-		void mouseMoveEvent(QGraphicsSceneMouseEvent *);
+	bool type_trajet_x;
-		void mouseReleaseEvent(QGraphicsSceneMouseEvent *);
+	QPointF press_point;
-		void hoverMoveEvent(QGraphicsSceneHoverEvent *);
+	bool moving_point;
-		
+	bool moving_segment;
-		private:
+	int moved_point;
-		/// booleen indiquant si le fil est encore valide
+	qreal previous_z_value;
-		bool destroyed;
+	ConducerSegment *moved_segment;
-		QGraphicsTextItem *text_item;
+	bool modified_path;
-		ConducerSegment *segments;
+	static QPen conducer_pen;
-		QList<qreal> moves_x;
+	static QBrush conducer_brush;
-		QList<qreal> moves_y;
+	static bool pen_and_brush_initialized;
-		qreal orig_dist_2_terms_x;
+	
-		qreal orig_dist_2_terms_y;
+	// methodes
-		bool type_trajet_x;
+	public:
-		QPointF press_point;
+	virtual int type() const { return Type; }
-		bool moving_point;
+	void destroy();
-		bool moving_segment;
+	bool isDestroyed() const { return(destroyed); }
-		int moved_point;
+	void updateWithNewPos(const QRectF &, const Terminal *, const QPointF &);
-		qreal previous_z_value;
+	void update(const QRectF & = QRectF());
-		ConducerSegment *moved_segment;
+	void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
-		bool modified_path;
+	QRectF boundingRect() const;
-		static QPen conducer_pen;
+	virtual QPainterPath shape() const;
-		static QBrush conducer_brush;
+	qreal length();
-		static bool pen_and_brush_initialized;
+	ConducerSegment *middleSegment();
-		
+	static bool valideXml(QDomElement &);
-		void segmentsToPath();
+	bool fromXml(QDomElement &);
-		void updatePoints();
+	QDomElement toXml(QDomDocument &, QHash<Terminal *, int> &) const;
-		void priv_calculeConducer(const QPointF &, Terminal::Orientation, const QPointF &, Terminal::Orientation);
+	
-		void priv_modifieConducer(const QPointF &, Terminal::Orientation, const QPointF &, Terminal::Orientation);
+	protected:
-		int nbSegments();
+	void mousePressEvent(QGraphicsSceneMouseEvent *);
-		
+	void mouseMoveEvent(QGraphicsSceneMouseEvent *);
-		QList<QPointF> segmentsToPoints() const;
+	void mouseReleaseEvent(QGraphicsSceneMouseEvent *);
-		void pointsToSegments(QList<QPointF>);
+	void hoverMoveEvent(QGraphicsSceneHoverEvent *);
-		bool hasClickedOn(QPointF, QPointF);
+	
-		void calculateTextItemPosition();
+	private:
-		static QPointF extendTerminal(const QPointF &, Terminal::Orientation, qreal = 12.0);
+	void segmentsToPath();
-		static bool surLeMemeAxe(Terminal::Orientation, Terminal::Orientation);
+	void updatePoints();
-		static bool estHorizontale(Terminal::Orientation a);
+	void priv_calculeConducer(const QPointF &, Terminal::Orientation, const QPointF &, Terminal::Orientation);
-		static bool estVerticale(Terminal::Orientation a);
+	void priv_modifieConducer(const QPointF &, Terminal::Orientation, const QPointF &, Terminal::Orientation);
-		static qreal conducer_bound(qreal tobound, qreal bound1, qreal bound2);
+	int nbSegments() const;
-		static qreal conducer_bound(qreal tobound, qreal bound, bool positive);
+	QList<QPointF> segmentsToPoints() const;
-	};
+	void pointsToSegments(QList<QPointF>);
+	bool hasClickedOn(QPointF, QPointF) const;
+	void calculateTextItemPosition();
+	static QPointF extendTerminal(const QPointF &, Terminal::Orientation, qreal = 12.0);
+	static bool surLeMemeAxe(Terminal::Orientation, Terminal::Orientation);
+	static bool estHorizontale(Terminal::Orientation a);
+	static bool estVerticale(Terminal::Orientation a);
+	static qreal conducer_bound(qreal tobound, qreal bound1, qreal bound2);
+	static qreal conducer_bound(qreal tobound, qreal bound, bool positive);
+};
 #endif

conducersegment.cpp

@@ -8,9 +8,15 @@
 	@param cs1 Le segment precedent
 	@param cs2 Le segment suivant
 */
-ConducerSegment::ConducerSegment(QPointF p1, QPointF p2, ConducerSegment *cs1, ConducerSegment *cs2) {
+ConducerSegment::ConducerSegment(
-	setFirstPoint(p1);
+	const QPointF &p1,
-	setSecondPoint(p2);
+	const QPointF &p2,
+	ConducerSegment *cs1,
+	ConducerSegment *cs2
+) :
+point1(p1),
+point2(p2)
+{
 	setPreviousSegment(cs1);
 	setNextSegment(cs2);
 }
@@ -19,6 +25,7 @@ ConducerSegment::ConducerSegment(QPointF p1, QPointF p2, ConducerSegment *cs1, C
 	Destructeur - Relie le segment precedent au suivant
 */
 ConducerSegment::~ConducerSegment() {
+	//qDebug() << "~ConducerSegment()" << (void *)this;
 	if (hasPreviousSegment()) previousSegment() -> setNextSegment(nextSegment());
 	if (hasNextSegment()) nextSegment() -> setPreviousSegment(previousSegment());
 }
@@ -32,7 +39,7 @@ 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(qreal asked_dx, qreal &possible_dx) {
+bool ConducerSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx) const {
 	
 	Q_ASSERT_X(isVertical(), "ConducerSegment::canMove1stPointX", "segment non vertical");
 	
@@ -91,7 +98,7 @@ bool ConducerSegment::canMove1stPointX(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(qreal asked_dx, qreal &possible_dx) {
+bool ConducerSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx) const {
 	
 	Q_ASSERT_X(isVertical(), "ConducerSegment::canMove2ndPointX", "segment non vertical");
 	
@@ -150,7 +157,7 @@ bool ConducerSegment::canMove2ndPointX(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(qreal asked_dy, qreal &possible_dy) {
+bool ConducerSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy) const {
 	
 	Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove1stPointY", "segment non horizontal");
 	
@@ -209,7 +216,7 @@ bool ConducerSegment::canMove1stPointY(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(qreal asked_dy, qreal &possible_dy) {
+bool ConducerSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy) const {
 	
 	Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove2ndPointY", "segment non horizontal");
 	
@@ -264,7 +271,7 @@ bool ConducerSegment::canMove2ndPointY(qreal asked_dy, qreal &possible_dy) {
 	Gere les mouvements sur l'axe horizontal
 	@param dx taille du deplacement en pixels
 */
-void ConducerSegment::moveX(qreal dx) {
+void ConducerSegment::moveX(const qreal &dx) {
 	if (isHorizontal()) return;
 	Q_ASSERT_X(isVertical(), "ConducerSegment::moveX", "segment non vertical");
 	
@@ -312,7 +319,7 @@ void ConducerSegment::moveX(qreal dx) {
 	Gere les mouvements sur l'axe vertical
 	@param dx taille du deplacement en pixels
 */
-void ConducerSegment::moveY(qreal dy) {
+void ConducerSegment::moveY(const qreal &dy) {
 	if (isVertical()) return;
 	Q_ASSERT_X(isHorizontal(), "ConducerSegment::moveY", "segment non horizontal");
 	
@@ -449,42 +456,42 @@ void ConducerSegment::setNextSegment(ConducerSegment *ns) {
 /**
 	@return Le segment precedent
 */
-ConducerSegment *ConducerSegment::previousSegment() {
+ConducerSegment *ConducerSegment::previousSegment()  const {
 	return(previous_segment);
 }
 
 /**
 	@return Le segment suivant
 */
-ConducerSegment *ConducerSegment::nextSegment() {
+ConducerSegment *ConducerSegment::nextSegment()  const {
 	return(next_segment);
 }
 
 /**
 	@return true si le segment est vertical, false sinon
 */
-bool ConducerSegment::isVertical() {
+bool ConducerSegment::isVertical() const {
 	return(point1.x() == point2.x());
 }
 
 /**
 	@return true si le segment est horizontal, false sinon
 */
-bool ConducerSegment::isHorizontal() {
+bool ConducerSegment::isHorizontal() const {
 	return(point1.y() == point2.y());
 }
 
 /**
 	@return le premier point du segment
 */
-QPointF ConducerSegment::firstPoint() {
+QPointF ConducerSegment::firstPoint() const {
 	return(point1);
 }
 
 /**
 	@return le second point du segment
 */
-QPointF ConducerSegment::secondPoint() {
+QPointF ConducerSegment::secondPoint() const {
 	return(point2);
 }
 
@@ -492,7 +499,7 @@ QPointF ConducerSegment::secondPoint() {
 	Permet de changer la position du premier point du segment
 	@param p La nouvelle position du premier point
 */
-void ConducerSegment::setFirstPoint(QPointF p) {
+void ConducerSegment::setFirstPoint(const QPointF &p) {
 	point1 = p;
 }
 
@@ -500,28 +507,28 @@ void ConducerSegment::setFirstPoint(QPointF p) {
 	Permet de changer la position du second point du segment
 	@param p La nouvelle position du second point
 */
-void ConducerSegment::setSecondPoint(QPointF p) {
+void ConducerSegment::setSecondPoint(const QPointF &p) {
 	point2 = p;
 }
 
 /**
 	@return true si le segment a un segment precedent, false sinon
 */
-bool ConducerSegment::hasPreviousSegment() {
+bool ConducerSegment::hasPreviousSegment() const {
 	return(previous_segment != NULL);
 }
 
 /**
 	@return true si le segment a un segment suivant, false sinon
 */
-bool ConducerSegment::hasNextSegment() {
+bool ConducerSegment::hasNextSegment() const {
 	return(next_segment != NULL);
 }
 
 /**
 	@return Le centre du rectangle delimitant le conducteur
 */
-QPointF ConducerSegment::middle() {
+QPointF ConducerSegment::middle() const {
 	return(
 		QPointF(
 			(point1.x() + point2.x()) / 2.0,
@@ -533,7 +540,7 @@ QPointF ConducerSegment::middle() {
 /**
 	@return La longueur du conducteur
 */
-qreal ConducerSegment::length() {
+qreal ConducerSegment::length() const {
 	if (isHorizontal()) {
 		return(secondPoint().x() - firstPoint().x());
 	} else {

conducersegment.h

@@ -1,43 +1,47 @@
 #ifndef CONDUCER_SEGMENT_H
-	#define CONDUCER_SEGMENT_H
+#define CONDUCER_SEGMENT_H
-	#include <QPointF>
+#include <QPointF>
-	/**
+/**
-		Cette classe represente un segment de conducteur.
+	Cette classe represente un segment de conducteur.
-	*/
+*/
-	class ConducerSegment {
+class ConducerSegment {
-		// constructeurs et destructeur
+	
-		public:
+	// constructeurs, destructeur
-		ConducerSegment(QPointF, QPointF, ConducerSegment * = NULL, ConducerSegment * = NULL);
+	public:
-		~ConducerSegment();
+	ConducerSegment(const QPointF &, const QPointF &, ConducerSegment * = NULL, ConducerSegment * = NULL);
-		
+	virtual ~ConducerSegment();
-		// attributs
+	
-		private:
+	private:
-		ConducerSegment *previous_segment;
+	ConducerSegment(const ConducerSegment &);
-		ConducerSegment *next_segment;
+	
-		QPointF point1;
+	// attributs
-		QPointF point2;
+	private:
-		
+	ConducerSegment *previous_segment;
-		// methodes
+	ConducerSegment *next_segment;
-		public:
+	QPointF point1;
-		void moveX(qreal);
+	QPointF point2;
-		void moveY(qreal);
+	
-		ConducerSegment *previousSegment();
+	// methodes
-		ConducerSegment *nextSegment();
+	public:
-		bool hasPreviousSegment();
+	void moveX(const qreal &);
-		bool hasNextSegment();
+	void moveY(const qreal &);
-		void setPreviousSegment(ConducerSegment *);
+	ConducerSegment *previousSegment() const;
-		void setNextSegment(ConducerSegment *);
+	ConducerSegment *nextSegment()  const;
-		QPointF firstPoint();
+	bool hasPreviousSegment() const;
-		QPointF secondPoint();
+	bool hasNextSegment() const;
-		void setFirstPoint(QPointF);
+	void setPreviousSegment(ConducerSegment *);
-		void setSecondPoint(QPointF);
+	void setNextSegment(ConducerSegment *);
-		QPointF middle();
+	QPointF firstPoint() const;
-		bool isHorizontal();
+	QPointF secondPoint() const;
-		bool isVertical();
+	void setFirstPoint(const QPointF &);
-		qreal length();
+	void setSecondPoint(const QPointF &);
-		bool canMove1stPointX(qreal, qreal &);
+	QPointF middle() const;
-		bool canMove2ndPointX(qreal, qreal &);
+	bool isHorizontal() const;
-		bool canMove1stPointY(qreal, qreal &);
+	bool isVertical() const;
-		bool canMove2ndPointY(qreal, qreal &);
+	qreal length() const;
-	};
+	bool canMove1stPointX(const qreal &, qreal &) const;
+	bool canMove2ndPointX(const qreal &, qreal &) const;
+	bool canMove1stPointY(const qreal &, qreal &) const;
+	bool canMove2ndPointY(const qreal &, qreal &) const;
+};
 #endif

customelement.cpp

@@ -156,6 +156,12 @@ CustomElement::CustomElement(QString &nom_fichier, QGraphicsItem *qgi, Diagram *
 	elmt_etat = 0;
 }
 
+/**
+	Destructeur
+*/
+CustomElement::~CustomElement() {
+}
+
 /**
 	@return Le nombre de bornes que l'element possede
 */

customelement.h

@@ -1,43 +1,102 @@
 #ifndef ELEMENTPERSO_H
-	#define ELEMENTPERSO_H
+#define ELEMENTPERSO_H
-	#include "fixedelement.h"
+#include "fixedelement.h"
-	#include <QtGui>
+#include <QtGui>
-	/**
+/**
-		Cette classe represente un element electrique. Elle est utilisable
+	Cette classe represente un element electrique. Elle est utilisable
-		comme un element fixe. La difference est que l'element perso lit
+	comme un element fixe. La difference est que l'element perso lit
-		sa description (noms, dessin, comportement) dans un fichier XML a fournir
+	sa description (noms, dessin, comportement) dans un fichier XML a fournir
-		en parametre.
+	en parametre.
-	*/
+*/
-	class CustomElement : public FixedElement {
+class CustomElement : public FixedElement {
-		public:
+	// constructeurs, destructeur
-		CustomElement(QString &, QGraphicsItem * = 0, Diagram * = 0, int * = NULL);
+	public:
-		virtual int nbTerminals() const;
+	CustomElement(QString &, QGraphicsItem * = 0, Diagram * = 0, int * = NULL);
-		virtual void paint(QPainter *, const QStyleOptionGraphicsItem *);
+	virtual ~CustomElement();
-		inline QString typeId() const { return(nomfichier); }
+	
-		inline QString fichier() const { return(nomfichier); }
+	private:
-		inline bool isNull() const { return(elmt_etat != 0); }
+	CustomElement(const CustomElement &);
-		inline int etat() const { return(elmt_etat); }
+	
-		inline QString nom() const { return(priv_nom); }
+	// attributs
-		
+	private:
-		private:
+	int elmt_etat; // contient le code d'erreur si l'instanciation a echoue ou 0 si l'instanciation s'est bien passe
-		int elmt_etat; // contient le code d'erreur si l'instanciation a echoue ou 0 si l'instanciation s'est bien passe
+	QString priv_nom;
-		QString priv_nom;
+	QString nomfichier;
-		QString nomfichier;
+	QPicture dessin;
-		QPicture dessin;
+	int nb_terminals;
-		bool parseElement(QDomElement &, QPainter &, Diagram *);
+	
-		bool parseLine(QDomElement &, QPainter &);
+	// methodes
-		bool parseEllipse(QDomElement &, QPainter &);
+	public:
-		bool parseCircle(QDomElement &, QPainter &);
+	virtual int nbTerminals() const;
-		bool parseArc(QDomElement &, QPainter &);
+	virtual void paint(QPainter *, const QStyleOptionGraphicsItem *);
-		bool parsePolygon(QDomElement &, QPainter &);
+	QString typeId() const;
-		bool parseText(QDomElement &, QPainter &);
+	QString fichier() const;
-		bool parseInput(QDomElement &, Diagram *);
+	bool isNull() const;
-		bool parseTerminal(QDomElement &, Diagram *);
+	int etat() const;
-		void setQPainterAntiAliasing(QPainter &, bool);
+	QString nom() const;
-		bool attributeIsAnInteger(QDomElement &, QString, int * = NULL);
+	
-		bool attributeIsAReal(QDomElement &, QString, double * = NULL);
+	private:
-		bool validOrientationAttribute(QDomElement &);
+	bool parseElement(QDomElement &, QPainter &, Diagram *);
-		void setPainterStyle(QDomElement &, QPainter &);
+	bool parseLine(QDomElement &, QPainter &);
-		int nb_terminals;
+	bool parseEllipse(QDomElement &, QPainter &);
-	};
+	bool parseCircle(QDomElement &, QPainter &);
+	bool parseArc(QDomElement &, QPainter &);
+	bool parsePolygon(QDomElement &, QPainter &);
+	bool parseText(QDomElement &, QPainter &);
+	bool parseInput(QDomElement &, Diagram *);
+	bool parseTerminal(QDomElement &, Diagram *);
+	void setQPainterAntiAliasing(QPainter &, bool);
+	bool attributeIsAnInteger(QDomElement &, QString, int * = NULL);
+	bool attributeIsAReal(QDomElement &, QString, double * = NULL);
+	bool validOrientationAttribute(QDomElement &);
+	void setPainterStyle(QDomElement &, QPainter &);
+};
+
+/**
+	@return L'ID du type de l'element ; pour un CustomElement, cela revient au
+	nom du fichier
+	@see fichier()
+*/
+inline QString CustomElement::typeId() const {
+	return(nomfichier);
+}
+
+/**
+	@return L'adresse du fichier contenant la description XML de cet element
+*/
+inline QString CustomElement::fichier() const {
+	return(nomfichier);
+}
+
+/**
+	@return true si cet element est nul, c'est-a-dire si le chargement de sa
+	description XML a echoue
+*/
+inline bool CustomElement::isNull() const {
+	return(elmt_etat != 0);
+}
+
+/**
+	@return Un entier representant l'etat de l'element :
+		- 0 : L'instanciation a reussi
+		- 1 : Le fichier n'existe pas
+		- 2 : Le fichier n'a pu etre ouvert
+		- 3 : Le fichier n'est pas un document XML
+		- 4 : Le document XML n'a pas une "definition" comme racine
+		- 5 : Les attributs de la definition ne sont pas presents et / ou valides
+		- 6 : La definition est vide
+		- 7 : L'analyse d'un element XML decrivant une partie du dessin de l'element a echoue
+		- 8 : Aucune partie du dessin n'a pu etre chargee
+*/
+inline int CustomElement::etat() const {
+	return(elmt_etat);
+}
+
+/**
+	@return Le nom de l'element
+*/
+inline QString CustomElement::nom() const {
+	return(priv_nom);
+}
+
 #endif

diagram.cpp

@@ -10,19 +10,25 @@
 */
 Diagram::Diagram(QObject *parent) : QGraphicsScene(parent) {
 	setBackgroundBrush(Qt::white);
-	poseur_de_conducer = new QGraphicsLineItem(0, 0);
+	conducer_setter = new QGraphicsLineItem(0, 0);
-	poseur_de_conducer -> setZValue(1000000);
+	conducer_setter -> setZValue(1000000);
 	QPen t;
 	t.setColor(Qt::black);
 	t.setWidthF(1.5);
 	t.setStyle(Qt::DashLine);
-	poseur_de_conducer -> setPen(t);
+	conducer_setter -> setPen(t);
-	poseur_de_conducer -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
+	conducer_setter -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
 	draw_grid  = true;
 	use_border = true;
 	connect(this, SIGNAL(changed(const QList<QRectF> &)), this, SLOT(slot_checkSelectionEmptinessChange()));
 }
 
+/**
+	Destructeur
+*/
+Diagram::~Diagram() {
+};
+
 /**
 	Dessine l'arriere-plan du schema, cad la grille.
 	@param p Le QPainter a utiliser pour dessiner
@@ -41,7 +47,7 @@ void Diagram::drawBackground(QPainter *p, const QRectF &r) {
 	p -> setBrush(Qt::white);
 	p -> drawRect(r);
 	
-	if (draw_grid) {
+	if (draw_grid && r.width() < 2500 && r.height() < 2500) {
 		// dessine les points de la grille
 		p -> setPen(Qt::black);
 		p -> setBrush(Qt::NoBrush);

diagram.h

@@ -11,38 +11,50 @@ class Element;
 class Terminal;
 class Diagram : public QGraphicsScene {
 	Q_OBJECT
-	enum BorderOptions { EmptyBorder, Inset, Columns };
+	
+	// constructeurs, destructeur
 	public:
 	Diagram(QObject * = 0);
+	virtual ~Diagram();
+	
+	private:
+	Diagram(const Diagram &diagram);
+	
+	// attributs
+	public:
+	enum BorderOptions { EmptyBorder, Inset, Columns };
+	BorderInset border_and_inset;
+	
+	private:
+	QGraphicsLineItem *conducer_setter;
+	bool draw_grid;
+	bool use_border;
+	
+	// methodes
+	public:
 	void drawBackground(QPainter *, const QRectF &);
 	
 	// fonctions relatives a la pose de conducteurs
-	void poseConducer(bool);
+	void setConducer(bool);
-	
+	void setConducerStart (QPointF);
-	void setDepart (QPointF);
+	void setConducerStop(QPointF);
-	void setArrivee(QPointF);
 	
 	// fonctions relatives a l'import / export XML
 	QDomDocument toXml(bool = true);
 	bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true);
 	
 	// fonctions relatives aux options graphiques
-	void setAffichageGrille(bool);
+	void setDisplayGrid(bool);
 	bool displayGrid();
 	void setUseBorder(bool);
 	bool useBorder();
 	void setBorderOptions(BorderOptions);
 	BorderOptions borderOptions();
-	BorderInset border_and_inset;
+	
 	QRectF border() const;
 	QImage toImage(int = -1, int = -1, Qt::AspectRatioMode = Qt::KeepAspectRatio);
 	QSize imageSize() const;
 	
-	private:
-	QGraphicsLineItem *poseur_de_conducer;
-	bool draw_grid;
-	bool use_border;
-	
 	private slots:
 	void slot_checkSelectionChange();
 	void slot_checkSelectionEmptinessChange();
@@ -58,11 +70,11 @@ class Diagram : public QGraphicsScene {
 	bornes.
 	@param true pour ajouter le poseur de conducteur, false pour l'enlever
 */
-inline void Diagram::poseConducer(bool pf) {
+inline void Diagram::setConducer(bool pf) {
 	if (pf) {
-		if (!poseur_de_conducer -> scene()) addItem(poseur_de_conducer);
+		if (!conducer_setter -> scene()) addItem(conducer_setter);
 	} else {
-		if (poseur_de_conducer -> scene()) removeItem(poseur_de_conducer);
+		if (conducer_setter -> scene()) removeItem(conducer_setter);
 	}
 }
 
@@ -70,23 +82,23 @@ inline void Diagram::poseConducer(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::setDepart(QPointF d) {
+inline void Diagram::setConducerStart(QPointF d) {
-	poseur_de_conducer -> setLine(QLineF(d, poseur_de_conducer -> line().p2()));
+	conducer_setter -> setLine(QLineF(d, conducer_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::setArrivee(QPointF a) {
+inline void Diagram::setConducerStop(QPointF a) {
-	poseur_de_conducer -> setLine(QLineF(poseur_de_conducer -> line().p1(), a));
+	conducer_setter -> setLine(QLineF(conducer_setter -> line().p1(), a));
 }
 
 /**
 	Permet de specifier si la grille du schema doit etre dessinee ou non
 	@param dg true pour afficher la grille, false pour ne pas l'afficher
 */
-inline void Diagram::setAffichageGrille(bool dg) {
+inline void Diagram::setDisplayGrid(bool dg) {
 	draw_grid = dg;
 }
 

diagramview.cpp

@@ -2,6 +2,7 @@
 #include "diagram.h"
 #include "customelement.h"
 #include "exportdialog.h"
+#include "conducer.h"
 
 /**
 	Initialise le DiagramView
@@ -40,6 +41,12 @@ DiagramView::DiagramView(QWidget *parent) : QGraphicsView(parent) {
 	initialise();
 }
 
+/**
+	Destructeur
+*/
+DiagramView::~DiagramView() {
+}
+
 /**
 	appelle la methode select sur tous les elements de la liste d'elements
 */
@@ -443,9 +450,9 @@ void DiagramView::dialogPrint() {
 	
 	if (qpd.exec() == QDialog::Accepted) {
 		QPainter qp(&qprin);
-		scene -> setAffichageGrille(false);
+		scene -> setDisplayGrid(false);
 		scene -> render(&qp);
-		scene -> setAffichageGrille(true);
+		scene -> setDisplayGrid(true);
 	}
 }
 

diagramview.h

@@ -1,75 +1,79 @@
 #ifndef DIAGRAMVIEW_H
-	#define DIAGRAMVIEW_H
+#define DIAGRAMVIEW_H
-	#include <QtGui>
+#include <QtGui>
-	class Diagram;
+class Diagram;
-	#include "element.h"
+/**
-	#include "conducer.h"
+	Classe representant graphiquement un schema electrique
-	/**
+*/
-		Classe representant graphiquement un schema electrique
+class DiagramView : public QGraphicsView {
-	*/
+	Q_OBJECT
-	class DiagramView : public QGraphicsView {
+	
-		Q_OBJECT
+	// constructeurs, destructeur
-		public:
+	public:
-		// constructeurs
+	DiagramView();
-		DiagramView();
+	DiagramView(QWidget * = 0);
-		DiagramView(QWidget * = 0);
+	virtual ~DiagramView();
-		
+	
-		// nouveaux attributs
+	private:
-		Diagram *scene;
+	DiagramView(const DiagramView &);
-		
+	
-		// methodes publiques
+	// attributs
-		bool ouvrir(QString, int * = NULL);
+	private:
-		void closeEvent(QCloseEvent *);
+	Diagram *scene;
-		QString nom_fichier;
+	QList<QGraphicsItem *> garbage;
-		bool enregistrer();
+	
-		bool enregistrer_sous();
+	// methodes
-		void dialogExport();
+	public:
-		void dialogEditInfos();
+	bool ouvrir(QString, int * = NULL);
-		void dialogPrint();
+	void closeEvent(QCloseEvent *);
-		void addColumn();
+	QString nom_fichier;
-		void removeColumn();
+	bool enregistrer();
-		void adjustHeight(qreal);
+	bool enregistrer_sous();
-		void adjustSceneRect();
+	void dialogExport();
-		void expand();
+	void dialogEditInfos();
-		void shrink();
+	void dialogPrint();
-		Diagram *diagram() { return(scene); }
+	void addColumn();
-		bool hasSelectedItems();
+	void removeColumn();
-		
+	void adjustHeight(qreal);
-		private:
+	void adjustSceneRect();
-		bool private_enregistrer(QString &);
+	void expand();
-		void initialise();
+	void shrink();
-		QList<QGraphicsItem *> garbage;
+	Diagram *diagram() { return(scene); }
-		
+	bool hasSelectedItems();
-		void throwToGarbage(QGraphicsItem *);
+	
-		void mousePressEvent(QMouseEvent *);
+	private:
-		void dragEnterEvent(QDragEnterEvent *);
+	bool private_enregistrer(QString &);
-		void dragLeaveEvent(QDragLeaveEvent *);
+	void initialise();
-		void dragMoveEvent(QDragMoveEvent *);
+	void throwToGarbage(QGraphicsItem *);
-		void dropEvent(QDropEvent *);
+	void mousePressEvent(QMouseEvent *);
-		
+	void dragEnterEvent(QDragEnterEvent *);
-		signals:
+	void dragLeaveEvent(QDragLeaveEvent *);
-		void selectionChanged();
+	void dragMoveEvent(QDragMoveEvent *);
-		void antialiasingChanged();
+	void dropEvent(QDropEvent *);
-		void modeChanged();
+	
-		
+	signals:
-		public slots:
+	void selectionChanged();
-		void selectNothing();
+	void antialiasingChanged();
-		void selectAll();
+	void modeChanged();
-		void selectInvert();
+	
-		void supprimer();
+	public slots:
-		void pivoter();
+	void selectNothing();
-		void setVisualisationMode();
+	void selectAll();
-		void setSelectionMode();
+	void selectInvert();
-		void zoomPlus();
+	void supprimer();
-		void zoomMoins();
+	void pivoter();
-		void zoomFit();
+	void setVisualisationMode();
-		void zoomReset();
+	void setSelectionMode();
-		void couper();
+	void zoomPlus();
-		void copier();
+	void zoomMoins();
-		void coller();
+	void zoomFit();
-		
+	void zoomReset();
-		private slots:
+	void couper();
-		void flushGarbage();
+	void copier();
-		void slot_selectionChanged();
+	void coller();
-	};
+	
+	private slots:
+	void flushGarbage();
+	void slot_selectionChanged();
+};
 #endif

element.cpp

@@ -3,8 +3,6 @@
 #include "elementtextitem.h"
 #include <QtDebug>
 
-/*** Methodes publiques ***/
-
 /**
 	Constructeur pour un element sans scene ni parent
 */
@@ -13,6 +11,12 @@ Element::Element(QGraphicsItem *parent, Diagram *scene) : QGraphicsItem(parent,
 	setZValue(10);
 }
 
+/**
+	Destructeur
+*/
+Element::~Element() {
+}
+
 /**
 	Methode principale de dessin de l'element
 	@param painter Le QPainter utilise pour dessiner l'elment
@@ -110,10 +114,6 @@ QVariant Element::itemChange(GraphicsItemChange change, const QVariant &value) {
 		foreach(QGraphicsItem *qgi, children()) {
 			if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConducer(value.toPointF());
 		}
-	} else if (change == QGraphicsItem::ItemSelectedChange) {
-		foreach(QGraphicsItem *qgi, children()) {
-			if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConducer();
-		}
 	}
 	return(QGraphicsItem::itemChange(change, value));
 }

element.h

@@ -7,45 +7,20 @@
 */
 class Diagram;
 class Element : public QGraphicsItem {
+	
+	// constructeurs, destructeur
+	public:
+	Element(QGraphicsItem * = 0, Diagram * = 0);
+	virtual ~Element();
+	
+	private:
+	Element(const Element &);
+	
+	// attributs
 	public:
 	enum { Type = UserType + 1000 };
-	virtual int type() const { return Type; }
-	Element(QGraphicsItem * = 0, Diagram * = 0);
-	
-	virtual  int nbTerminals()    const = 0;
-	virtual  int nbTerminalsMin() const = 0;
-	virtual  int nbTerminalsMax() const = 0;
-	virtual  void paint(QPainter *, const QStyleOptionGraphicsItem *) = 0;
-	virtual  QString typeId() const = 0;
-	
-	virtual QString  nom() const = 0;
-	void     paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
-	QRectF   boundingRect() const;
-	QSize    setSize(int, int);
-	QPoint   setHotspot(QPoint);
-	QPoint   hotspot() const;
-	void     select();
-	void     deselect();
-	QPixmap  pixmap();
-	QVariant itemChange(GraphicsItemChange, const QVariant &);
-	void     setPos(const QPointF &);
-	void     setPos(qreal, qreal);
-	bool     connexionsInternesAcceptees();
-	void     setConnexionsInternesAcceptees(bool cia);
-	static bool     valideXml(QDomElement &);
-	virtual bool fromXml(QDomElement  &, QHash<int, Terminal *>&);
-	virtual QDomElement toXml (QDomDocument &, QHash<Terminal *, int>&) const;
-	// methodes d'acces aux possibilites d'orientation
-	Terminal::Orientation orientation() const;
-	bool acceptOrientation(Terminal::Orientation o) const;
-	Terminal::Orientation defaultOrientation() const;
-	Terminal::Orientation nextAcceptableOrientation() const;
-	Terminal::Orientation previousAcceptableOrientation() const;
-	bool setOrientation(Terminal::Orientation o);
 	
 	protected:
-	void drawAxes(QPainter *, const QStyleOptionGraphicsItem *);
-	void mouseMoveEvent(QGraphicsSceneMouseEvent *);
 	bool    ori_n;
 	bool    ori_s;
 	bool    ori_e;
@@ -53,6 +28,63 @@ class Element : public QGraphicsItem {
 	Terminal::Orientation ori_d;
 	Terminal::Orientation ori;
 	
+	private:
+	QSize   dimensions;
+	QPoint  hotspot_coord;
+	QPixmap apercu;
+	QMenu   menu;
+	
+	// methodes
+	public:
+	virtual int type() const { return Type; }
+	
+	// methodes virtuelles pures a definir dans les classes enfants
+	virtual int nbTerminals() const = 0;
+	virtual int nbTerminalsMin() const = 0;
+	virtual int nbTerminalsMax() const = 0;
+	virtual void paint(QPainter *, const QStyleOptionGraphicsItem *) = 0;
+	virtual QString typeId() const = 0;
+	virtual QString nom() const = 0;
+	
+	void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
+	QVariant itemChange(GraphicsItemChange, const QVariant &);
+	QRectF boundingRect() const;
+	QSize setSize(int, int);
+	QPixmap  pixmap();
+	
+	// methodes relatives au point de saisie
+	QPoint setHotspot(QPoint);
+	QPoint hotspot() const;
+	
+	// methodes relatives a la selection
+	void select();
+	void deselect();
+	
+	// methodes relatives a la position
+	void setPos(const QPointF &);
+	void setPos(qreal, qreal);
+	
+	// methodes relatives aux connexions internes
+	bool connexionsInternesAcceptees();
+	void setConnexionsInternesAcceptees(bool cia);
+	
+	// methodes relatives aux fichiers XML
+	static bool valideXml(QDomElement &);
+	virtual bool fromXml(QDomElement &, QHash<int, Terminal *>&);
+	virtual QDomElement toXml(QDomDocument &, QHash<Terminal *, int>&) const;
+	
+	// methodes d'acces aux possibilites d'orientation
+	Terminal::Orientation orientation() const;
+	Terminal::Orientation defaultOrientation() const;
+	bool acceptOrientation(Terminal::Orientation o) const;
+	Terminal::Orientation nextAcceptableOrientation() const;
+	Terminal::Orientation previousAcceptableOrientation() const;
+	bool setOrientation(Terminal::Orientation o);
+	
+	protected:
+	void drawAxes(QPainter *, const QStyleOptionGraphicsItem *);
+	void mouseMoveEvent(QGraphicsSceneMouseEvent *);
+	
 	private:
 	bool peut_relier_ses_propres_terminals;
 	void drawSelection(QPainter *, const QStyleOptionGraphicsItem *);
@@ -60,11 +92,6 @@ class Element : public QGraphicsItem {
 	Terminal::Orientation nextOrientation(Terminal::Orientation o) const;
 	Terminal::Orientation previousOrientation(Terminal::Orientation o) const;
 	static QList<QDomElement> findInDomElement(QDomElement, QString, QString);
-	
-	QSize   dimensions;
-	QPoint  hotspot_coord;
-	QPixmap apercu;
-	QMenu   menu;
 };
 
 /**

elementscategorieslist.cpp

@@ -21,7 +21,6 @@ ElementsCategoriesList::ElementsCategoriesList(QWidget *parent) : QTreeWidget(pa
 	Destructeur
 */
 ElementsCategoriesList::~ElementsCategoriesList() {
-	
 }
 
 /**

elementscategorieslist.h

@@ -7,23 +7,24 @@
 */
 class ElementsCategoriesList : public QTreeWidget {
 	Q_OBJECT
-	// Constructeur, destructeur
+	
+	// Constructeurs, destructeur
 	public:
 	ElementsCategoriesList(QWidget * = 0);
-	~ElementsCategoriesList();
+	virtual ~ElementsCategoriesList();
-	
-	// attributs
 	
+	private:
+	ElementsCategoriesList(const ElementsCategoriesList &);
 	
 	// methodes
-	private:
-	void addDir(QTreeWidgetItem *, QString, QString = QString());
-	QString categoryName(QDir &);
-	
 	public:
 	QString selectedCategoryPath();
 	QString selectedCategoryName();
 	
+	private:
+	void addDir(QTreeWidgetItem *, QString, QString = QString());
+	QString categoryName(QDir &);
+	
 	public slots:
 	void reload();
 };

elementscategorieswidget.h

@@ -9,10 +9,14 @@
 class ElementsCategoriesList;
 class ElementsCategoriesWidget : public QWidget {
 	Q_OBJECT
-	// Constructeur, destructeur
+	
+	// Constructeurs, destructeur
 	public:
 	ElementsCategoriesWidget(QWidget * = 0);
-	~ElementsCategoriesWidget();
+	virtual ~ElementsCategoriesWidget();
+	
+	private:
+	ElementsCategoriesWidget(const ElementsCategoriesWidget &);
 	
 	// attributs
 	private:
@@ -24,8 +28,6 @@ class ElementsCategoriesWidget : public QWidget {
 	QAction *action_delete;
 	
 	// methodes
-	bool rmdir(const QString &);
-	
 	public:
 	ElementsCategoriesList &elementsCategoriesList() const;
 	

elementscategory.cpp

@@ -13,7 +13,6 @@ ElementsCategory::ElementsCategory(const QString &path) : QDir(path) {
 	Destructeur
 */
 ElementsCategory::~ElementsCategory() {
-	
 }
 
 /**

elementscategory.h

@@ -7,20 +7,19 @@
 	qet_directory contenant ses caracteristiques (pour le moment : ses noms).
 */
 class ElementsCategory : public QDir {
-	// Constructeur, destructeur
+	// constructeurs, destructeur
 	public:
 	ElementsCategory(const QString & = QString());
-	~ElementsCategory();
+	virtual ~ElementsCategory();
+	
+	private:
+	ElementsCategory(const ElementsCategory &);
 	
 	// attributs
 	private:
 	QHash<QString, QString> category_names;
 	
 	// methodes
-	private:
-	bool rmdir(const QString &) const;
-	void loadNames();
-	
 	public:
 	QString name() const;
 	QHash<QString, QString> categoryNames() const;
@@ -29,5 +28,9 @@ class ElementsCategory : public QDir {
 	bool write() const;
 	bool remove() const;
 	//bool move(const QString &new_parent);
+	
+	private:
+	bool rmdir(const QString &) const;
+	void loadNames();
 };
 #endif

elementscategoryeditor.h

@@ -9,11 +9,15 @@ class ElementsCategory;
 class NamesList;
 class ElementsCategoryEditor : public QDialog {
 	Q_OBJECT
-	//Constructeurs, destructeur
+	
+	// constructeurs, destructeur
 	public:
 	ElementsCategoryEditor(QWidget * = 0);
 	ElementsCategoryEditor(const QString &, bool = true, QWidget * = 0);
-	~ElementsCategoryEditor();
+	virtual ~ElementsCategoryEditor();
+	
+	private:
+	ElementsCategoryEditor(const ElementsCategoryEditor &);
 	
 	// attributs
 	private:
@@ -29,6 +33,5 @@ class ElementsCategoryEditor : public QDialog {
 	public slots:
 	void acceptCreation();
 	void acceptUpdate();
-	
 };
 #endif

elementspanel.cpp

@@ -35,6 +35,12 @@ ElementsPanel::ElementsPanel(QWidget *parent) :  QTreeWidget(parent) {
 	setPalette(qp);
 }
 
+/**
+	Destructeur
+*/
+ElementsPanel::~ElementsPanel() {
+}
+
 /**
 	Gere le mouvement lors d'un drag'n drop
 */

elementspanel.h

@@ -1,24 +1,32 @@
 #ifndef PANELAPPAREILS_H
-	#define PANELAPPAREILS_H
+#define PANELAPPAREILS_H
-	#include <QtGui>
+#include <QtGui>
-	#include "qetapp.h"
+#include "qetapp.h"
-	/**
+/**
-		Cette classe represente le panel d'appareils (en tant qu'element
+	Cette classe represente le panel d'appareils (en tant qu'element
-		graphique) dans lequel l'utilisateur choisit les composants de
+	graphique) dans lequel l'utilisateur choisit les composants de
-		son choix et les depose sur le schema par drag'n drop.
+	son choix et les depose sur le schema par drag'n drop.
-	*/
+*/
-	class ElementsPanel : public QTreeWidget {
+class ElementsPanel : public QTreeWidget {
-		Q_OBJECT
+	Q_OBJECT
-		public:
+	
-		ElementsPanel(QWidget * = 0);
+	// constructeurs, destructeur
-		static QString categoryName(QDir &);
+	public:
-		public slots:
+	ElementsPanel(QWidget * = 0);
-		void dragMoveEvent(QDragMoveEvent *);
+	virtual ~ElementsPanel();
-		void dropEvent(QDropEvent *);
+	
-		void startDrag(Qt::DropActions);
+	private:
-		void reload();
+	ElementsPanel(const ElementsPanel &);
-		private:
+	
-		void addFile(QTreeWidgetItem *, QString);
+	// methodes
-		void addDir(QTreeWidgetItem *, QString, QString = QString());
+	private:
-	};
+	void addFile(QTreeWidgetItem *, QString);
+	void addDir(QTreeWidgetItem *, QString, QString = QString());
+	
+	public slots:
+	void dragMoveEvent(QDragMoveEvent *);
+	void dropEvent(QDropEvent *);
+	void startDrag(Qt::DropActions);
+	void reload();
+};
 #endif

elementspanelwidget.cpp

@@ -25,6 +25,12 @@ ElementsPanelWidget::ElementsPanelWidget(QWidget *parent) : QWidget(parent) {
 	setLayout(vlayout);
 }
 
+/**
+	Destructeur
+*/
+ElementsPanelWidget::~ElementsPanelWidget() {
+}
+
 /**
 	Appelle l'assistant de creation de nouvel element
 */

elementspanelwidget.h

@@ -10,9 +10,13 @@
 class ElementsPanelWidget : public QWidget {
 	Q_OBJECT
 	
-	// constructeurs
+	// constructeurs, destructeur
 	public:
 	ElementsPanelWidget(QWidget * = 0);
+	virtual ~ElementsPanelWidget();
+	
+	private:
+	ElementsPanelWidget(const ElementsPanelWidget &);
 	
 	// attributs
 	private:
@@ -21,9 +25,17 @@ class ElementsPanelWidget : public QWidget {
 	
 	// methodes
 	public:
-	inline ElementsPanel &elementsPanel() const { return(*elements_panel); }
+	inline ElementsPanel &elementsPanel() const;
 	
 	public slots:
 	void newElement();
 };
+
+/**
+	@return Le panel d'elements imbrique dans ce widget
+*/
+inline ElementsPanel &ElementsPanelWidget::elementsPanel() const {
+	return(*elements_panel);
+}
+
 #endif

elementtextitem.cpp

@@ -21,6 +21,9 @@ ElementTextItem::ElementTextItem(const QString &text, QGraphicsItem *parent, QGr
 	setTextInteractionFlags(Qt::TextEditorInteraction);
 }
 
+ElementTextItem::~ElementTextItem() {
+}
+
 /**
 	Modifie la position du champ de texte
 	@param pos La nouvelle position du champ de texte
@@ -55,7 +58,7 @@ QPointF ElementTextItem::pos() const {
 	valeur a ce champ.
 	@param e L'element XML representant le champ de texte
 */
-void ElementTextItem::fromXml(QDomElement &e) {
+void ElementTextItem::fromXml(const QDomElement &e) {
 	QPointF _pos = pos();
 	if (e.attribute("x").toDouble() == _pos.x() && e.attribute("y").toDouble() == _pos.y()) {
 		setPlainText(e.attribute("text"));
@@ -66,7 +69,7 @@ void ElementTextItem::fromXml(QDomElement &e) {
 	@param document Le document XML a utiliser
 	@return L'element XML representant ce champ de texte
 */
-QDomElement ElementTextItem::toXml(QDomDocument &document) {
+QDomElement ElementTextItem::toXml(QDomDocument &document) const {
 	QDomElement result = document.createElement("input");
 	result.setAttribute("x", pos().x());
 	result.setAttribute("y", pos().y());

elementtextitem.h

@@ -8,23 +8,26 @@
 	malgre les rotations de son element parent.
 */
 class ElementTextItem : public QGraphicsTextItem {
-	// constructeurs
+	// constructeurs, destructeur
 	public:
 	ElementTextItem(QGraphicsItem * = 0, QGraphicsScene * = 0);
 	ElementTextItem(const QString &, QGraphicsItem * = 0, QGraphicsScene * = 0);
+	virtual ~ElementTextItem();
 	
 	// attributs
+	public:
+	enum { Type = UserType + 1003 };
+	
 	private:
 	bool follow_parent_rotations;
 	
 	// methodes
 	public:
-	enum { Type = UserType + 1003 };
 	virtual int type() const { return Type; }
 	bool followParentRotations() const;
 	void setFollowParentRotations(bool);
-	void fromXml(QDomElement &);
+	void fromXml(const QDomElement &);
-	QDomElement toXml(QDomDocument &);
+	QDomElement toXml(QDomDocument &) const;
 	void setPos(const QPointF &);
 	void setPos(qreal, qreal);
 	QPointF pos() const;

exportdialog.cpp

@@ -58,7 +58,6 @@ ExportDialog::ExportDialog(Diagram *dia, QWidget *parent) : QDialog(parent) {
 	Destructeur - ne fait rien
 */
 ExportDialog::~ExportDialog() {
-	
 }
 
 /**
@@ -266,7 +265,7 @@ QImage ExportDialog::generateImage() {
 	
 	// genere l'image
 	diagram -> setUseBorder(export_border -> isChecked());
-	diagram -> setAffichageGrille(draw_grid -> isChecked());
+	diagram -> setDisplayGrid(draw_grid -> isChecked());
 	diagram -> border_and_inset.displayBorder(draw_border -> isChecked());
 	diagram -> border_and_inset.displayColumns(draw_columns -> isChecked());
 	diagram -> border_and_inset.displayInset(draw_inset -> isChecked());
@@ -287,7 +286,7 @@ QImage ExportDialog::generateImage() {
 	diagram -> border_and_inset.displayBorder(state_drawBorder);
 	diagram -> border_and_inset.displayColumns(state_drawColumns);
 	diagram -> border_and_inset.displayInset(state_drawInset);
-	diagram -> setAffichageGrille(state_drawGrid);
+	diagram -> setDisplayGrid(state_drawGrid);
 	diagram -> setUseBorder(state_useBorder);
 	
 	return(image);

exportdialog.h

@@ -1,58 +1,66 @@
 #ifndef EXPORTDIALOG_H
-	#define EXPORTDIALOG_H
+#define EXPORTDIALOG_H
-	#include <QtGui>
+#include <QtGui>
-	#include "diagram.h"
+#include "diagram.h"
-	/**
+/**
-		Cette classe represente le dialogue permettant d'exporter un schema
+	Cette classe represente le dialogue permettant d'exporter un schema
-		sous forme d'image selon les desirs de l'utilisateur
+	sous forme d'image selon les desirs de l'utilisateur
-	*/
+*/
-	class ExportDialog : public QDialog {
+class ExportDialog : public QDialog {
-		Q_OBJECT
+	Q_OBJECT
-		public:
+	
-		ExportDialog(Diagram *, QWidget * = 0);
+	// constructeurs, destructeur
-		~ExportDialog();
+	public:
-		
+	ExportDialog(Diagram *, QWidget * = 0);
-		private:
+	virtual ~ExportDialog();
-		// elements graphiques
+	
-		QLineEdit *filename;
+	private:
-		QPushButton *button_browse;
+	ExportDialog(const ExportDialog &);
-		QComboBox *format;
+	
-		QSpinBox *width;
+	// attributs
-		QSpinBox *height;
+	private:
-		QCheckBox *keep_aspect_ratio;
+	// elements graphiques
-		QCheckBox *draw_grid;
+	QLineEdit *filename;
-		QCheckBox *draw_border;
+	QPushButton *button_browse;
-		QCheckBox *draw_inset;
+	QComboBox *format;
-		QCheckBox *draw_columns;
+	QSpinBox *width;
-		QCheckBox *keep_colors;
+	QSpinBox *height;
-		QRadioButton *export_elements;
+	QCheckBox *keep_aspect_ratio;
-		QRadioButton *export_border;
+	QCheckBox *draw_grid;
-		QDialogButtonBox *buttons;
+	QCheckBox *draw_border;
-		QGraphicsScene *preview_scene;
+	QCheckBox *draw_inset;
-		QGraphicsView *preview_view;
+	QCheckBox *draw_columns;
-		
+	QCheckBox *keep_colors;
-		// booleens pour ne pas avoir de boucle lors de l'edition des dimensions de l'image
+	QRadioButton *export_elements;
-		bool dontchangewidth;
+	QRadioButton *export_border;
-		bool dontchangeheight;
+	QDialogButtonBox *buttons;
-		
+	QGraphicsScene *preview_scene;
-		// elements relatifs au traitement effectue par le dialogue
+	QGraphicsView *preview_view;
-		Diagram *diagram;
+	
-		QSize diagram_size;
+	// booleens pour ne pas avoir de boucle lors de l'edition des dimensions de l'image
-		QString diagram_path;
+	bool dontchangewidth;
-		qreal diagram_ratio;
+	bool dontchangeheight;
-		
+	
-		QWidget *leftPart();
+	// elements relatifs au traitement effectue par le dialogue
-		QWidget *rightPart();
+	Diagram *diagram;
-		QGroupBox *setupDimensionsGroupBox();
+	QSize diagram_size;
-		QGroupBox *setupOptionsGroupBox();
+	QString diagram_path;
-		QImage generateImage();
+	qreal diagram_ratio;
-		
+	
-		public slots:
+	// methodes
-		void slot_correctWidth();
+	private:
-		void slot_correctHeight();
+	QWidget *leftPart();
-		void slot_chooseAFile();
+	QWidget *rightPart();
-		void slot_check();
+	QGroupBox *setupDimensionsGroupBox();
-		void slot_changeUseBorder();
+	QGroupBox *setupOptionsGroupBox();
-		void slot_refreshPreview();
+	QImage generateImage();
-	};
+	
+	public slots:
+	void slot_correctWidth();
+	void slot_correctHeight();
+	void slot_chooseAFile();
+	void slot_check();
+	void slot_changeUseBorder();
+	void slot_refreshPreview();
+};
 #endif

fixedelement.cpp

@@ -5,6 +5,12 @@
 FixedElement::FixedElement(QGraphicsItem *parent, Diagram *scene) : Element(parent, scene) {
 }
 
+/**
+	Destructeur
+*/
+FixedElement::~FixedElement() {
+}
+
 /**
 	@return Le nombre minimal de bornes que l'element peut avoir
 */

fixedelement.h

@@ -1,14 +1,23 @@
 #ifndef ELEMENTFIXE_H
-	#define ELEMENTFIXE_H
+#define ELEMENTFIXE_H
-	#include "element.h"
+#include "element.h"
-	class FixedElement : public Element {
+/**
-		public:
+	Cette classe represente un element avec un nombre fixe de bornes.
-		FixedElement(QGraphicsItem * = 0, Diagram * = 0);
+*/
-		int nbTerminalsMin() const;
+class FixedElement : public Element {
-		int nbTerminalsMax() const;
+	
-		virtual int nbTerminals() const = 0;
+	// constructeurs, destructeur
-		virtual void paint(QPainter *, const QStyleOptionGraphicsItem *) = 0;
+	public:
-		virtual QString typeId() const = 0;
+	FixedElement(QGraphicsItem * = 0, Diagram * = 0);
-		virtual QString  nom() const = 0;
+	virtual ~FixedElement();
-	};
+	
+	// methodes
+	public:
+	int nbTerminalsMin() const;
+	int nbTerminalsMax() const;
+	virtual int nbTerminals() const = 0;
+	virtual void paint(QPainter *, const QStyleOptionGraphicsItem *) = 0;
+	virtual QString typeId() const = 0;
+	virtual QString  nom() const = 0;
+};
 #endif

nameslist.cpp

@@ -25,7 +25,6 @@ NamesList::NamesList(QWidget *parent) : QWidget(parent) {
 	Destructeur
 */
 NamesList::~NamesList() {
-	
 }
 
 /**

nameslist.h

@@ -7,10 +7,14 @@
 */
 class NamesList : public QWidget {
 	Q_OBJECT
-	//Constructeur, destructeur
+	
+	// constructeurs, destructeur
 	public:
 	NamesList(QWidget * = 0);
-	~NamesList();
+	virtual ~NamesList();
+	
+	private:
+	NamesList(const NamesList &);
 	
 	// attributs
 	private:
@@ -23,6 +27,7 @@ class NamesList : public QWidget {
 	bool checkOneName();
 	QHash<QString, QString> names();
 	void setNames(QHash<QString, QString> &);
+	
 	private:
 	void clean();
 	void updateHash();

newelementwizard.h

@@ -17,10 +17,14 @@ class NamesList;
 class Diagram;
 class NewElementWizard : public QDialog {
 	Q_OBJECT
-	// Constructeur, destructeur
+	
+	// constructeurs, destructeur
 	public:
 	NewElementWizard(QWidget * = 0, Qt::WindowFlags = 0);
-	~NewElementWizard();
+	virtual ~NewElementWizard();
+	
+	private:
+	NewElementWizard(const NewElementWizard &);
 	
 	// attributs
 	private:

qetapp.cpp

@@ -88,6 +88,12 @@ QETApp::QETApp(QWidget *parent) : QMainWindow(parent) {
 	connect(QApplication::clipboard(), SIGNAL(dataChanged()),              this, SLOT(slot_updateActions()));
 }
 
+/**
+	Destructeur
+*/
+QETApp::~QETApp() {
+}
+
 /**
 	Gere les evenements relatifs au QSystemTrayIcon
 	@param raison un entier representant l'evenement survenu sur le systray
@@ -604,7 +610,7 @@ bool QETApp::fermer() {
 /**
 	@return Le DiagramView qui a le focus dans l'interface MDI
 */
-DiagramView *QETApp::diagramEnCours() {
+DiagramView *QETApp::diagramEnCours() const {
 	return(qobject_cast<DiagramView *>(workspace.activeWindow()));
 }
 

qetapp.h

@@ -1,134 +1,146 @@
 #ifndef QETAPP_H
-	#define QETAPP_H
+#define QETAPP_H
-	#include <QtGui>
+#include <QtGui>
-	class DiagramView;
+class DiagramView;
-	class ElementsPanelWidget;
+class ElementsPanelWidget;
-	/**
+/**
-		Cette classe represente la fenetre principale de QElectroTech et,
+	Cette classe represente la fenetre principale de QElectroTech et,
-		ipso facto, la plus grande partie de l'interface graphique de QElectroTech.
+	ipso facto, la plus grande partie de l'interface graphique de QElectroTech.
-		Il s'agit d'un objet QMainWindow avec un QWorkSpace contenant des objets
+	Il s'agit d'un objet QMainWindow avec un QWorkSpace contenant des objets
-		« Diagram » en guise de widget central et un « Panel d'Appareils » en guise
+	« Diagram » en guise de widget central et un « Panel d'Appareils » en guise
-		de widget « Dock ».
+	de widget « Dock ».
-	*/
+*/
-	class QETApp : public QMainWindow {
+class QETApp : public QMainWindow {
-		Q_OBJECT
+	Q_OBJECT
-		public:
+	
-		QETApp(QWidget * = 0);
+	// constructeurs, destructeur
-		void closeEvent(QCloseEvent *);
+	public:
-		void addDiagramView(DiagramView *);
+	QETApp(QWidget * = 0);
-		static QString commonElementsDir();
+	virtual ~QETApp();
-		static QString customElementsDir();
+	
-		static QString configDir();
+	private:
-		static QString languagesPath();
+	QETApp(const QETApp &);
-		static QString realPath(QString &);
+	
-		static QString symbolicPath(QString &);
+	// methodes
-		
+	public:
-		public slots:
+	void closeEvent(QCloseEvent *);
-		void systray(QSystemTrayIcon::ActivationReason);
+	void addDiagramView(DiagramView *);
-		void systrayReduce();
+	static QString commonElementsDir();
-		void systrayRestore();
+	static QString customElementsDir();
-		void quit(QCloseEvent * = NULL);
+	static QString configDir();
-		void toggleFullScreen();
+	static QString languagesPath();
-		void aPropos();
+	static QString realPath(QString &);
-		void dialog_print();
+	static QString symbolicPath(QString &);
-		void dialog_export();
+	
-		bool dialogue_enregistrer_sous();
+	protected:
-		bool enregistrer();
+	void actions();
-		bool nouveau();
+	
-		bool ouvrir();
+	private:
-		bool fermer();
+	DiagramView *diagramEnCours() const;
-		void slot_editInfos();
+	void menus();
-		void slot_couper();
+	void toolbar();
-		void slot_copier();
+	
-		void slot_coller();
+	public slots:
-		void slot_zoomPlus();
+	void systray(QSystemTrayIcon::ActivationReason);
-		void slot_zoomMoins();
+	void systrayReduce();
-		void slot_zoomFit();
+	void systrayRestore();
-		void slot_zoomReset();
+	void quit(QCloseEvent * = NULL);
-		void slot_selectAll();
+	void toggleFullScreen();
-		void slot_selectNothing();
+	void aPropos();
-		void slot_selectInvert();
+	void dialog_print();
-		void slot_supprimer();
+	void dialog_export();
-		void slot_pivoter();
+	bool dialogue_enregistrer_sous();
-		void slot_setSelectionMode();
+	bool enregistrer();
-		void slot_setVisualisationMode();
+	bool nouveau();
-		void slot_updateActions();
+	bool ouvrir();
-		void slot_updateMenuFenetres();
+	bool fermer();
-		void slot_addColumn();
+	void slot_editInfos();
-		void slot_removeColumn();
+	void slot_couper();
-		void slot_expand();
+	void slot_copier();
-		void slot_shrink();
+	void slot_coller();
-		
+	void slot_zoomPlus();
-		protected:
+	void slot_zoomMoins();
-		// Actions faisables au travers de menus dans l'application QElectroTech
+	void slot_zoomFit();
-		QAction *mode_selection;
+	void slot_zoomReset();
-		QAction *mode_visualise;
+	void slot_selectAll();
-		QAction *nouveau_fichier;
+	void slot_selectNothing();
-		QAction *ouvrir_fichier;
+	void slot_selectInvert();
-		QAction *fermer_fichier;
+	void slot_supprimer();
-		QAction *enr_fichier;
+	void slot_pivoter();
-		QAction *enr_fichier_sous;
+	void slot_setSelectionMode();
-		QAction *importer;
+	void slot_setVisualisationMode();
-		QAction *exporter;
+	void slot_updateActions();
-		QAction *imprimer;
+	void slot_updateMenuFenetres();
-		QAction *quitter_qet;
+	void slot_addColumn();
-		QAction *annuler;
+	void slot_removeColumn();
-		QAction *refaire;
+	void slot_expand();
-		QAction *couper;
+	void slot_shrink();
-		QAction *copier;
+	
-		QAction *coller;
+	// attributs
-		QAction *sel_tout;
+	protected:
-		QAction *sel_rien;
+	// Actions faisables au travers de menus dans l'application QElectroTech
-		QAction *sel_inverse;
+	QAction *mode_selection;
-		QAction *supprimer;
+	QAction *mode_visualise;
-		QAction *selectionner;
+	QAction *nouveau_fichier;
-		QAction *pivoter;
+	QAction *ouvrir_fichier;
-		QAction *infos_diagram;
+	QAction *fermer_fichier;
-		QAction *add_column;
+	QAction *enr_fichier;
-		QAction *remove_column;
+	QAction *enr_fichier_sous;
-		QAction *expand_diagram;
+	QAction *importer;
-		QAction *shrink_diagram;
+	QAction *exporter;
-		QAction *poser_fil;
+	QAction *imprimer;
-		QAction *reduce_appli;
+	QAction *quitter_qet;
-		QAction *restore_appli;
+	QAction *annuler;
-		QAction *zoom_avant;
+	QAction *refaire;
-		QAction *zoom_arriere;
+	QAction *couper;
-		QAction *zoom_adapte;
+	QAction *copier;
-		QAction *zoom_reset;
+	QAction *coller;
-		QAction *a_propos_de_qet;
+	QAction *sel_tout;
-		QAction *a_propos_de_qt;
+	QAction *sel_rien;
-		QAction *configurer;
+	QAction *sel_inverse;
-		QAction *entrer_pe;
+	QAction *supprimer;
-		QAction *sortir_pe;
+	QAction *selectionner;
-		QAction *f_mosaique;
+	QAction *pivoter;
-		QAction *f_cascade;
+	QAction *infos_diagram;
-		QAction *f_reorganise;
+	QAction *add_column;
-		QAction *f_prec;
+	QAction *remove_column;
-		QAction *f_suiv;
+	QAction *expand_diagram;
-		
+	QAction *shrink_diagram;
-		void actions();
+	QAction *poser_fil;
-		// menus variables
+	QAction *reduce_appli;
-		QAction *menu_systray_masquer_restaurer;
+	QAction *restore_appli;
-		
+	QAction *zoom_avant;
-		private:
+	QAction *zoom_arriere;
-		QWorkspace workspace;
+	QAction *zoom_adapte;
-		DiagramView *diagramEnCours();
+	QAction *zoom_reset;
-		QSignalMapper windowMapper;
+	QAction *a_propos_de_qet;
-		/// Dock pour le Panel d'Appareils
+	QAction *a_propos_de_qt;
-		QDockWidget *qdw_pa;
+	QAction *configurer;
-		/// Panel d'Appareils
+	QAction *entrer_pe;
-		ElementsPanelWidget *pa;
+	QAction *sortir_pe;
-		/// Elements de menus pour l'icone du systray
+	QAction *f_mosaique;
-		QMenu *menu_systray;
+	QAction *f_cascade;
-		QAction *systray_masquer;
+	QAction *f_reorganise;
-		QAction * config_fullscreen;
+	QAction *f_prec;
-		QMenu *menu_fenetres;
+	QAction *f_suiv;
-		/// Icone dans le systray
+	QAction *menu_systray_masquer_restaurer;
-		QSystemTrayIcon *qsti;
+	
-		/// Geometrie de la fenetre principale
+	private:
-		QByteArray wg;
+	QWorkspace workspace;
-		void menus();
+	QSignalMapper windowMapper;
-		void toolbar();
+	/// Dock pour le Panel d'Appareils
-		QToolBar *barre_outils;
+	QDockWidget *qdw_pa;
-	};
+	/// Panel d'Appareils
+	ElementsPanelWidget *pa;
+	/// Elements de menus pour l'icone du systray
+	QMenu *menu_systray;
+	QAction *systray_masquer;
+	QAction * config_fullscreen;
+	QMenu *menu_fenetres;
+	/// Icone dans le systray
+	QSystemTrayIcon *qsti;
+	/// Geometrie de la fenetre principale
+	QByteArray wg;
+	QToolBar *barre_outils;
+};
 #endif

terminal.cpp

@@ -77,8 +77,12 @@ Terminal::Terminal(qreal pf_x, qreal pf_y, Terminal::Orientation o, Element *e,
 
 /**
 	Destructeur
+	La destruction de la borne entraine la destruction des conducteurs
+	associes.
 */
 Terminal::~Terminal() {
+	//qDebug() << "Terminal::~Terminal" << (void *)this;
+	foreach(Conducer *c, liste_conducers) delete c;
 	delete br;
 }
 
@@ -139,6 +143,7 @@ bool Terminal::addConducer(Conducer *f) {
 	@param f Conducteur a enlever
 */
 void Terminal::removeConducer(Conducer *f) {
+	//qDebug() << "Terminal::removeConducer" << (void *)this;
 	int index = liste_conducers.indexOf(f);
 	if (index == -1) return;
 	liste_conducers.removeAt(index);
@@ -229,9 +234,9 @@ void Terminal::hoverLeaveEvent(QGraphicsSceneHoverEvent *) {
 */
 void Terminal::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	if (Diagram *s = qobject_cast<Diagram *>(scene())) {
-		s -> setDepart(mapToScene(QPointF(amarrage_conducer)));
+		s -> setConducerStart(mapToScene(QPointF(amarrage_conducer)));
-		s -> setArrivee(e -> scenePos());
+		s -> setConducerStop(e -> scenePos());
-		s -> poseConducer(true);
+		s -> setConducer(true);
 		setCursor(Qt::CrossCursor);
 	}
 }
@@ -253,7 +258,7 @@ void Terminal::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	}
 	
 	// si la scene est un Diagram, on actualise le poseur de conducteur
-	if (Diagram *s = qobject_cast<Diagram *>(scene())) s -> setArrivee(e -> scenePos());
+	if (Diagram *s = qobject_cast<Diagram *>(scene())) s -> setConducerStop(e -> scenePos());
 	
 	// on recupere la liste des qgi sous le pointeur
 	QList<QGraphicsItem *> qgis = scene() -> items(e -> scenePos());
@@ -315,7 +320,7 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	// verifie que la scene est bien un Diagram
 	if (Diagram *s = qobject_cast<Diagram *>(scene())) {
 		// on arrete de dessiner l'apercu du conducteur
-		s -> poseConducer(false);
+		s -> setConducer(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

terminal.h

@@ -4,28 +4,29 @@
 #include <QtGui>
 #include <QtXml>
 class Conducer;
-class Element;
 class Diagram;
+class Element;
 /**
 	Classe modelisant la « borne » d'un appareil, c'est-a-dire un
 	branchement possible pour un Conducteur.
 */
 class Terminal : public QGraphicsItem {
+	
+	// constructeurs, destructeur
 	public:
-	// enum definissant l'orientation de la borne
 	enum Orientation {Nord, Est, Sud, Ouest};
-	
-	// permet de caster un QGraphicsItem en Borne avec qgraphicsitem_cast
-	enum { Type = UserType + 1002 };
-	virtual int type() const { return Type; }
-	
-	// constructeurs
 	Terminal();
 	Terminal(QPointF,      Terminal::Orientation, Element * = 0, Diagram * = 0);
 	Terminal(qreal, qreal, Terminal::Orientation, Element * = 0, Diagram * = 0);
+	virtual ~Terminal();
 	
-	// destructeur
+	private:
-	~Terminal();
+	Terminal(const Terminal &);
+	
+	// methodes
+	public:
+	// permet de caster un QGraphicsItem en Borne avec qgraphicsitem_cast
+	virtual int type() const { return Type; }
 	
 	// implementation des methodes virtuelles pures de QGraphicsItem
 	void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
@@ -37,15 +38,15 @@ class Terminal : public QGraphicsItem {
 	int nbConducers() const;
 	
 	// methodes de lecture
-	QList<Conducer *> conducers() const; 
+	QList<Conducer *> conducers() const;
 	Terminal::Orientation orientation() const;
 	QPointF amarrageConducer() const;
 	void updateConducer(QPointF = QPointF());
 	
 	// methodes relatives a l'import/export au format XML
 	static bool valideXml(QDomElement  &);
-	bool        fromXml  (QDomElement  &);
+	bool fromXml (QDomElement &);
-	QDomElement toXml    (QDomDocument &) const;
+	QDomElement toXml (QDomDocument &) const;
 	
 	protected:
 	// methodes de gestion des evenements
@@ -56,6 +57,10 @@ class Terminal : public QGraphicsItem {
 	void mouseMoveEvent   (QGraphicsSceneMouseEvent *);
 	void mouseReleaseEvent(QGraphicsSceneMouseEvent *);
 	
+	// attributs
+	public:
+	enum { Type = UserType + 1002 };
+	
 	private:
 	// pointeur vers la QGraphicsScene de type Diagram (evite quelques casts en interne)
 	Diagram *diagram_scene;