Ajout de documentation

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

borderinset.h

@@ -42,27 +42,45 @@ class BorderInset : public QObject {
 	void draw(QPainter *, qreal = 0.0, qreal = 0.0);
 	
 	// methodes d'acces en lecture aux dimensions
+	/// @return le nombre de colonnes du schema
 	int     nbColumn()            const { return(nb_columns);                    }
+	/// @return la taille des colonnes en pixels
 	qreal   columnsWidth()        const { return(columns_width);                 }
+	/// @return la hauteur, en pixels, des en-tetes des colonnes
 	qreal   columnsHeaderHeight() const { return(columns_header_height);         }
+	/// @return la hauteur des colonnes, en-tetes inclus
 	qreal   columnsHeight()       const { return(columns_height);                }
+	/// @return la largeur de la bordure
 	qreal   borderWidth()         const { return(nb_columns * columns_width);    }
+	/// @return la hauteur de la bordure
 	qreal   borderHeight()        const { return(columns_height + inset_height); }
+	/// @return la largeur du cartouche
 	qreal   insetWidth()          const { return(inset_width);                   }
+	/// @return la hauteur du cartouche
 	qreal   insetHeight()         const { return(inset_height);                  }
+	/// @return la hauteur minimale acceptee des colonnes
 	qreal   minColumnsHeight()    const { return(min_columns_height);            }
+	/// @return le nombre minimum accepte de colonnes
 	int     minNbColumns()        const { return(min_nb_columns);                }
 	
 	// methodes d'acces en lecture aux informations du cartouche
+	/// @return le champ "Auteur" du cartouche
 	QString author()              const { return(bi_author);             }
+	/// @return le champ "Date" du cartouche
 	QDate   date()                const { return(bi_date);               }
+	/// @return le champ "Titre" du cartouche
 	QString title()               const { return(bi_title);              }
+	/// @return le champ "Folio" du cartouche
 	QString folio()               const { return(bi_folio);              }
+	/// @return le champ "Fichier" du cartouche
 	QString fileName()            const { return(bi_filename);           }
 	
 	// methodes d'acces en lecture aux options
+	/// @return true si le cartouche est affiche, false sinon
 	bool    insetIsDisplayed()    const { return(display_inset);         }
+	/// @return true si les entetes des colonnes sont affiches, false sinon
 	bool    columnsAreDisplayed() const { return(display_columns);       }
+	/// @return true si la bordure est affichee, false sinon
 	bool    borderIsDisplayed()   const { return(display_border);        }
 	
 	// methodes d'acces en ecriture aux dimensions
@@ -77,11 +95,18 @@ class BorderInset : public QObject {
 	void adjustInsetToColumns  ();
 	
 	// methodes d'acces en ecriture aux informations du cartouche
+	/// @param author le nouveau contenu du champ "Auteur"
 	void setAuthor             (const QString &author)   { bi_author       = author;   }
+	/// @param date le nouveau contenu du champ "Date"
 	void setDate               (const QDate   &date)     { bi_date         = date;     }
+	/// @param title le nouveau contenu du champ "Titre"
 	void setTitle              (const QString &title)    { bi_title        = title;    }
+	/// @param folio le nouveau contenu du champ "Folio"
 	void setFolio              (const QString &folio)    { bi_folio        = folio;    }
+	/// @param filename le nouveau contenu du champ "Fichier"
 	void setFileName           (const QString &filename) { bi_filename     = filename; }
+	
+	/// @return les proprietes du cartouches
 	InsetProperties exportInset() {
 		InsetProperties ip;
 		ip.author = bi_author;
@@ -91,6 +116,8 @@ class BorderInset : public QObject {
 		ip.filename = bi_filename;
 		return(ip);
 	}
+	
+	/// @param ip les nouvelles proprietes du cartouche
 	void importInset(const InsetProperties &ip) {
 		bi_author = ip.author;
 		bi_date = ip.date;
@@ -100,8 +127,11 @@ class BorderInset : public QObject {
 	}
 	
 	// methodes d'acces en ecriture aux options
+	/// @param di true pour afficher le cartouche, false sinon
 	void displayInset          (bool di)                 { display_inset   = di;       }
+	/// @param dc true pour afficher les entetes des colonnes, false sinon
 	void displayColumns        (bool dc)                 { display_columns = dc;       }
+	/// @param db true pour afficher la bordure du schema, false sinon
 	void displayBorder         (bool db)                 { display_border  = db;       }
 	
 	private:

customelement.cpp

@@ -194,7 +194,7 @@ int CustomElement::nbTerminals() const {
 /**
 	Dessine le composant sur le Diagram
 	@param qp Le QPainter a utiliser pour dessiner l'element
-	@param qsogi Les options graphiques
+	@param options Les options graphiques
 */
 void CustomElement::paint(QPainter *qp, const QStyleOptionGraphicsItem *) {
 	dessin.play(qp);
@@ -371,7 +371,7 @@ bool CustomElement::parsePolygon(QDomElement &e, QPainter &qp) {
 /**
 	Analyse un element XML suppose representer un texte. Si l'analyse
 	reussit, le texte est ajoute au dessin.
-	Le texte est defini par une position, une chaine de caract<EFBFBD>res et une
+	Le texte est defini par une position, une chaine de caracteres et une
 	taille.
 	@param e L'element XML a analyser
 	@param qp Le QPainter a utiliser pour dessiner l'element perso
@@ -400,7 +400,7 @@ bool CustomElement::parseText(QDomElement &e, QPainter &qp) {
 	l'utilisateur. Si l'analyse reussit, le champ est ajoute au dessin.
 	Le texte est defini par :
 		- une position
-		- une chaine de caract<EFBFBD>res facultative utilisee comme valeur par defaut
+		- une chaine de caracteres facultative utilisee comme valeur par defaut
 		- une taille
 		- le fait de subir les rotations de l'element ou non
 	@param e L'element XML a analyser

diagram.cpp

@@ -362,7 +362,7 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in
 	foreach (QDomElement e, QET::findInDomElement(root, "elements", "element")) {
 		if (!Element::valideXml(e)) continue;
 		
-		// cree un element dont le type correspond <EFBFBD> l'id type
+		// cree un element dont le type correspond a l'id type
 		QString type_id = e.attribute("type");
 		QString chemin_fichier = QETApp::realPath(type_id);
 		CustomElement *nvel_elmt = new CustomElement(chemin_fichier);

diagramcommands.cpp

@@ -61,8 +61,8 @@ void AddElementCommand::redo() {
 /**
 	Constructeur
 	@param dia Schema auquel on ajoute du texte
-	@param elmt Texte ajoute
-	@param p Position a laquelle le texte est ajoute
+	@param text Texte ajoute
+	@param pos Position a laquelle le texte est ajoute
 	@param parent QUndoCommand parent
 */
 AddTextCommand::AddTextCommand(Diagram *dia, DiagramTextItem *text, const QPointF &pos, QUndoCommand *parent) :
@@ -193,9 +193,7 @@ void DeleteElementsCommand::redo() {
 /**
 	Constructeur
 	@param dia Schema sur lequel on colle les elements et conducteurs
-	@param e Elements colles sur le schema
-	@param c Conducteurs colles sur le schema
-	@param t Textes colles sur le schema
+	@param c Contenu a coller sur le schema
 	@param parent QUndoCommand parent
 */
 PasteDiagramCommand::PasteDiagramCommand(
@@ -419,6 +417,7 @@ void RotateElementsCommand::redo() {
 	@param c Conducteur modifie
 	@param old_p ancien profil du conducteur
 	@param new_p nouveau profil du conducteur
+	@param path_t Trajectoire du trajet modifie
 	@param parent QUndoCommand parent
 */
 ChangeConductorCommand::ChangeConductorCommand(

editor/arceditor.cpp

@@ -18,6 +18,12 @@
 #include "arceditor.h"
 #include "partarc.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param arc L'arc a editer
+	@param parent le Widget parent
+*/
 ArcEditor::ArcEditor(QETElementEditor *editor, PartArc *arc, QWidget *parent) : ElementItemEditor(editor, parent) {
 	
 	part = arc;
@@ -51,9 +57,13 @@ ArcEditor::ArcEditor(QETElementEditor *editor, PartArc *arc, QWidget *parent) :
 	activeConnections(true);
 }
 
+/// Destructeur
 ArcEditor::~ArcEditor() {
 }
 
+/**
+	Met a jour l'arc a partir a partir des donnees du formulaire
+*/
 void ArcEditor::updateArc() {
 	part -> setProperty("x",          x -> text().toDouble());
 	part -> setProperty("y",          y -> text().toDouble());
@@ -63,13 +73,22 @@ void ArcEditor::updateArc() {
 	part -> setAngle(-angle -> value());
 }
 
+/// Met a jour l'abscisse du centre de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcX() { addChangePartCommand(tr("abscisse"),               part, "x",           x -> text().toDouble());       }
+/// Met a jour l'ordonnee du centre de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcY() { addChangePartCommand(tr("ordonn\351e"),            part, "y",           y -> text().toDouble());       }
+/// Met a jour le diametre horizontal de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcH() { addChangePartCommand(tr("diam\350tre horizontal"), part, "diameter_h",  h -> text().toDouble());       }
+/// Met a jour le diametre vertical de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcV() { addChangePartCommand(tr("diam\350tre vertical"),   part, "diameter_v",  v -> text().toDouble());       }
+/// Met a jour l'angle de depart de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcS() { addChangePartCommand(tr("angle de d\351part"),     part, "start_angle", -start_angle -> value() + 90); }
+/// Met a jour l'etendue de l'arc et cree un objet d'annulation
 void ArcEditor::updateArcA() { addChangePartCommand(tr("angle"),                  part, "angle",       -angle -> value());            }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void ArcEditor::updateForm() {
 	activeConnections(false);
 	x -> setText(part -> property("x").toString());
@@ -81,6 +100,10 @@ void ArcEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void ArcEditor::activeConnections(bool active) {
 	if (active) {
 		connect(x,           SIGNAL(editingFinished()), this, SLOT(updateArcX()));

editor/circleeditor.cpp

@@ -18,6 +18,12 @@
 #include "circleeditor.h"
 #include "partcircle.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param circle Le cercle a editer
+	@param parent le Widget parent
+*/
 CircleEditor::CircleEditor(QETElementEditor *editor, PartCircle *circle, QWidget *parent) : ElementItemEditor(editor, parent) {
 	
 	part = circle;
@@ -45,19 +51,31 @@ CircleEditor::CircleEditor(QETElementEditor *editor, PartCircle *circle, QWidget
 	updateForm();
 }
 
+/// Destructeur
 CircleEditor::~CircleEditor() {
 }
 
+/**
+	met a jour le cercle a partir des donnees du formulaire
+*/
 void CircleEditor::updateCircle() {
 	part -> setProperty("x", x -> text().toDouble());
 	part -> setProperty("y", y -> text().toDouble());
 	part -> setProperty("diameter", r -> text().toDouble());
 }
 
+/// Met a jour l'abscisse du cercle et cree un objet d'annulation
 void CircleEditor::updateCircleX() { addChangePartCommand(tr("abscisse"),    part, "x",        x -> text().toDouble()); }
+
+/// Met a jour l'ordonnee du cercle et cree un objet d'annulation
 void CircleEditor::updateCircleY() { addChangePartCommand(tr("ordonn\351e"), part, "y",        y -> text().toDouble()); }
+
+/// Met a jour le diametre du cercle et cree un objet d'annulation
 void CircleEditor::updateCircleD() { addChangePartCommand(tr("diam\350tre"), part, "diameter", r -> text().toDouble()); }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void CircleEditor::updateForm() {
 	activeConnections(false);
 	x -> setText(part -> property("x").toString());
@@ -66,6 +84,10 @@ void CircleEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void CircleEditor::activeConnections(bool active) {
 	if (active) {
 		connect(x, SIGNAL(editingFinished()), this, SLOT(updateCircleX()));

editor/customelementgraphicpart.cpp

@@ -149,6 +149,16 @@ QWidget *CustomElementGraphicPart::elementInformations() {
 	return(style_editor);
 }
 
+/**
+	Specifie la valeur d'une propriete de style donnee.
+	@param property propriete a modifier. Valeurs acceptees :
+		* line-style : type de trait (@see LineStyle)
+		* line-weight : epaisseur du traut (@see LineWeight)
+		* filling : couleur de remplissage (@see Color)
+		* color : couleur du trait (@see Color)
+		* antialias : utiliser l'antialiasing ou non (booleen)
+	@param value Valeur a attribuer a la propriete
+*/
 void CustomElementGraphicPart::setProperty(const QString &property, const QVariant &value) {
 	bool change_made = false;
 	if (property == "line-style") {
@@ -172,6 +182,16 @@ void CustomElementGraphicPart::setProperty(const QString &property, const QVaria
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete de style donnee.
+	@param property propriete lue. Valeurs acceptees :
+		* line-style : type de trait (@see LineStyle)
+		* line-weight : epaisseur du traut (@see LineWeight)
+		* filling : couleur de remplissage (@see Color)
+		* color : couleur du trait (@see Color)
+		* antialias : utiliser l'antialiasing ou non (booleen)
+	@return La valeur de la propriete property
+*/
 QVariant CustomElementGraphicPart::property(const QString &property) {
 	if (property == "line-style") {
 		return(lineStyle());

editor/editorcommands.cpp

@@ -322,7 +322,7 @@ void ChangeNamesCommand::redo() {
 	Constructeur
 	@param element_scene Element edite
 	@param before Orientations avant changement
-	@param after Orientationss apres changement
+	@param after Orientations apres changement
 	@param parent QUndoCommand parent
 */
 ChangeOrientationsCommand::ChangeOrientationsCommand(

editor/elementscene.cpp

@@ -32,6 +32,11 @@
 const int ElementScene::xGrid = 10;
 const int ElementScene::yGrid = 10;
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent le Widget parent
+*/
 ElementScene::ElementScene(QETElementEditor *editor, QObject *parent) :
 	QGraphicsScene(parent),
 	_width(3),
@@ -45,45 +50,79 @@ ElementScene::ElementScene(QETElementEditor *editor, QObject *parent) :
 	connect(this, SIGNAL(changed(const QList<QRectF> &)), this, SLOT(slot_checkSelectionChanged()));
 }
 
+/// Destructeur
 ElementScene::~ElementScene() {
 }
 
+/**
+	Passe la scene en mode "selection et deplacement de parties"
+*/
 void ElementScene::slot_move() {
 	behavior = Normal;
 }
 
+/**
+	Passe la scene en mode "ajout de ligne"
+*/
 void ElementScene::slot_addLine() {
 	behavior = Line;
 }
 
+/**
+	Passe la scene en mode "ajout de cercle"
+*/
 void ElementScene::slot_addCircle() {
 	behavior = Circle;
 }
 
+/**
+	Passe la scene en mode "ajout d'ellipse"
+*/
 void ElementScene::slot_addEllipse() {
 	behavior = Ellipse;
 }
 
+/**
+	Passe la scene en mode "ajout de polygone"
+*/
 void ElementScene::slot_addPolygon() {
 	behavior = Polygon;
 }
 
+
+/**
+	Passe la scene en mode "ajout de texte statique"
+*/
 void ElementScene::slot_addText() {
 	behavior = Text;
 }
 
+/**
+	Passe la scene en mode "ajout de borne"
+*/
 void ElementScene::slot_addTerminal() {
 	behavior = Terminal;
 }
 
+
+/**
+	Passe la scene en mode "ajout d'arc de cercle"
+*/
 void ElementScene::slot_addArc() {
 	behavior = Arc;
 }
 
+/**
+	Passe la scene en mode "ajout de champ de texte"
+*/
 void ElementScene::slot_addTextField() {
 	behavior = TextField;
 }
 
+/**
+	Gere les mouvements de la souris
+	@param e objet decrivant l'evenement
+*/
 void ElementScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	if (behavior != Polygon && current_polygon != NULL) current_polygon = NULL;
 	QRectF temp_rect;
@@ -134,6 +173,10 @@ void ElementScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
 	} else QGraphicsScene::mouseMoveEvent(e);
 }
 
+/**
+	Gere les appuis sur les boutons de la souris
+	@param e objet decrivant l'evenement
+*/
 void ElementScene::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	if (behavior != Polygon && current_polygon != NULL) current_polygon = NULL;
 	QPolygonF temp_polygon;
@@ -176,6 +219,10 @@ void ElementScene::mousePressEvent(QGraphicsSceneMouseEvent *e) {
 	} else QGraphicsScene::mousePressEvent(e);
 }
 
+/**
+	Gere les relachements de boutons de la souris
+	@param e objet decrivant l'evenement
+*/
 void ElementScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
 	PartTerminal *terminal;
 	PartText *text;
@@ -307,6 +354,10 @@ void ElementScene::drawForeground(QPainter *p, const QRectF &) {
 	p -> restore();
 }
 
+/**
+	Exporte l'element en XML
+	@return un document XML decrivant l'element
+*/
 const QDomDocument ElementScene::toXml() const {
 	// document XML
 	QDomDocument xml_document;
@@ -337,6 +388,10 @@ const QDomDocument ElementScene::toXml() const {
 	return(xml_document);
 }
 
+/**
+	Lit un element depuis un document XML
+	@param xml_document un document XML decrivant l'element
+*/
 void ElementScene::fromXml(const QDomDocument &xml_document) {
 	
 	QString error_message;
@@ -411,18 +466,31 @@ void ElementScene::fromXml(const QDomDocument &xml_document) {
 	}
 }
 
+/**
+	@return un rectangle englobant toutes les parties ainsi que le
+	"bounding rect" de l'element
+*/
 QRectF ElementScene::sceneContent() const {
 	return(itemsBoundingRect().unite(QRectF(-_hotspot, QSizeF(width(), height()))));
 }
 
+/**
+	@return la pile d'annulations de cet editeur d'element
+*/
 QUndoStack &ElementScene::undoStack() {
 	return(undo_stack);
 }
 
+/**
+	@return le gestionnaire de QGraphicsItem de cet editeur d'element
+*/
 QGIManager &ElementScene::qgiManager() {
 	return(qgi_manager);
 }
 
+/**
+	Detecte les changements de selection
+*/
 void ElementScene::slot_checkSelectionChanged() {
 	static QList<QGraphicsItem *> cache_selecteditems = QList<QGraphicsItem *>();
 	QList<QGraphicsItem *> selecteditems = selectedItems();
@@ -430,18 +498,30 @@ void ElementScene::slot_checkSelectionChanged() {
 	cache_selecteditems = selecteditems;
 }
 
+/**
+	Selectionne tout
+*/
 void ElementScene::slot_selectAll() {
 	foreach(QGraphicsItem *qgi, items()) qgi -> setSelected(true);
 }
 
+/**
+	Deselectionne tout
+*/
 void ElementScene::slot_deselectAll() {
 	clearSelection();
 }
 
+/**
+	Inverse la selection
+*/
 void ElementScene::slot_invertSelection() {
 	foreach(QGraphicsItem *qgi, items()) qgi -> setSelected(!qgi -> isSelected());
 }
 
+/**
+	Supprime les elements selectionnes
+*/
 void ElementScene::slot_delete() {
 	// verifie qu'il y a qqc de selectionne
 	QList<QGraphicsItem *> selected_items = selectedItems();
@@ -452,6 +532,10 @@ void ElementScene::slot_delete() {
 	emit(partsRemoved());
 }
 
+/**
+	Lance un dialogue pour editer les dimensions et le point de saisie
+	(hotspot) de l'element.
+*/
 void ElementScene::slot_editSizeHotSpot() {
 	// cree un dialogue
 	QDialog dialog_sh;
@@ -488,6 +572,9 @@ void ElementScene::slot_editSizeHotSpot() {
 	}
 }
 
+/**
+	Lance un dialogue pour editer les noms de cete element
+*/
 void ElementScene::slot_editOrientations() {
 	
 	// cree un dialogue
@@ -523,6 +610,9 @@ void ElementScene::slot_editOrientations() {
 	}
 }
 
+/**
+	Lance un dialogue pour editer les noms de cet element
+*/
 void ElementScene::slot_editNames() {
 	
 	// cree un dialogue

editor/elementscene.h

@@ -137,46 +137,76 @@ class ElementScene : public QGraphicsScene {
 	void partsZValueChanged();
 };
 
+/**
+	@param wid Nouvelle largeur de l'element edite
+*/
 inline void ElementScene::setWidth(const uint &wid) {
 	_width = wid;
 	while (_width % 10) ++ _width;
 	_width /= 10;
 }
 
+/**
+	@return la largeur de l'element edite
+*/
 inline uint ElementScene::width() const {
 	return(_width * 10);
 }
 
+/**
+	@param wid Nouvelle hauteur de l'element edite
+*/
 inline void ElementScene::setHeight(const uint &hei) {
 	_height = hei;
 	while (_height % 10) ++ _height;
 	_height /= 10;
 }
 
+/**
+	@return la largeur de l'element edite
+*/
 inline uint ElementScene::height() const {
 	return(_height * 10);
 }
 
+/**
+	@param hs Nouveau point de saisie de l'element edite
+*/
 inline void ElementScene::setHotspot(const QPoint &hs) {
 	_hotspot = hs;
 }
 
+/**
+	@return le point de saisie de l'element edite
+*/
 inline QPoint ElementScene::hotspot() const {
 	return(_hotspot);
 }
 
+/**
+	@param hs Nouvel ensemble de noms de l'element edite
+*/
 inline void ElementScene::setNames(const NamesList nameslist) {
 	_names = nameslist;
 }
 
+/**
+	@return l'ensemble de noms de l'element edite
+*/
 inline NamesList ElementScene::names() const {
 	return(_names);
 }
 
+/**
+	@return l'ensemble d'orientations de l'element edite
+*/
 inline OrientationSet ElementScene::orientations() {
 	return(ori);
 }
 
+/**
+	@param orientation_set Nouvel ensemble d'orientations de l'element edite
+*/
 inline void ElementScene::setOrientations(const OrientationSet &orientation_set) {
 	ori = orientation_set;
 }

editor/elementview.cpp

@@ -51,6 +51,12 @@ void ElementView::setScene(ElementScene *s) {
 	scene_ = s;
 }
 
+/**
+	Gere les evenements envoyes a la vue.
+	Methode reimplentee pour gerer le conflit de raccourcis avec Suppr
+	(supprimer une partie ou supprimer le caractere suivant)
+	@param e evenement a gerer
+*/
 bool ElementView::event(QEvent *e) {
 	if (e -> type() == QEvent::ShortcutOverride && scene_ -> focusItem()) {
 		e -> accept();

editor/ellipseeditor.cpp

@@ -18,6 +18,12 @@
 #include "ellipseeditor.h"
 #include "partellipse.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param ellipse L'ellipse a editer
+	@param parent le Widget parent
+*/
 EllipseEditor::EllipseEditor(QETElementEditor *editor, PartEllipse *ellipse, QWidget *parent) : ElementItemEditor(editor, parent) {
 	
 	part = ellipse;
@@ -50,9 +56,13 @@ EllipseEditor::EllipseEditor(QETElementEditor *editor, PartEllipse *ellipse, QWi
 	updateForm();
 }
 
+/// Destructeur
 EllipseEditor::~EllipseEditor() {
 }
 
+/**
+	Met a jour l'ellipse a partir des donnees du formulaire
+*/
 void EllipseEditor::updateEllipse() {
 	part -> setProperty("x", x -> text().toDouble());
 	part -> setProperty("y", x -> text().toDouble());
@@ -60,11 +70,18 @@ void EllipseEditor::updateEllipse() {
 	part -> setProperty("diameter_v", x -> text().toDouble());
 }
 
+/// Met a jour l'abscisse du centre de l'ellipse et cree un objet d'annulation
 void EllipseEditor::updateEllipseX() { addChangePartCommand(tr("abscisse"),               part, "x",           x -> text().toDouble());       }
+/// Met a jour l'ordonnee du centre de l'ellipse et cree un objet d'annulation
 void EllipseEditor::updateEllipseY() { addChangePartCommand(tr("ordonn\351e"),            part, "y",           y -> text().toDouble());       }
+/// Met a jour le diametre horizontal de l'ellipse et cree un objet d'annulation
 void EllipseEditor::updateEllipseH() { addChangePartCommand(tr("diam\350tre horizontal"), part, "diameter_h",  h -> text().toDouble());       }
+/// Met a jour le diametre vertical de l'ellipse et cree un objet d'annulation
 void EllipseEditor::updateEllipseV() { addChangePartCommand(tr("diam\350tre vertical"),   part, "diameter_v",  v -> text().toDouble());       }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void EllipseEditor::updateForm() {
 	activeConnections(false);
 	x -> setText(part -> property("x").toString());
@@ -74,6 +91,10 @@ void EllipseEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void EllipseEditor::activeConnections(bool active) {
 	if (active) {
 		connect(x, SIGNAL(editingFinished()), this, SLOT(updateEllipseX()));

editor/lineeditor.cpp

@@ -18,6 +18,12 @@
 #include "lineeditor.h"
 #include "partline.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param line La ligne a editer
+	@param parent le Widget parent
+*/
 LineEditor::LineEditor(QETElementEditor *editor, PartLine *line, QWidget *parent) : ElementItemEditor(editor, parent) {
 	
 	part = line;
@@ -40,9 +46,13 @@ LineEditor::LineEditor(QETElementEditor *editor, PartLine *line, QWidget *parent
 	updateForm();
 }
 
+/// Destructeur
 LineEditor::~LineEditor() {
 }
 
+/**
+	Met a jour la ligne a partir des donnees du formulaire
+*/
 void LineEditor::updateLine() {
 	part -> setLine(
 		QLineF(
@@ -58,11 +68,18 @@ void LineEditor::updateLine() {
 	);
 }
 
+/// Met a jour l'abscisse du premier point de la ligne et cree un objet d'annulation
 void LineEditor::updateLineX1() { addChangePartCommand(tr("abscisse point 1"),    part, "x1", x1 -> text().toDouble()); }
+/// Met a jour l'ordonnee du premier point de la ligne et cree un objet d'annulation
 void LineEditor::updateLineY1() { addChangePartCommand(tr("ordonn\351e point 1"), part, "y1", y1 -> text().toDouble()); }
+/// Met a jour l'abscisse du second point de la ligne et cree un objet d'annulation
 void LineEditor::updateLineX2() { addChangePartCommand(tr("abscisse point 2"),    part, "x2", x2 -> text().toDouble()); }
+/// Met a jour l'ordonnee du second point de la ligne et cree un objet d'annulation
 void LineEditor::updateLineY2() { addChangePartCommand(tr("ordonn\351e point 2"), part, "y2", y2 -> text().toDouble()); }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void LineEditor::updateForm() {
 	activeConnections(false);
 	QPointF p1(part -> sceneP1());
@@ -74,6 +91,10 @@ void LineEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void LineEditor::activeConnections(bool active) {
 	if (active) {
 		connect(x1, SIGNAL(editingFinished()), this, SLOT(updateLineX1()));

editor/partarc.cpp

@@ -18,6 +18,12 @@
 #include "partarc.h"
 #include "arceditor.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de cet arc
+	@param scene La scene sur laquelle figure cet arc
+*/
 PartArc::PartArc(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) :
 	QGraphicsEllipseItem(parent, scene),
 	CustomElementGraphicPart(editor),
@@ -32,6 +38,16 @@ PartArc::PartArc(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene
 	style_editor -> setElementTypeName(name());
 }
 
+/// Destructeur
+PartArc::~PartArc() {
+}
+
+/**
+	Dessine l'arc de cercle
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
 void PartArc::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) {
 	applyStylesToQPainter(*painter);
 	// enleve systematiquement la couleur de fond
@@ -56,6 +72,11 @@ void PartArc::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget
 	}
 }
 
+/**
+	Exporte l'arc de cercle en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant l'arc de cercle
+*/
 const QDomElement PartArc::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("arc");
 	QPointF top_left(sceneTopLeft());
@@ -69,6 +90,10 @@ const QDomElement PartArc::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	Importe les proprietes d'un arc de cercle depuis un element XML
+	@param qde Element XML a lire
+*/
 void PartArc::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
 	setRect(
@@ -87,10 +112,25 @@ void PartArc::fromXml(const QDomElement &qde) {
 	setAngle(qde.attribute("angle", "-90").toInt());
 }
 
+/**
+	@return le coin superieur gauche du rectangle dans lequel s'inscrit
+	l'ellipse dont fait partie cet arc, dans les coordonnees de la scene.
+*/
 QPointF PartArc::sceneTopLeft() const {
 	return(mapToScene(rect().topLeft()));
 }
 
+/**
+	Specifie la valeur d'une propriete donnee de l'arc
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse du centre de l'ellipse dont fait partie l'arc
+		* y : ordonnee du centre de l'ellipse dont fait partie l'arc
+		* diameter_h : diametre horizontal de l'ellipse dont fait partie l'arc
+		* diameter_v : diametre vertical de l'ellipse dont fait partie l'arc
+		* start_angle : angle de depart
+		* angle : taille de l'arc de cercle
+	@param value Valeur a attribuer a la propriete
+*/
 void PartArc::setProperty(const QString &property, const QVariant &value) {
 	CustomElementGraphicPart::setProperty(property, value);
 	if (!value.canConvert(QVariant::Double)) return;
@@ -121,6 +161,17 @@ void PartArc::setProperty(const QString &property, const QVariant &value) {
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee de l'arc de cercle
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse du centre de l'ellipse dont fait partie l'arc
+		* y : ordonnee du centre de l'ellipse dont fait partie l'arc
+		* diameter_h : diametre horizontal de l'ellipse dont fait partie l'arc
+		* diameter_v : diametre vertical de l'ellipse dont fait partie l'arc
+		* start_angle : angle de depart
+		* angle : taille de l'arc de cercle
+	@return La valeur de la propriete property
+*/
 QVariant PartArc::property(const QString &property) {
 	// appelle la methode property de CustomElementGraphicpart pour les styles
 	QVariant style_property = CustomElementGraphicPart::property(property);
@@ -142,6 +193,11 @@ QVariant PartArc::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartArc::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -151,18 +207,37 @@ QVariant PartArc::itemChange(GraphicsItemChange change, const QVariant &value) {
 	return(QGraphicsEllipseItem::itemChange(change, value));
 }
 
+/**
+	Permet de modifier l'etendue de l'arc de cercle.
+	Il s'agit d'un angle, exprime en degres.
+	Si l'angle est positif, l'arc s'etendra dans le sens des aiguilles d'une
+	montre.
+	@param a la nouvelle taille de l'arc de cercle
+*/
 void PartArc::setAngle(int a) {
 	_angle = a;
 }
 
+/**
+	Permet de modifier la position de depart de l'arc de cercle.
+	Il s'agit d'un angle, exprime en degres.
+	l'angle "0 degre" est situe a "3 heures".
+	@param a la nouvelle taille de l'arc de cercle
+*/
 void PartArc::setStartAngle(int a) {
 	start_angle = a;
 }
 
+/**
+	@return l'etendue de l'arc de cercle
+*/
 int PartArc::angle() const {
 	return(_angle);
 }
 
+/**
+	@return la position de depart de l'arc de cercle
+*/
 int PartArc::startAngle() const {
 	return(start_angle);
 }

editor/partarc.h

@@ -28,7 +28,7 @@ class PartArc : public QGraphicsEllipseItem, public CustomElementGraphicPart {
 	// constructeurs, destructeur
 	public:
 	PartArc(QETElementEditor *, QGraphicsItem * = 0, QGraphicsScene * = 0);
-	virtual ~PartArc() {}
+	virtual ~PartArc();
 	
 	private:
 	PartArc(const PartArc &);

editor/partcircle.cpp

@@ -18,6 +18,12 @@
 #include "partcircle.h"
 #include "circleeditor.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de ce cercle
+	@param scene La scene sur laquelle figure ce cercle
+*/
 PartCircle::PartCircle(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) : QGraphicsEllipseItem(parent, scene), CustomElementGraphicPart(editor) {
 	setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 	setAcceptedMouseButtons(Qt::LeftButton);
@@ -27,6 +33,16 @@ PartCircle::PartCircle(QETElementEditor *editor, QGraphicsItem *parent, QGraphic
 	style_editor -> setElementTypeName(name());
 }
 
+/// Destructeur
+PartCircle::~PartCircle() {
+}
+
+/**
+	Dessine le cercle
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
 void PartCircle::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) {
 	applyStylesToQPainter(*painter);
 	QPen t = painter -> pen();
@@ -44,6 +60,11 @@ void PartCircle::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWid
 	}
 }
 
+/**
+	Exporte le cercle en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant le cercle
+*/
 const QDomElement PartCircle::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("circle");
 	QPointF top_left(sceneTopLeft());
@@ -54,6 +75,10 @@ const QDomElement PartCircle::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	Importe les proprietes d'un cercle depuis un element XML
+	@param qde Element XML a lire
+*/
 void PartCircle::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
 	qreal diameter = qde.attribute("diameter",  "0").toDouble();
@@ -71,6 +96,14 @@ void PartCircle::fromXml(const QDomElement &qde) {
 	);
 }
 
+/**
+	Specifie la valeur d'une propriete donnee du cercle
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse du centre du cercle
+		* y : ordonnee du centre du cercle
+		* diameter : diametre du cercle
+	@param value Valeur a attribuer a la propriete
+*/
 void PartCircle::setProperty(const QString &property, const QVariant &value) {
 	CustomElementGraphicPart::setProperty(property, value);
 	if (!value.canConvert(QVariant::Double)) return;
@@ -94,6 +127,14 @@ void PartCircle::setProperty(const QString &property, const QVariant &value) {
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete de style donnee.
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse du centre du cercle
+		* y : ordonnee du centre du cercle
+		* diameter : diametre du cercle
+	@return La valeur de la propriete property
+*/
 QVariant PartCircle::property(const QString &property) {
 	// appelle la methode property de CustomElementGraphicpart pour les styles
 	QVariant style_property = CustomElementGraphicPart::property(property);
@@ -109,6 +150,11 @@ QVariant PartCircle::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartCircle::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -118,14 +164,24 @@ QVariant PartCircle::itemChange(GraphicsItemChange change, const QVariant &value
 	return(QGraphicsEllipseItem::itemChange(change, value));
 }
 
+/**
+	@return le coin superieur gauche du rectangle dans lequel s'inscrit
+	le cercle, dans les coordonnees de la scene.
+*/
 QPointF PartCircle::sceneTopLeft() const {
 	return(mapToScene(rect().topLeft()));
 }
 
+/**
+	@return le centre du cercle, dans les coordonnees de la scene.
+*/
 QPointF PartCircle::sceneCenter() const {
 	return(mapToScene(rect().center()));
 }
 
+/**
+	@return le rectangle delimitant cette partie.
+*/
 QRectF PartCircle::boundingRect() const {
 	qreal adjust = 1.5;
 	QRectF r(QGraphicsEllipseItem::boundingRect());

editor/partcircle.h

@@ -28,7 +28,7 @@ class PartCircle : public QGraphicsEllipseItem, public CustomElementGraphicPart
 	// constructeurs, destructeur
 	public:
 	PartCircle(QETElementEditor *, QGraphicsItem * = 0, QGraphicsScene * = 0);
-	virtual ~PartCircle() {}
+	virtual ~PartCircle();
 	
 	private:
 	PartCircle(const PartCircle &);

editor/partellipse.cpp

@@ -18,6 +18,12 @@
 #include "partellipse.h"
 #include "ellipseeditor.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de cette ellipse
+	@param scene La scene sur laquelle figure cette ellipse
+*/
 PartEllipse::PartEllipse(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) : QGraphicsEllipseItem(parent, scene), CustomElementGraphicPart(editor) {
 	setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 	setAcceptedMouseButtons(Qt::LeftButton);
@@ -27,6 +33,16 @@ PartEllipse::PartEllipse(QETElementEditor *editor, QGraphicsItem *parent, QGraph
 	style_editor -> setElementTypeName(name());
 }
 
+/// Destructeur
+PartEllipse::~PartEllipse() {
+}
+
+/**
+	Dessine l'ellipse
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
 void PartEllipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) {
 	applyStylesToQPainter(*painter);
 	QPen t = painter -> pen();
@@ -44,6 +60,11 @@ void PartEllipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWi
 	}
 }
 
+/**
+	Exporte l'ellipse en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant l'ellipse
+*/
 const QDomElement PartEllipse::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("ellipse");
 	QPointF top_left(sceneTopLeft());
@@ -55,6 +76,10 @@ const QDomElement PartEllipse::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	Importe les proprietes d'une ellipse depuis un element XML
+	@param qde Element XML a lire
+*/
 void PartEllipse::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
 	setRect(
@@ -71,6 +96,15 @@ void PartEllipse::fromXml(const QDomElement &qde) {
 	);
 }
 
+/**
+	Specifie la valeur d'une propriete donnee de l'ellipse
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse du centre de l'ellipse
+		* y : ordonnee du centre de l'ellipse
+		* diameter_h : diametre horizontal de l'ellipse
+		* diameter_v : diametre vertical de l'ellipse
+	@param value Valeur a attribuer a la propriete
+*/
 void PartEllipse::setProperty(const QString &property, const QVariant &value) {
 	CustomElementGraphicPart::setProperty(property, value);
 	if (!value.canConvert(QVariant::Double)) return;
@@ -97,6 +131,15 @@ void PartEllipse::setProperty(const QString &property, const QVariant &value) {
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee de l'ellipse
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse du centre de l'ellipse
+		* y : ordonnee du centre de l'ellipse
+		* diameter_h : diametre horizontal de l'ellipse
+		* diameter_v : diametre vertical de l'ellipse
+	@return La valeur de la propriete property
+*/
 QVariant PartEllipse::property(const QString &property) {
 	// appelle la methode property de CustomElementGraphicpart pour les styles
 	QVariant style_property = CustomElementGraphicPart::property(property);
@@ -114,6 +157,11 @@ QVariant PartEllipse::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartEllipse::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -123,6 +171,10 @@ QVariant PartEllipse::itemChange(GraphicsItemChange change, const QVariant &valu
 	return(QGraphicsEllipseItem::itemChange(change, value));
 }
 
+/**
+	@return le coin superieur gauche du rectangle dans lequel s'inscrit
+	l'ellipse, dans les coordonnees de la scene.
+*/
 QPointF PartEllipse::sceneTopLeft() const {
 	return(mapToScene(rect().topLeft()));
 }

editor/partellipse.h

@@ -28,7 +28,7 @@ class PartEllipse : public QGraphicsEllipseItem, public CustomElementGraphicPart
 	// constructeurs, destructeur
 	public:
 	PartEllipse(QETElementEditor *, QGraphicsItem * = 0, QGraphicsScene * = 0);
-	virtual ~PartEllipse() {}
+	virtual ~PartEllipse();
 	
 	private:
 	PartEllipse(const PartEllipse &);

editor/partline.cpp

@@ -19,6 +19,12 @@
 #include "lineeditor.h"
 #include <cmath>
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de cette ligne
+	@param scene La scene sur laquelle figure cette ligne
+*/
 PartLine::PartLine(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) : QGraphicsLineItem(parent, scene), CustomElementGraphicPart(editor) {
 	setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 	setAcceptedMouseButtons(Qt::LeftButton);
@@ -28,6 +34,16 @@ PartLine::PartLine(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsSce
 	style_editor -> setElementTypeName(name());
 }
 
+/// Destructeur
+PartLine::~PartLine() {
+}
+
+/**
+	Dessine la ligne
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
 void PartLine::paint(QPainter *painter, const QStyleOptionGraphicsItem */*q*/, QWidget */*w*/) {
 	applyStylesToQPainter(*painter);
 	QPen t = painter -> pen();
@@ -39,6 +55,11 @@ void PartLine::paint(QPainter *painter, const QStyleOptionGraphicsItem */*q*/, Q
 	painter -> drawLine(line());
 }
 
+/**
+	Exporte la ligne en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant la ligne
+*/
 const QDomElement PartLine::toXml(QDomDocument &xml_document) const {
 	
 	QPointF p1(sceneP1());
@@ -59,6 +80,10 @@ const QDomElement PartLine::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	Importe les proprietes d'une ligne depuis un element XML
+	@param qde Element XML a lire
+*/
 void PartLine::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
 	setLine(
@@ -75,6 +100,15 @@ void PartLine::fromXml(const QDomElement &qde) {
 	);
 }
 
+/**
+	Specifie la valeur d'une propriete donnee de la ligne
+	@param property propriete a modifier. Valeurs acceptees :
+		* x1 : abscisse du premier point
+		* y1 : ordonnee du second point
+		* x2 : abscisse du premier point
+		* y2 : ordonnee du second point
+	@param value Valeur a attribuer a la propriete
+*/
 void PartLine::setProperty(const QString &property, const QVariant &value) {
 	CustomElementGraphicPart::setProperty(property, value);
 	if (!value.canConvert(QVariant::Double)) return;
@@ -92,6 +126,15 @@ void PartLine::setProperty(const QString &property, const QVariant &value) {
 	setLine(QLineF(mapFromScene(new_p1), mapFromScene(new_p2)));
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee de la ligne
+	@param property propriete lue. Valeurs acceptees :
+		* x1 : abscisse du premier point
+		* y1 : ordonnee du second point
+		* x2 : abscisse du premier point
+		* y2 : ordonnee du second point
+	@return La valeur de la propriete property
+*/
 QVariant PartLine::property(const QString &property) {
 	// appelle la methode property de CustomElementGraphicpart pour les styles
 	QVariant style_property = CustomElementGraphicPart::property(property);
@@ -109,6 +152,11 @@ QVariant PartLine::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartLine::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -118,14 +166,23 @@ QVariant PartLine::itemChange(GraphicsItemChange change, const QVariant &value)
 	return(QGraphicsLineItem::itemChange(change, value));
 }
 
+/**
+	@return le premier point, dans les coordonnees de la scene.
+*/
 QPointF PartLine::sceneP1() const {
 	return(mapToScene(line().p1()));
 }
 
+/**
+	@return le second point, dans les coordonnees de la scene.
+*/
 QPointF PartLine::sceneP2() const {
 	return(mapToScene(line().p2()));
 }
 
+/**
+	@return la forme selectionnable de la ligne
+*/
 QPainterPath PartLine::shape() const {
 	QList<QPointF> points = fourShapePoints();
 	QPainterPath t;
@@ -168,7 +225,7 @@ QList<QPointF> PartLine::fourShapePoints() const {
 		// laisser
 		QPointF u = v_ab / ab * marge;
 		
-		// on d<EFBFBD>finit le vecteur v(-b , a)  qui est perpendiculaire <EFBFBD> AB
+		// on definit le vecteur v(-b , a) qui est perpendiculaire a AB
 		QPointF v(-u.y(), u.x());
 		QPointF m = -u + v; // on a le vecteur M = -u + v
 		QPointF n = -u - v; // et le vecteur N=-u-v
@@ -182,6 +239,9 @@ QList<QPointF> PartLine::fourShapePoints() const {
 	return(result);
 }
 
+/**
+	@return le rectangle delimitant cette partie.
+*/
 QRectF PartLine::boundingRect() const {
 	qreal adjust = 1.5;
 	QRectF r(QGraphicsLineItem::boundingRect());

editor/partline.h

@@ -28,7 +28,7 @@ class PartLine : public QGraphicsLineItem, public CustomElementGraphicPart {
 	// constructeurs, destructeur
 	public:
 	PartLine(QETElementEditor *, QGraphicsItem * = 0, QGraphicsScene * = 0);
-	virtual ~PartLine() {}
+	virtual ~PartLine();
 	
 	private:
 	PartLine(const PartLine &);

editor/partpolygon.cpp

@@ -18,6 +18,13 @@
 #include "partpolygon.h"
 #include "qet.h"
 #include "polygoneditor.h"
+
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de ce polygone
+	@param scene La scene sur laquelle figure ce polygone
+*/
 PartPolygon::PartPolygon(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) : 
 	QGraphicsPolygonItem(parent, scene),
 	CustomElementGraphicPart(editor),
@@ -31,6 +38,14 @@ PartPolygon::PartPolygon(QETElementEditor *editor, QGraphicsItem *parent, QGraph
 	style_editor -> setElementTypeName(name());
 }
 
+/// Destructeur
+PartPolygon::~PartPolygon() {
+}
+
+/**
+	Importe les proprietes d'un polygone depuis un element XML
+	@param qde Element XML a lire
+*/
 void PartPolygon::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
 	int i = 1;
@@ -54,6 +69,11 @@ void PartPolygon::fromXml(const QDomElement &qde) {
 	closed = qde.attribute("closed") != "false";
 }
 
+/**
+	Exporte le polygone en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant le polygone
+*/
 const QDomElement PartPolygon::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("polygon");
 	int i = 1;
@@ -68,7 +88,13 @@ const QDomElement PartPolygon::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
-void PartPolygon::paint(QPainter *painter, const QStyleOptionGraphicsItem */*q*/, QWidget */*w*/) {
+/**
+	Dessine le polygone
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
+void PartPolygon::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) {
 	applyStylesToQPainter(*painter);
 	QPen t = painter -> pen();
 	if (isSelected()) {
@@ -79,11 +105,23 @@ void PartPolygon::paint(QPainter *painter, const QStyleOptionGraphicsItem */*q*/
 	else painter -> drawPolyline(polygon());
 }
 
+/**
+	Specifie la valeur d'une propriete donnee du polygone
+	@param property propriete a modifier. Valeurs acceptees :
+		* closed : true pour fermer le polygone, false sinon
+	@param value Valeur a attribuer a la propriete
+*/
 void PartPolygon::setProperty(const QString &property, const QVariant &value) {
 	CustomElementGraphicPart::setProperty(property, value);
 	if (property == "closed") closed = value.toBool();
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee de la ligne
+	@param property propriete lue. Valeurs acceptees :
+		* closed : true pour fermer le polygone, false sinon
+	@return La valeur de la propriete property
+*/
 QVariant PartPolygon::property(const QString &property) {
 	// appelle la methode property de CustomElementGraphicpart pour les styles
 	QVariant style_property = CustomElementGraphicPart::property(property);
@@ -93,6 +131,11 @@ QVariant PartPolygon::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartPolygon::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {

editor/partpolygon.h

@@ -28,7 +28,7 @@ class PartPolygon : public QGraphicsPolygonItem, public CustomElementGraphicPart
 	// constructeurs, destructeur
 	public:
 	PartPolygon(QETElementEditor *, QGraphicsItem * = 0, QGraphicsScene * = 0);
-	virtual ~PartPolygon() {}
+	virtual ~PartPolygon();
 	
 	private:
 	PartPolygon(const PartPolygon &);

editor/partterminal.cpp

@@ -19,6 +19,12 @@
 #include "terminal.h"
 #include "terminaleditor.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de cette borne
+	@param scene La scene sur laquelle figure cette borne
+*/
 PartTerminal::PartTerminal(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) :
 	CustomElementPart(editor),
 	QGraphicsItem(parent, scene),
@@ -31,10 +37,15 @@ PartTerminal::PartTerminal(QETElementEditor *editor, QGraphicsItem *parent, QGra
 	setZValue(100000);
 }
 
+/// Destructeur
 PartTerminal::~PartTerminal() {
 	delete informations;
 };
 
+/**
+	Importe les proprietes d'une borne depuis un element XML
+	@param xml_elmt Element XML a lire
+*/
 void PartTerminal::fromXml(const QDomElement &xml_elmt) {
 	// lit la position de la borne
 	qreal term_x = 0.0, term_y = 0.0;
@@ -47,6 +58,11 @@ void PartTerminal::fromXml(const QDomElement &xml_elmt) {
 	updateSecondPoint();
 }
 
+/**
+	Exporte la borne en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant la borne
+*/
 const QDomElement PartTerminal::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("terminal");
 	
@@ -60,10 +76,19 @@ const QDomElement PartTerminal::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	@return Le widget permettant d'editer cette borne
+*/
 QWidget *PartTerminal::elementInformations() {
 	return(informations);
 }
 
+/**
+	Dessine la borne
+	@param painter QPainter a utiliser pour rendre le dessin
+	@param options Options pour affiner le rendu
+	@param widget Widget sur lequel le rendu est effectue
+*/
 void PartTerminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *) {
 	p -> save();
 	
@@ -88,6 +113,9 @@ void PartTerminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget
 	p -> restore();
 }
 
+/**
+	@return le rectangle delimitant cette partie.
+*/
 QRectF PartTerminal::boundingRect() const {
 	QPointF p1, p2;
 	if (second_point.x() <= 0.0 && second_point.y() <= 0.0) {
@@ -103,10 +131,17 @@ QRectF PartTerminal::boundingRect() const {
 	return(br);
 }
 
+/**
+	@return L'orientation de la borne
+*/
 QET::Orientation PartTerminal::orientation() const {
 	return(_orientation);
 }
 
+/**
+	Definit l'orientation de la borne
+	@param ori la nouvelle orientation de la borne
+*/
 void PartTerminal::setOrientation(QET::Orientation ori) {
 	prepareGeometryChange();
 	_orientation = ori;
@@ -114,6 +149,14 @@ void PartTerminal::setOrientation(QET::Orientation ori) {
 	informations -> updateForm();
 }
 
+/**
+	Specifie la valeur d'une propriete donnee de la borne
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse de la borne
+		* y : ordonnee de la borne
+		* orientation : orientation de la borne
+	@param value Valeur a attribuer a la propriete
+*/
 void PartTerminal::setProperty(const QString &property, const QVariant &value) {
 	if (property == "x") {
 		if (!value.canConvert(QVariant::Double)) return;
@@ -127,6 +170,14 @@ void PartTerminal::setProperty(const QString &property, const QVariant &value) {
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee de la borne
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse de la borne
+		* y : ordonnee de la borne
+		* orientation : orientation de la borne
+	@return La valeur de la propriete property
+*/
 QVariant PartTerminal::property(const QString &property) {
 	if (property == "x") {
 		return(scenePos().x());
@@ -138,6 +189,11 @@ QVariant PartTerminal::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartTerminal::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -147,6 +203,10 @@ QVariant PartTerminal::itemChange(GraphicsItemChange change, const QVariant &val
 	return(QGraphicsItem::itemChange(change, value));
 }
 
+/**
+	Met a jour la position du second point en fonction de la position et de
+	l'orientation de la borne.
+*/
 void PartTerminal::updateSecondPoint() {
 	qreal ts = 4.0; // terminal size
 	switch(_orientation) {

editor/parttext.cpp

@@ -18,6 +18,13 @@
 #include "parttext.h"
 #include "texteditor.h"
 #include "elementscene.h"
+
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de ce texte statique
+	@param scene La scene sur laquelle figure ce texte statique
+*/
 PartText::PartText(QETElementEditor *editor, QGraphicsItem *parent, ElementScene *scene) :
 	QGraphicsTextItem(parent, scene),
 	CustomElementPart(editor)
@@ -29,10 +36,16 @@ PartText::PartText(QETElementEditor *editor, QGraphicsItem *parent, ElementScene
 	infos -> setElementTypeName(name());
 }
 
+
+/// Destructeur
 PartText::~PartText() {
 	delete infos;
 }
 
+/**
+	Importe les proprietes d'un texte statique depuis un element XML
+	@param xml_element Element XML a lire
+*/
 void PartText::fromXml(const QDomElement &xml_element) {
 	bool ok;
 	int font_size = xml_element.attribute("size").toInt(&ok);
@@ -46,6 +59,11 @@ void PartText::fromXml(const QDomElement &xml_element) {
 	);
 }
 
+/**
+	Exporte le texte statique en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant le texte statique
+*/
 const QDomElement PartText::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("text");
 	xml_element.setAttribute("x", QString("%1").arg((scenePos() + margin()).x()));
@@ -55,6 +73,9 @@ const QDomElement PartText::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	@return Le widget permettant d'editer ce texte statique
+*/
 QWidget *PartText::elementInformations() {
 	return(infos);
 }
@@ -68,10 +89,19 @@ QPointF PartText::pos() const {
 	return(QGraphicsTextItem::pos() + margin());
 }
 
+/**
+	Specifie la position du texte statique
+	@param left_corner_pos Nouvelle position
+*/
 void PartText::setPos(const QPointF &left_corner_pos) {
 	QGraphicsTextItem::setPos(left_corner_pos - margin());
 }
 
+/**
+	Specifie la position du texte statique
+	@param x abscisse de la nouvelle position
+	@param y ordonnee de la nouvelle position
+*/
 void PartText::setPos(qreal x, qreal y) {
 	QGraphicsTextItem::setPos(QPointF(x, y) - margin());
 }
@@ -109,6 +139,15 @@ void PartText::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *e) {
 	setFocus(Qt::MouseFocusReason);
 }
 
+/**
+	Specifie la valeur d'une propriete donnee du texte statique
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse de la position
+		* y : ordonnee de la position
+		* size : taille du texte
+		* text : texte
+	@param value Valeur a attribuer a la propriete
+*/
 void PartText::setProperty(const QString &property, const QVariant &value) {
 	if (property == "x") {
 		if (!value.canConvert(QVariant::Double)) return;
@@ -124,6 +163,15 @@ void PartText::setProperty(const QString &property, const QVariant &value) {
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee du texte statique
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse de la position
+		* y : ordonnee de la position
+		* size : taille du texte
+		* text : texte
+	@return La valeur de la propriete property
+*/
 QVariant PartText::property(const QString &property) {
 	if (property == "x") {
 		return((scenePos() + margin()).x());
@@ -137,6 +185,11 @@ QVariant PartText::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartText::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -146,6 +199,9 @@ QVariant PartText::itemChange(GraphicsItemChange change, const QVariant &value)
 	return(QGraphicsTextItem::itemChange(change, value));
 }
 
+/**
+	@return le rectangle delimitant cette partie.
+*/
 QRectF PartText::boundingRect() const {
 	QRectF r = QGraphicsTextItem::boundingRect();
 	r.adjust(0.0, -2.0, 0.0, 0.0);

editor/parttextfield.cpp

@@ -18,7 +18,12 @@
 #include "parttextfield.h"
 #include "textfieldeditor.h"
 
-
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param parent Le QGraphicsItem parent de ce champ de texte
+	@param scene La scene sur laquelle figure ce champ de texte
+*/
 PartTextField::PartTextField(QETElementEditor *editor, QGraphicsItem *parent, QGraphicsScene *scene) :
 	QGraphicsTextItem(parent, scene),
 	CustomElementPart(editor),
@@ -31,10 +36,15 @@ PartTextField::PartTextField(QETElementEditor *editor, QGraphicsItem *parent, QG
 	infos -> setElementTypeName(name());
 }
 
+/// Destructeur
 PartTextField::~PartTextField() {
 	delete infos;
 }
 
+/**
+	Importe les proprietes d'un champ de texte depuis un element XML
+	@param xml_element Element XML a lire
+*/
 void PartTextField::fromXml(const QDomElement &xml_element) {
 	bool ok;
 	int font_size = xml_element.attribute("size").toInt(&ok);
@@ -50,6 +60,11 @@ void PartTextField::fromXml(const QDomElement &xml_element) {
 	follow_parent_rotations = (xml_element.attribute("rotate") == "true");
 }
 
+/**
+	Exporte le champ de texte en XML
+	@param xml_document Document XML a utiliser pour creer l'element XML
+	@return un element XML decrivant le champ de texte
+*/
 const QDomElement PartTextField::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("input");
 	xml_element.setAttribute("x", QString("%1").arg((scenePos() + margin()).x()));
@@ -60,6 +75,9 @@ const QDomElement PartTextField::toXml(QDomDocument &xml_document) const {
 	return(xml_element);
 }
 
+/**
+	@return Le widget permettant d'editer ce champ de texte
+*/
 QWidget *PartTextField::elementInformations() {
 	return(infos);
 }
@@ -73,18 +91,35 @@ QPointF PartTextField::pos() const {
 	return(QGraphicsTextItem::pos() + margin());
 }
 
+/**
+	Specifie la position du champ de texte
+	@param left_corner_pos Nouvelle position
+*/
 void PartTextField::setPos(const QPointF &left_corner_pos) {
 	QGraphicsTextItem::setPos(left_corner_pos - margin());
 }
 
+/**
+	Specifie la position du champ de texte
+	@param x abscisse de la nouvelle position
+	@param y ordonnee de la nouvelle position
+*/
 void PartTextField::setPos(qreal x, qreal y) {
 	QGraphicsTextItem::setPos(QPointF(x, y) - margin());
 }
 
+/**
+	@return true si le champ de texte suit les rotation de l'element, false
+	sinon
+*/
 bool PartTextField::followParentRotations() {
 	return(follow_parent_rotations);
 }
 
+/**
+	@param  fpr true pour que le champ de texte suive les rotation de
+	l'element, false sinon
+*/
 void PartTextField::setFollowParentRotations(bool fpr) {
 	follow_parent_rotations = fpr;
 }
@@ -122,6 +157,16 @@ void PartTextField::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *e) {
 	setFocus(Qt::MouseFocusReason);
 }
 
+/**
+	Specifie la valeur d'une propriete donnee du champ de texte
+	@param property propriete a modifier. Valeurs acceptees :
+		* x : abscisse de la position
+		* y : ordonnee de la position
+		* size : taille du texte
+		* text : texte
+		* rotate : suivi de la rotation de l'element parent
+	@param value Valeur a attribuer a la propriete
+*/
 void PartTextField::setProperty(const QString &property, const QVariant &value) {
 	if (property == "x") {
 		if (!value.canConvert(QVariant::Double)) return;
@@ -139,6 +184,16 @@ void PartTextField::setProperty(const QString &property, const QVariant &value)
 	}
 }
 
+/**
+	Permet d'acceder a la valeur d'une propriete donnee du champ de texte
+	@param property propriete lue. Valeurs acceptees :
+		* x : abscisse de la position
+		* y : ordonnee de la position
+		* size : taille du texte
+		* text : texte
+		* rotate : suivi de la rotation de l'element parent
+	@return La valeur de la propriete property
+*/
 QVariant PartTextField::property(const QString &property) {
 	if (property == "x") {
 		return((scenePos() + margin()).x());
@@ -154,6 +209,11 @@ QVariant PartTextField::property(const QString &property) {
 	return(QVariant());
 }
 
+/**
+	Gere les changements intervenant sur cette partie
+	@param change Type de changement
+	@param value Valeur numerique relative au changement
+*/
 QVariant PartTextField::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (scene()) {
 		if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemSelectedChange) {
@@ -163,6 +223,9 @@ QVariant PartTextField::itemChange(GraphicsItemChange change, const QVariant &va
 	return(QGraphicsTextItem::itemChange(change, value));
 }
 
+/**
+	@return le rectangle delimitant cette partie.
+*/
 QRectF PartTextField::boundingRect() const {
 	QRectF r = QGraphicsTextItem::boundingRect();
 	r.adjust(0.0, -2.0, 0.0, 0.0);

editor/polygoneditor.cpp

@@ -22,6 +22,7 @@
 
 /**
 	Constructeur
+	@param editor L'editeur d'element concerne
 	@param p Le polygone a editer
 	@param parent le Widget parent
 */
@@ -48,11 +49,21 @@ PolygonEditor::PolygonEditor(QETElementEditor *editor, PartPolygon *p, QWidget *
 	updateForm();
 }
 
+/// Destructeur
+PolygonEditor::~PolygonEditor() {
+}
+
+/**
+	Met a jour le polygone a partir des donnees du formulaire : points et etat ferme ou non
+*/
 void PolygonEditor::updatePolygon() {
 	updatePolygonPoints();
 	updatePolygonClosedState();
 }
 
+/**
+	Met a jour les points du polygone et cree un objet d'annulation
+*/
 void PolygonEditor::updatePolygonPoints() {
 	QVector<QPointF> points = getPointsFromTree();
 	if (points.count() < 2) {
@@ -66,6 +77,9 @@ void PolygonEditor::updatePolygonPoints() {
 	undoStack().push(new ChangePolygonPointsCommand(part, part -> polygon(), points));
 }
 
+/**
+	Met a jour l'etat ferme ou non du polygone
+*/
 void PolygonEditor::updatePolygonClosedState() {
 	undoStack().push(
 		new ChangePartCommand(
@@ -78,6 +92,9 @@ void PolygonEditor::updatePolygonClosedState() {
 	);
 }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void PolygonEditor::updateForm() {
 	activeConnections(false);
 	while(points_list.takeTopLevelItem(0));
@@ -93,6 +110,10 @@ void PolygonEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	@return Un vecteur contenant les points composant le polygone a partir du
+	formulaire d'edition
+*/
 QVector<QPointF> PolygonEditor::getPointsFromTree() {
 	QVector<QPointF> points;
 	for(int i = 0 ; i < points_list.topLevelItemCount() ; ++ i) {
@@ -106,6 +127,10 @@ QVector<QPointF> PolygonEditor::getPointsFromTree() {
 	return(points);
 }
 
+/**
+	@param qtwi QTreeWidgetItem a valider
+	@param column Colonne exacte du QTreeWidgetItem a valider
+*/
 void PolygonEditor::validColumn(QTreeWidgetItem *qtwi, int column) {
 	bool convert_ok;
 	qtwi -> text(column).toDouble(&convert_ok);
@@ -115,6 +140,10 @@ void PolygonEditor::validColumn(QTreeWidgetItem *qtwi, int column) {
 	} else points_list.openPersistentEditor(qtwi, column);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void PolygonEditor::activeConnections(bool active) {
 	if (active) {
 		connect(&close_polygon, SIGNAL(stateChanged(int)),                   this, SLOT(updatePolygonClosedState()));

editor/polygoneditor.h

@@ -30,7 +30,7 @@ class PolygonEditor : public ElementItemEditor {
 	// constructeurs, destructeur
 	public:
 	PolygonEditor(QETElementEditor *, PartPolygon *, QWidget * = 0);
-	virtual ~PolygonEditor() {}
+	virtual ~PolygonEditor();
 	
 	private:
 	PolygonEditor(const PolygonEditor &);

editor/qetelementeditor.cpp

@@ -288,7 +288,7 @@ void QETElementEditor::setupInterface() {
 	undo_view -> setEmptyLabel(tr("Aucune modification"));
 	undo_dock -> setWidget(undo_view);
 	
-	// panel sur le c<EFBFBD>t<EFBFBD> pour la liste des parties
+	// panel sur le cote pour la liste des parties
 	parts_list = new QListWidget(this);
 	parts_list -> setSelectionMode(QAbstractItemView::ExtendedSelection);
 	connect(ce_scene,   SIGNAL(partsAdded()),           this, SLOT(slot_createPartsList()));

editor/styleeditor.cpp

@@ -18,6 +18,12 @@
 #include "styleeditor.h"
 #include "customelementgraphicpart.h"
 
+/**
+	Constructeur
+	@param editor L'editeur d'element concerne
+	@param p La partie a editer
+	@param parent le Widget parent
+*/
 StyleEditor::StyleEditor(QETElementEditor *editor, CustomElementGraphicPart *p, QWidget *parent) : ElementItemEditor(editor, parent), part(p) {
 	// couleur
 	color = new QButtonGroup(this);
@@ -88,9 +94,13 @@ StyleEditor::StyleEditor(QETElementEditor *editor, CustomElementGraphicPart *p,
 	setLayout(main_layout);
 }
 
+/// Destructeur
 StyleEditor::~StyleEditor() {
 }
 
+/**
+	Met a jour le style de la partie a partir des donnees du formulaire
+*/
 void StyleEditor::updatePart() {
 	// applique l'antialiasing
 	part -> setAntialiased(antialiasing -> isChecked());
@@ -108,12 +118,20 @@ void StyleEditor::updatePart() {
 	part -> setFilling(static_cast<CEGP::Filling>(filling -> checkedId()));
 }
 
+/// Met a jour l'antialiasing et cree un objet d'annulation
 void StyleEditor::updatePartAntialiasing()   { addChangePartCommand("style antialiasing", part, "antialias",   antialiasing -> isChecked()); }
+/// Met a jour la couleur du trait et cree un objet d'annulation
 void StyleEditor::updatePartColor()          { addChangePartCommand("style couleur",      part, "color",       color -> checkedId());        }
+/// Met a jour le style du trait et cree un objet d'annulation
 void StyleEditor::updatePartLineStyle()      { addChangePartCommand("style ligne",        part, "line-style",  style -> checkedId());        }
+/// Met a jour l'epaisseur du trait et cree un objet d'annulation
 void StyleEditor::updatePartLineWeight()     { addChangePartCommand("style epaisseur",    part, "line-weight", weight -> checkedId());       }
+/// Met a jour la couleur de fond et cree un objet d'annulation
 void StyleEditor::updatePartFilling()        { addChangePartCommand("style remplissage",  part, "filling",     filling -> checkedId());      }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void StyleEditor::updateForm() {
 	activeConnections(false);
 	// lit l'antialiasing
@@ -133,10 +151,18 @@ void StyleEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Ajoute un widget en bas de l'editeur de style
+	@param w Widget a inserer
+*/
 void StyleEditor::appendWidget(QWidget *w) {
 	main_layout -> insertWidget(7, w);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void StyleEditor::activeConnections(bool active) {
 	if (active) {
 		connect(color,        SIGNAL(buttonClicked(int)), this, SLOT(updatePartColor()));

editor/terminaleditor.cpp

@@ -20,7 +20,8 @@
 
 /**
 	Constructeur
-	@param term Borne a editer
+	@param editor L'editeur d'element concerne
+	@param term La borne a editer
 	@param parent QWidget parent de ce widget
 */
 TerminalEditor::TerminalEditor(QETElementEditor *editor, PartTerminal *term, QWidget *parent) : ElementItemEditor(editor, parent) {
@@ -56,12 +57,13 @@ TerminalEditor::TerminalEditor(QETElementEditor *editor, PartTerminal *term, QWi
 	updateForm();
 }
 
-/**
-	Destructeur
-*/
+/// Destructeur
 TerminalEditor::~TerminalEditor() {
 };
 
+/**
+	Met a jour la borne a partir des donnees du formulaire
+*/
 void TerminalEditor::updateTerminal() {
 	part -> setPos(qle_x -> text().toDouble(), qle_y -> text().toDouble());
 	part -> setOrientation(
@@ -73,10 +75,16 @@ void TerminalEditor::updateTerminal() {
 	);
 }
 
+/// Met a jour l'abscisse de la position de la borne et cree un objet d'annulation
 void TerminalEditor::updateTerminalX() { addChangePartCommand(tr("abscisse"),    part, "x",           qle_x -> text().toDouble()); updateForm(); }
+/// Met a jour l'ordonnee de la position de la borne et cree un objet d'annulation
 void TerminalEditor::updateTerminalY() { addChangePartCommand(tr("ordonn\351e"), part, "y",           qle_y -> text().toDouble()); updateForm(); }
+/// Met a jour l'orientation de la borne et cree un objet d'annulation
 void TerminalEditor::updateTerminalO() { addChangePartCommand(tr("orientation"), part, "orientation", orientation -> itemData(orientation -> currentIndex()).toInt()); }
 
+/**
+	Met a jour le formulaire d'edition
+*/
 void TerminalEditor::updateForm() {
 	activeConnections(false);
 	qle_x -> setText(part -> property("x").toString());
@@ -85,6 +93,10 @@ void TerminalEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void TerminalEditor::activeConnections(bool active) {
 	if (active) {
 		connect(qle_x,       SIGNAL(editingFinished()), this, SLOT(updateTerminalX()));

editor/textfieldeditor.cpp

@@ -21,7 +21,7 @@
 /**
 	Constructeur
 	@param editor L'editeur d'element concerne
-	@param textfield Champ de texte a editer
+	@param textfield Le champ de texte a editer
 	@param parent QWidget parent
 */
 TextFieldEditor::TextFieldEditor(QETElementEditor *editor, PartTextField *textfield, QWidget *parent) : ElementItemEditor(editor, parent) {
@@ -64,9 +64,7 @@ TextFieldEditor::TextFieldEditor(QETElementEditor *editor, PartTextField *textfi
 	updateForm();
 }
 
-/**
-	Destructeur
-*/
+/// Destructeur
 TextFieldEditor::~TextFieldEditor() {
 }
 
@@ -80,14 +78,19 @@ void TextFieldEditor::updateTextField() {
 	part -> setFollowParentRotations(!rotate -> isChecked());
 }
 
+/// Met a jour l'abscisse de la position du champ de texte et cree un objet d'annulation
 void TextFieldEditor::updateTextFieldX() { addChangePartCommand(tr("abscisse"),        part, "x",      qle_x -> text().toDouble()); updateForm(); }
+/// Met a jour l'ordonnee de la position du champ de texte et cree un objet d'annulation
 void TextFieldEditor::updateTextFieldY() { addChangePartCommand(tr("ordonn\351e"),     part, "y",      qle_y -> text().toDouble()); updateForm(); }
+/// Met a jour le texte du champ de texte et cree un objet d'annulation
 void TextFieldEditor::updateTextFieldT() { addChangePartCommand(tr("texte"),           part, "text",   qle_text -> text());         }
+/// Met a jour la taille du champ de texte et cree un objet d'annulation
 void TextFieldEditor::updateTextFieldS() { addChangePartCommand(tr("taille"),          part, "size",   font_size -> value());       }
+/// Met a jour la taille du champ de texte et cree un objet d'annulation
 void TextFieldEditor::updateTextFieldR() { addChangePartCommand(tr("propri\351t\351"), part, "rotate", !rotate -> isChecked());     }
 
 /**
-	Met a jour le formulaire a partir du champ de texte
+	Met a jour le formulaire d'edition
 */
 void TextFieldEditor::updateForm() {
 	activeConnections(false);
@@ -99,6 +102,10 @@ void TextFieldEditor::updateForm() {
 	activeConnections(true);
 }
 
+/**
+	Active ou desactive les connexionx signaux/slots entre les widgets internes.
+	@param active true pour activer les connexions, false pour les desactiver
+*/
 void TextFieldEditor::activeConnections(bool active) {
 	if (active) {
 		connect(qle_x,     SIGNAL(editingFinished()), this, SLOT(updateTextFieldX()));

element.cpp

@@ -332,7 +332,7 @@ bool Element::valideXml(QDomElement &e) {
 */
 bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr) {
 	/*
-		les bornes vont maintenant etre recensees pour associer leurs id <EFBFBD> leur adresse reelle
+		les bornes vont maintenant etre recensees pour associer leurs id a leur adresse reelle
 		ce recensement servira lors de la mise en place des fils
 	*/
 	QList<QDomElement> liste_terminals;

elementspanel.cpp

@@ -99,7 +99,7 @@ void ElementsPanel::dropEvent(QDropEvent */*e*/) {
 	Gere le debut des drag'n drop
 	@param supportedActions Les actions supportees
  */
-void ElementsPanel::startDrag(Qt::DropActions /*supportedActions*/) {
+void ElementsPanel::startDrag(Qt::DropActions) {
 	// recupere le nom du fichier decrivant l'element
 	QString nom_fichier = currentItem() -> data(0, 42).toString();
 	if (nom_fichier.isEmpty()) return;

insetproperties.h

@@ -27,6 +27,7 @@ class InsetProperties {
 	public:
 	InsetProperties();
 	virtual ~InsetProperties();
+	/// Specifie comment gerer la date
 	enum DateManagement {
 		UseDateValue, ///< utilise l'attribut date
 		CurrentDate   ///< utilise la date courante

insetpropertieswidget.cpp

@@ -21,7 +21,7 @@
 /**
 	Constructeur
 	@param inset InsetProperties a afficher
-	@param fixed true pour afficher l'option "Date courante"
+	@param current true pour afficher l'option "Date courante"
 	@param parent QWidget parent
 */
 InsetPropertiesWidget::InsetPropertiesWidget(const InsetProperties &inset, bool current, QWidget *parent) : QWidget(parent), display_current_date(false) {

qet.cpp

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

qetapp.cpp

@@ -402,7 +402,7 @@ QList<QETElementEditor *> QETApp::elementEditors() const {
 }
 
 /**
-	Affiche ou cache une fenetre (editeurs de schemas / editeurs d <20>lements)
+	Affiche ou cache une fenetre (editeurs de schemas / editeurs d'elements)
 	@param window fenetre a afficher / cacher
 	@param visible true pour affiche la fenetre, false sinon
 */
@@ -426,7 +426,7 @@ void QETApp::setMainWindowVisible(QMainWindow *window, bool visible) {
 }
 
 /**
-	Affiche une fenetre (editeurs de schemas / editeurs d <20>lements) si
+	Affiche une fenetre (editeurs de schemas / editeurs d'elements) si
 	celle-ci est cachee ou la cache si elle est affichee.
 	@param window fenetre a afficher / cacher
 */

qetapp.h

@@ -54,13 +54,13 @@ class QETApp : public QApplication {
 	public:
 	static void overrideCommonElementsDir(const QString &);
 	private:
-	static QString common_elements_dir;
+	static QString common_elements_dir; ///< Dossier contenant la collection d'elements commune
 #endif
 #ifdef QET_ALLOW_OVERRIDE_CD_OPTION
 	public:
 	static void overrideConfigDir(const QString &);
 	private:
-	static QString config_dir;
+	static QString config_dir; ///< Dossier contenant la configuration et la collection d'elements de l'utilisateur
 #endif
 	
 	protected: