La hauteur du schema est desormais geree via un systeme de lignes, dont le nombre et la hauteur sont ajustables.

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

qelectrotech.qrc

@@ -6,6 +6,7 @@
 	<file>ico/qelectrotech.png</file>
 	<file>ico/allowed.png</file>
 	<file>ico/add_col.png</file>
+	<file>ico/add_row.png</file>
 	<file>ico/arc.png</file>
 	<file>ico/bring_forward.png</file>
 	<file>ico/button_cancel.png</file>
@@ -57,6 +58,7 @@
 	<file>ico/redo.png</file>
 	<file>ico/reload.png</file>
 	<file>ico/remove_col.png</file>
+	<file>ico/remove_row.png</file>
 	<file>ico/restaurer.png</file>
 	<file>ico/saveas.png</file>
 	<file>ico/save.png</file>

sources/borderinset.cpp

@@ -18,23 +18,30 @@
 #include <QPainter>
 #include "borderinset.h"
 #include "qetapp.h"
+#include "math.h"
 
 /**
-	Constructeur simple : construit une bordure de 15 colonnes de 50x500 avec
+	Constructeur simple : construit une bordure en recuperant les dimensions
-	un cartouche de 400x50.
+	dans la configuration de l'application.
 	@param parent QObject parent de ce BorderInset
 */
 BorderInset::BorderInset(QObject *parent) : QObject(parent) {
-	nb_columns            = qMax(3, QETApp::settings().value("diagrameditor/defaultcols", 15).toInt());
+	// initialise les dimensions des colonnes (ainsi que la largeur du cartouche)
-	min_nb_columns        = 3;
-	columns_width         = QETApp::settings().value("diagrameditor/defaultcolsize", 50.0).toDouble();
-	columns_height        = QETApp::settings().value("diagrameditor/defaultheight", 500.0).toDouble();
-	min_columns_height    = 80.0;
-	inset_width           = nb_columns * columns_width;
-	inset_height          = 50.0;
 	columns_header_height = 20.0;
+	setNbColumns   (QETApp::settings().value("diagrameditor/defaultcols", 15).toInt());
+	setColumnsWidth(QETApp::settings().value("diagrameditor/defaultcolsize", 50.0).toDouble());
+	
+	// initialise les dimensions des lignes
+	rows_header_width     = 20.0;
+	setNbRows(QETApp::settings().value("diagrameditor/defaultrows", 6).toInt());
+	setRowsHeight(QETApp::settings().value("diagrameditor/defaultrowsize", 80.0).toDouble());
+	
+	// hauteur du cartouche
+	inset_height          = 50.0;
+	
 	display_inset         = true;
 	display_columns       = true;
+	display_rows          = true;
 	display_border        = true;
 	updateRectangles();
 	
@@ -54,18 +61,46 @@ BorderInset::BorderInset(QObject *parent) : QObject(parent) {
 BorderInset::~BorderInset() {
 }
 
+/**
+	@return Le nombre minimum de colonnes qu'un schema doit comporter
+*/
+int BorderInset::minNbColumns() {
+	return(3);
+}
+
+/**
+	@return la largeur minimale d'une colonne de schema
+*/
+qreal BorderInset::minColumnsWidth() {
+	return(5.0);
+}
+
+/**
+	@return Le nombre minimum de lignes qu'un schema doit comporter
+*/
+int BorderInset::minNbRows() {
+	return(2);
+}
+
+/**
+	@return la hauteur minimale d'une ligne de schema
+*/
+qreal BorderInset::minRowsHeight() {
+	return(5.0);
+}
+
 /**
 	Methode recalculant les rectangles composant le cadre et le cartouche en
 	fonction des attributs de taille
 */
 void BorderInset::updateRectangles() {
 	// rectangle delimitant le schema
-	QRectF previous_border = border;
+	QRectF previous_diagram = diagram;
-	border = QRectF(0, 0, nb_columns * columns_width, columns_height);
+	diagram = QRectF(0, 0, diagramWidth(), diagramHeight());
-	if (border != previous_border) emit(borderChanged(previous_border, border));
+	if (diagram != previous_diagram) emit(borderChanged(previous_diagram, diagram));
 	
 	// rectangles relatifs au cartouche
-	inset        = QRectF(border.bottomLeft().x(), border.bottomLeft().y(), inset_width, inset_height);
+	inset        = QRectF(diagram.bottomLeft().x(), diagram.bottomLeft().y(), inset_width, inset_height);
 	inset_author = QRectF(inset.topLeft(), QSizeF(2.0 * inset_width / 9.0, 0.5 * inset_height));
 	inset_date   = QRectF(inset_author.bottomLeft(), inset_author.size());
 	inset_title  = QRectF(inset_author.topRight(), QSizeF(5.0 * inset_width / 9.0, inset_height));
@@ -81,7 +116,7 @@ void BorderInset::updateRectangles() {
 */
 void BorderInset::draw(QPainter *qp, qreal x, qreal y) {
 	// translate tous les rectangles
-	border      .translate(x, y);
+	diagram     .translate(x, y);
 	inset       .translate(x, y);
 	inset_author.translate(x, y);
 	inset_date  .translate(x, y);
@@ -95,17 +130,28 @@ void BorderInset::draw(QPainter *qp, qreal x, qreal y) {
 	qp -> setBrush(Qt::NoBrush);
 	
 	// dessine le cadre
-	if (display_border) qp -> drawRect(border);
+	if (display_border) qp -> drawRect(diagram);
 	
 	qp -> setFont(QFont(QETApp::diagramTextsFont(), qp -> font().pointSize()));
 	
+	// dessine la case vide qui apparait des qu'il y a un entete
+	if (display_columns || display_rows) {
+		qp -> setBrush(Qt::white);
+		QRectF first_rectangle(
+			diagram.topLeft().x(),
+			diagram.topLeft().y(),
+			rows_header_width,
+			columns_header_height
+		);
+		qp -> drawRect(first_rectangle);
+	}
+	
 	// dessine la numerotation des colonnes
 	if (display_columns) {
-		qp -> setBrush(Qt::white);
 		for (int i = 1 ; i <= nb_columns ; ++ i) {
 			QRectF numbered_rectangle = QRectF(
-				border.topLeft().x() + ((i - 1) * columns_width),
+				diagram.topLeft().x() + (rows_header_width + ((i - 1) * columns_width)),
-				border.topLeft().y(),
+				diagram.topLeft().y(),
 				columns_width,
 				columns_header_height
 			);
@@ -114,6 +160,22 @@ void BorderInset::draw(QPainter *qp, qreal x, qreal y) {
 		}
 	}
 	
+	// dessine la numerotation des lignes
+	if (display_rows) {
+		QString row_string("A");
+		for (int i = 1 ; i <= nb_rows ; ++ i) {
+			QRectF lettered_rectangle = QRectF(
+				diagram.topLeft().x(),
+				diagram.topLeft().y() + (columns_header_height + ((i - 1) * rows_height)),
+				rows_header_width,
+				rows_height
+			);
+			qp -> drawRect(lettered_rectangle);
+			qp -> drawText(lettered_rectangle, Qt::AlignVCenter | Qt::AlignCenter, row_string);
+			row_string = incrementLetters(row_string);
+		}
+	}
+	
 	// dessine le cartouche
 	if (display_inset) {
 		qp -> setBrush(Qt::white);
@@ -138,7 +200,7 @@ void BorderInset::draw(QPainter *qp, qreal x, qreal y) {
 	qp -> restore();
 	
 	// annule la translation des rectangles
-	border      .translate(-x, -y);
+	diagram     .translate(-x, -y);
 	inset       .translate(-x, -y);
 	inset_author.translate(-x, -y);
 	inset_date  .translate(-x, -y);
@@ -151,47 +213,62 @@ void BorderInset::draw(QPainter *qp, qreal x, qreal y) {
 	Ajoute une colonne.
 */
 void BorderInset::addColumn() {
-	++ nb_columns;
+	setNbColumns(nbColumns() + 1);
-	setInsetWidth(nb_columns * columns_width);
-	updateRectangles();
 }
 
 /**
-	Enleve une colonne. Il doit rester au moins 3 colonnes.
+	Enleve une colonne sans passer sous le minimum requis.
+	@see minNbColumns()
 */
 void BorderInset::removeColumn() {
-	if (nb_columns == min_nb_columns) return;
+	setNbColumns(nbColumns() - 1);
-	-- nb_columns;
+}
-	setInsetWidth(nb_columns * columns_width);
+
-	updateRectangles();
+/**
+	Ajoute une ligne.
+*/
+void BorderInset::addRow() {
+	setNbRows(nbRows() + 1);
+}
+
+/**
+	Enleve une ligne sans passer sous le minimum requis.
+	@see minNbRows()
+*/
+void BorderInset::removeRow() {
+	setNbRows(nbRows() - 1);
 }
 
 /**
 	Permet de changer le nombre de colonnes.
-	Si ce nombre de colonnes est inferieur au minimum requis, cette fonction ne
+	Si ce nombre de colonnes est inferieur au minimum requis, c'est ce minimum
-	fait rien
+	qui est utilise.
 	@param nb_c nouveau nombre de colonnes
 	@see minNbColumns()
 */
 void BorderInset::setNbColumns(int nb_c) {
-	if (nb_c < min_nb_columns) return;
+	if (nb_c == nbColumns()) return;
-	nb_columns = nb_c;
+	nb_columns = qMax(minNbColumns(), nb_c);
-	setInsetWidth(nb_columns * columns_width);
+	setInsetWidth(diagramWidth());
-	updateRectangles();
 }
 
 /**
-	Change la largeur des colonnes ; celle-ci doit rester comprise entre 10 et
+	Change la largeur des colonnes.
-	200px.
+	Si la largeur indiquee est inferieure au minimum requis, c'est ce minimum
+	qui est utilise.
+	@param new_cw nouvelle largeur des colonnes
+	@see minColumnsWidth()
 */
 void BorderInset::setColumnsWidth(const qreal &new_cw) {
-	columns_width = qBound(10.0, new_cw, 200.0);
+	if (new_cw == columnsWidth()) return;
-	updateRectangles();
+	columns_width = qMax(minColumnsWidth(), new_cw);
+	setInsetWidth(diagramWidth());
 }
 
 /**
 	Change la hauteur des en-tetes contenant les numeros de colonnes. Celle-ci
 	doit rester comprise entre 5 et 50 px.
+	@param new_chh nouvelle hauteur des en-tetes de colonnes
 */
 void BorderInset::setColumnsHeaderHeight(const qreal &new_chh) {
 	columns_header_height = qBound(5.0, new_chh, 50.0);
@@ -199,29 +276,66 @@ void BorderInset::setColumnsHeaderHeight(const qreal &new_chh) {
 }
 
 /**
-	Change la hauteur des colonnes (et donc du cadre). Cette hauteur doit
+	Permet de changer le nombre de lignes.
-	rester superieure a la hauteur des en-tetes de colonnes + 20px.
+	Si ce nombre de lignes est inferieur au minimum requis, cette fonction ne
+	fait rien
+	@param nb_r nouveau nombre de lignes
+	@see minNbRows()
 */
-void BorderInset::setColumnsHeight(const qreal &new_ch) {
+void BorderInset::setNbRows(int nb_r) {
-	columns_height = qMax(columns_header_height + min_columns_height, new_ch);
+	if (nb_r == nbRows()) return;
+	nb_rows = qMax(minNbRows(), nb_r);
+	setInsetWidth(diagramWidth());
 	updateRectangles();
 }
 
 /**
-	Change la largeur du cartouche. Cette largeur doit rester comprise entre
+	Change la hauteur des lignes.
-	100px et la largeur du cartouche
+	Si la hauteur indiquee est inferieure au minimum requis, c'est ce minimum
+	qui est utilise.
+	@param rh nouvelle hauteur des lignes
+	@see minRowsHeight()
+*/
+void BorderInset::setRowsHeight(const qreal &new_rh) {
+	if (new_rh == rowsHeight()) return;
+	rows_height = qMax(minRowsHeight(), new_rh);
+	updateRectangles();
+}
+
+/**
+	Change la largeur des en-tetes contenant les numeros de lignes. Celle-ci
+	doit rester comprise entre 5 et 50 px.
+	@param new_rhw nouvelle largeur des en-tetes des lignes
+*/
+void BorderInset::setRowsHeaderWidth(const qreal &new_rhw) {
+	rows_header_width = qBound(5.0, new_rhw, 50.0);
+	updateRectangles();
+}
+
+/**
+	Cette methode essaye de se rapprocher le plus possible de la hauteur donnee
+	en parametre en modifiant le nombre de lignes en cours.
+*/
+void BorderInset::setDiagramHeight(const qreal &height) {
+	// taille des lignes a utiliser = rows_height
+	setNbColumns(ceil(height / rows_height));
+}
+
+/**
+	Change la largeur du cartouche. Cette largeur sera restreinte a celle du
+	schema.
 */
 void BorderInset::setInsetWidth(const qreal &new_iw) {
-	inset_width = qMax(100.0, qMin(nb_columns * columns_width, new_iw));
+	inset_width = qMin(diagramWidth(), new_iw);
 	updateRectangles();
 }
 
 /**
-	Change la hauteur du cartouche. Cette largeur doit rester comprise entre
+	Change la hauteur du cartouche. Cette hauteur doit rester comprise entre
-	20px et la hauteur du cartouche.
+	20px et la hauteur du schema.
 */
 void BorderInset::setInsetHeight(const qreal &new_ih) {
-	inset_height = qMax(20.0, qMin(columns_height, new_ih));
+	inset_height = qMax(20.0, qMin(diagramHeight(), new_ih));
 	updateRectangles();
 }
 
@@ -230,5 +344,22 @@ void BorderInset::setInsetHeight(const qreal &new_ih) {
 	que le schema
 */
 void BorderInset::adjustInsetToColumns() {
-	setInsetWidth(nbColumn() * columnsWidth());
+	setInsetWidth(diagramWidth());
+}
+
+QString BorderInset::incrementLetters(const QString &string) {
+	if (string.isEmpty()) {
+		return("A");
+	} else {
+		// separe les digits precedents du dernier digit
+		QString first_digits(string.left(string.count() - 1));
+		QChar last_digit(string.at(string.count() - 1));
+		if (last_digit != 'Z') {
+			// incremente le dernier digit
+			last_digit = last_digit.toAscii() + 1;
+			return(first_digits + QString(last_digit));
+		} else {
+			return(incrementLetters(first_digits) + "A");
+		}
+	}
 }

sources/borderinset.h

@@ -39,29 +39,51 @@ class BorderInset : public QObject {
 	
 	// methodes
 	public:
+	static int   minNbColumns();
+	static qreal minColumnsWidth();
+	static int   minNbRows();
+	static qreal minRowsHeight();
+	
 	void draw(QPainter *, qreal = 0.0, qreal = 0.0);
 	
 	// methodes d'acces en lecture aux dimensions
+	// colonnes
 	/// @return le nombre de colonnes du schema
-	int     nbColumn()            const { return(nb_columns);                    }
+	int   nbColumns()           const { return(nb_columns);                    }
-	/// @return la taille des colonnes en pixels
+	/// @return la largeur des colonnes en pixels
-	qreal   columnsWidth()        const { return(columns_width);                 }
+	qreal columnsWidth()        const { return(columns_width);                 }
+	/// @return la taille de l'ensemble des colonnes, en-tete des lignes non inclus
+	qreal columnsTotalWidth()   const { return(nb_columns * columns_width);    }
 	/// @return la hauteur, en pixels, des en-tetes des colonnes
-	qreal   columnsHeaderHeight() const { return(columns_header_height);         }
+	qreal columnsHeaderHeight() const { return(columns_header_height);         }
-	/// @return la hauteur des colonnes, en-tetes inclus
+	
-	qreal   columnsHeight()       const { return(columns_height);                }
+	// lignes
-	/// @return la largeur de la bordure
+	/// @return le nombre de lignes du schema
-	qreal   borderWidth()         const { return(nb_columns * columns_width);    }
+	int   nbRows()              const { return(nb_rows);                       }
-	/// @return la hauteur de la bordure
+	/// @return la hauteur des lignes en pixels
-	qreal   borderHeight()        const { return(columns_height + inset_height); }
+	qreal rowsHeight()          const { return(rows_height);                   }
+	/// @return la taille de l'ensemble des lignes, en-tete des colonnes non inclus
+	qreal rowsTotalHeight()     const { return(nb_rows * rows_height);         }
+	/// @return la largeur, en pixels, des en-tetes des lignes
+	qreal rowsHeaderWidth()     const { return(rows_header_width);             }
+	
+	// cadre sans le cartouche = schema
+	/// @return la largeur du schema, c'est-a-dire du cadre sans le cartouche
+	qreal diagramWidth()        const { return(columnsTotalWidth() + rowsHeaderWidth());    }
+	/// @return la hauteurdu schema, c'est-a-dire du cadre sans le cartouche
+	qreal diagramHeight()       const { return(rowsTotalHeight() + columnsHeaderHeight());  }
+	
+	// cartouche
 	/// @return la largeur du cartouche
-	qreal   insetWidth()          const { return(inset_width);                   }
+	qreal   insetWidth()          const { return(inset_width);                 }
 	/// @return la hauteur du cartouche
-	qreal   insetHeight()         const { return(inset_height);                  }
+	qreal   insetHeight()         const { return(inset_height);                }
-	/// @return la hauteur minimale acceptee des colonnes
+	
-	qreal   minColumnsHeight()    const { return(min_columns_height);            }
+	// cadre avec le cartouche
-	/// @return le nombre minimum accepte de colonnes
+	/// @return la hauteur de la bordure
-	int     minNbColumns()        const { return(min_nb_columns);                }
+	qreal   borderWidth()        const { return(diagramWidth());                  }
+	/// @return la hauteur de la bordure
+	qreal   borderHeight()       const { return(diagramHeight() + insetHeight()); }
 	
 	// methodes d'acces en lecture aux informations du cartouche
 	/// @return le champ "Auteur" du cartouche
@@ -80,16 +102,23 @@ class BorderInset : public QObject {
 	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 les entetes des lignes sont affiches, false sinon
+	bool    rowsAreDisplayed()    const { return(display_rows);          }
 	/// @return true si la bordure est affichee, false sinon
 	bool    borderIsDisplayed()   const { return(display_border);        }
 	
 	// methodes d'acces en ecriture aux dimensions
 	void addColumn             ();
+	void addRow                ();
 	void removeColumn          ();
+	void removeRow             ();
 	void setNbColumns          (int);
+	void setNbRows             (int);
 	void setColumnsWidth       (const qreal &);
+	void setRowsHeight         (const qreal &);
 	void setColumnsHeaderHeight(const qreal &);
-	void setColumnsHeight      (const qreal &);
+	void setRowsHeaderWidth    (const qreal &);
+	void setDiagramHeight      (const qreal &);
 	void setInsetWidth         (const qreal &);
 	void setInsetHeight        (const qreal &);
 	void adjustInsetToColumns  ();
@@ -131,11 +160,14 @@ class BorderInset : public QObject {
 	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 dr true pour afficher les entetes des lignes, false sinon
+	void displayRows           (bool dr)                 { display_rows    = dr;       }
 	/// @param db true pour afficher la bordure du schema, false sinon
 	void displayBorder         (bool db)                 { display_border  = db;       }
 	
 	private:
 	void updateRectangles();
+	QString incrementLetters(const QString &);
 	
 	// signaux
 	signals:
@@ -155,18 +187,23 @@ class BorderInset : public QObject {
 	QString bi_folio;
 	QString bi_filename;
 	
-	// dimensions du cadre et du cartouche
+	// dimensions du cadre (lignes et colonnes)
+	// colonnes : nombres et dimensions
 	int    nb_columns;
-	int    min_nb_columns;
 	qreal  columns_width;
 	qreal  columns_header_height;
-	qreal  columns_height;
+	
-	qreal  min_columns_height;
+	// lignes : nombres et dimensions
+	int    nb_rows;
+	qreal  rows_height;
+	qreal  rows_header_width;
+	
+	// dimensions du cartouche
 	qreal  inset_width;
 	qreal  inset_height;
 	
 	// rectangles utilises pour le dessin
-	QRectF  border;
+	QRectF  diagram;
 	QRectF  inset;
 	QRectF  inset_author;
 	QRectF  inset_date;
@@ -177,6 +214,7 @@ class BorderInset : public QObject {
 	// booleens pour les options de dessin
 	bool display_inset;
 	bool display_columns;
+	bool display_rows;
 	bool display_border;
 };
 #endif

sources/configpages.cpp

@@ -20,6 +20,7 @@
 #include "insetpropertieswidget.h"
 #include "qetapp.h"
 #include "qetdiagrameditor.h"
+#include "borderinset.h"
 
 /**
 	Constructeur
@@ -31,9 +32,10 @@ NewDiagramPage::NewDiagramPage(QWidget *parent) : ConfigPage(parent) {
 	QSettings &settings = QETApp::settings();
 	
 	// recupere les dimensions du schema
-	int columns_count_value  = settings.value("diagrameditor/defaultcols",       15).toInt();
+	int columns_count_value  = settings.value("diagrameditor/defaultcols", 15).toInt();
 	int columns_width_value  = qRound(settings.value("diagrameditor/defaultcolsize",  50.0).toDouble());
-	int columns_height_value = qRound(settings.value("diagrameditor/defaultheight",  500.0).toDouble());
+	int rows_count_value     = settings.value("diagrameditor/defaultrows",  6).toDouble();
+	int rows_height_value    = qRound(settings.value("diagrameditor/defaultrowsize",  80.0).toDouble());
 	
 	QVBoxLayout *vlayout1 = new QVBoxLayout();
 	
@@ -54,28 +56,35 @@ NewDiagramPage::NewDiagramPage(QWidget *parent) : ConfigPage(parent) {
 	QLabel *ds1 = new QLabel(tr("Colonnes :"));
 	
 	columns_count = new QSpinBox(diagram_size_box);
-	columns_count -> setMinimum(3); /// @todo methode statique pour recuperer ca
+	columns_count -> setMinimum(BorderInset::minNbColumns());
 	columns_count -> setValue(columns_count_value);
 	
 	columns_width = new QSpinBox(diagram_size_box);
-	columns_width -> setMinimum(1);
+	columns_width -> setMinimum(BorderInset::minColumnsWidth());
 	columns_width -> setSingleStep(10);
 	columns_width -> setValue(columns_width_value);
 	columns_width -> setPrefix(tr("\327"));
 	columns_width -> setSuffix(tr("px"));
 	
-	QLabel *ds2 = new QLabel(tr("Hauteur :"));
+	QLabel *ds2 = new QLabel(tr("Lignes :"));
 	
-	columns_height = new QSpinBox(diagram_size_box);
+	rows_count = new QSpinBox(diagram_size_box);
-	columns_height -> setRange(80, 10000); /// @todo methode statique pour recuperer ca
+	rows_count -> setMinimum(BorderInset::minNbRows());
-	columns_height -> setSingleStep(80);
+	rows_count -> setValue(rows_count_value);
-	columns_height -> setValue(columns_height_value);
+	
+	rows_height  = new QSpinBox(diagram_size_box);
+	rows_height -> setMinimum(BorderInset::minRowsHeight());
+	rows_height -> setSingleStep(10);
+	rows_height -> setValue(rows_height_value);
+	rows_height -> setPrefix(tr("\327"));
+	rows_height -> setSuffix(tr("px"));
 	
 	diagram_size_box_layout -> addWidget(ds1,            0, 0);
 	diagram_size_box_layout -> addWidget(columns_count,  0, 1);
 	diagram_size_box_layout -> addWidget(columns_width,  0, 2);
 	diagram_size_box_layout -> addWidget(ds2,            1, 0);
-	diagram_size_box_layout -> addWidget(columns_height, 1, 1);
+	diagram_size_box_layout -> addWidget(rows_count,     1, 1);
+	diagram_size_box_layout -> addWidget(rows_height,    1, 2);
 	
 	ipw = new InsetPropertiesWidget(QETDiagramEditor::defaultInsetProperties(), true, this);
 	
@@ -107,7 +116,8 @@ void NewDiagramPage::applyConf() {
 	// dimensions des nouveaux schemas
 	settings.setValue("diagrameditor/defaultcols",    columns_count -> value());
 	settings.setValue("diagrameditor/defaultcolsize", columns_width -> value());
-	settings.setValue("diagrameditor/defaultheight",  columns_height -> value());
+	settings.setValue("diagrameditor/defaultrows",    rows_count    -> value());
+	settings.setValue("diagrameditor/defaultrowsize", rows_height   -> value());
 	
 	// proprietes du cartouche
 	InsetProperties inset = ipw-> insetProperties();

sources/configpages.h

@@ -65,7 +65,8 @@ class NewDiagramPage : public ConfigPage {
 	public:
 	QSpinBox *columns_count;        ///< Widget d'edition du nombre par defaut de colonnes
 	QSpinBox *columns_width;        ///< Widget d'edition de la largeur par defaut des colonnes
-	QSpinBox *columns_height;       ///< Widget d'edition de la hauteur par defaut des colonnes
+	QSpinBox *rows_count;           ///< Widget d'edition du nombre par defaut de lignes
+	QSpinBox *rows_height;          ///< Widget d'edition de la hauteur par defaut des lignes
 	InsetPropertiesWidget *ipw;     ///< Widget d'edition des proprietes par defaut du cartouche
 	ConductorPropertiesWidget *cpw; ///< Widget d'edition des proprietes par defaut des conducteurs
 };

sources/diagram.cpp

@@ -247,9 +247,12 @@ QDomDocument Diagram::toXml(bool diagram) {
 		if (!border_and_inset.title().isNull())     racine.setAttribute("title",    border_and_inset.title());
 		if (!border_and_inset.fileName().isNull())  racine.setAttribute("filename", border_and_inset.fileName());
 		if (!border_and_inset.folio().isNull())     racine.setAttribute("folio",    border_and_inset.folio());
-		racine.setAttribute("cols",    border_and_inset.nbColumn());
+		racine.setAttribute("cols",    border_and_inset.nbColumns());
 		racine.setAttribute("colsize", border_and_inset.columnsWidth());
-		racine.setAttribute("height",  border_and_inset.columnsHeight());
+		racine.setAttribute("rows",    border_and_inset.nbRows());
+		racine.setAttribute("rowsize", border_and_inset.rowsHeight());
+		// attribut datant de la version 0.1 - laisse pour retrocompatibilite
+		racine.setAttribute("height",  border_and_inset.diagramHeight());
 		
 		// type de conducteur par defaut
 		QDomElement default_conductor = document.createElement("defaultconductor");
@@ -353,9 +356,20 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in
 		double col_size = root.attribute("colsize").toDouble(&ok);
 		if (ok) border_and_inset.setColumnsWidth(col_size);
 		
-		// hauteur du schema
+		// retrocompatibilite : les schemas enregistres avec la 0.1 ont un attribut "height"
-		double height = root.attribute("height").toDouble(&ok);
+		if (root.hasAttribute("rows") && root.hasAttribute("rowsize")) {
-		if (ok) border_and_inset.setColumnsHeight(height);
+			// nombre de lignes
+			int nb_rows = root.attribute("rows").toInt(&ok);
+			if (ok) border_and_inset.setNbRows(nb_rows);
+			
+			// taille des lignes
+			double row_size = root.attribute("rowsize").toDouble(&ok);
+			if (ok) border_and_inset.setRowsHeight(row_size);
+		} else {
+			// hauteur du schema
+			double height = root.attribute("height").toDouble(&ok);
+			if (ok) border_and_inset.setDiagramHeight(height);
+		}
 		
 		border_and_inset.adjustInsetToColumns();
 		

sources/diagramcommands.cpp

@@ -540,9 +540,11 @@ ChangeBorderCommand::ChangeBorderCommand(Diagram *dia, QUndoCommand *parent) :
 	QUndoCommand(QObject::tr("modifier les dimensions du sch\351ma"), parent),
 	diagram(dia),
 	columnsCountDifference(0),
-	columnsHeightDifference(0.0),
+	rowsCountDifference(0),
 	columnsWidthDifference(0.0),
-	headersHeightDifference(0.0)
+	rowsHeightDifference(0.0),
+	headersHeightDifference(0.0),
+	headersWidthDifference(0.0)
 {
 }
 
@@ -561,17 +563,23 @@ void ChangeBorderCommand::applyChanges(int coeff) {
 	// reference vers l'objet border_and_inset du schema
 	BorderInset &border = diagram -> border_and_inset;
 	if (columnsCountDifference) {
-		border.setNbColumns(border.nbColumn() + (columnsCountDifference * coeff));
+		border.setNbColumns(border.nbColumns() + (columnsCountDifference * coeff));
 	}
-	if (columnsHeightDifference) {
+	if (rowsCountDifference) {
-		border.setColumnsHeight(border.columnsHeight() + (columnsHeightDifference * coeff));
+		border.setNbRows(border.nbRows() + (rowsCountDifference * coeff));
 	}
 	if (columnsWidthDifference) {
 		border.setColumnsWidth(border.columnsWidth() + (columnsWidthDifference * coeff));
 	}
+	if (rowsHeightDifference) {
+		border.setRowsHeight(border.rowsHeight() + (rowsHeightDifference * coeff));
+	}
 	if (headersHeightDifference) {
 		border.setColumnsHeaderHeight(border.columnsHeaderHeight() + (headersHeightDifference * coeff));
 	}
+	if (headersWidthDifference) {
+		border.setRowsHeaderWidth(border.rowsHeaderWidth() + (headersWidthDifference * coeff));
+	}
 	border.adjustInsetToColumns();
 }
 

sources/diagramcommands.h

@@ -353,12 +353,16 @@ class ChangeBorderCommand : public QUndoCommand {
 	public:
 	/// nombre de colonnes ajoutees / enlevees
 	int columnsCountDifference;
-	/// delta pour la hauteur des colonnes
+	/// nombre de lignes ajoutees / enlevees
-	qreal columnsHeightDifference;
+	int rowsCountDifference;
 	/// delta pour la largeur des colonnes
 	qreal columnsWidthDifference;
+	/// delta pour la hauteur des lignes
+	qreal rowsHeightDifference;
 	/// delta pour la hauteur des entetes des colonnes
 	qreal headersHeightDifference;
+	/// delta pour la largeur des entetes des lignes
+	qreal headersWidthDifference;
 };
 
 /**

sources/diagramview.cpp

@@ -27,7 +27,7 @@
 
 /**
 	Constructeur
-	@param parent Le QWidegt parent de cette vue de schema
+	@param parent Le QWidget parent de cette vue de schema
 */
 DiagramView::DiagramView(QWidget *parent) : QGraphicsView(parent), is_adding_text(false) {
 	setAttribute(Qt::WA_DeleteOnClose, true);
@@ -67,7 +67,7 @@ DiagramView::~DiagramView() {
 }
 
 /**
-	appelle la methode select sur tous les elements de la liste d'elements
+	Appelle la methode select sur tous les elements de la liste d'elements
 */
 void DiagramView::selectAll() {
 	if (scene -> items().isEmpty()) return;
@@ -117,7 +117,7 @@ void DiagramView::rotateSelection() {
 }
 
 /**
-	accepte ou refuse le drag'n drop en fonction du type de donnees entrant
+	Accepte ou refuse le drag'n drop en fonction du type de donnees entrant
 	@param e le QDragEnterEvent correspondant au drag'n drop tente
 */
 void DiagramView::dragEnterEvent(QDragEnterEvent *e) {
@@ -126,14 +126,14 @@ void DiagramView::dragEnterEvent(QDragEnterEvent *e) {
 }
 
 /**
-	gere les dragleaveevent
+	Gere les dragleaveevent
 	@param e le QDragEnterEvent correspondant au drag'n drop sortant
 */
 void DiagramView::dragLeaveEvent(QDragLeaveEvent *) {
 }
 
 /**
-	accepte ou refuse le drag'n drop en fonction du type de donnees entrant
+	Accepte ou refuse le drag'n drop en fonction du type de donnees entrant
 	@param e le QDragMoveEvent correspondant au drag'n drop tente
 */
 void DiagramView::dragMoveEvent(QDragMoveEvent *e) {
@@ -142,7 +142,7 @@ void DiagramView::dragMoveEvent(QDragMoveEvent *e) {
 }
 
 /**
-	gere les depots (drop) acceptes sur le Diagram
+	Gere les depots (drop) acceptes sur le Diagram
 	@param e le QDropEvent correspondant au drag'n drop effectue
 */
 void DiagramView::dropEvent(QDropEvent *e) {
@@ -210,7 +210,7 @@ void DiagramView::zoomReset() {
 }
 
 /**
-	copie les elements selectionnes du schema dans le presse-papier puis les supprime
+	Copie les elements selectionnes du schema dans le presse-papier puis les supprime
 */
 void DiagramView::cut() {
 	copy();
@@ -220,7 +220,7 @@ void DiagramView::cut() {
 }
 
 /**
-	copie les elements selectionnes du schema dans le presse-papier
+	Copie les elements selectionnes du schema dans le presse-papier
 */
 void DiagramView::copy() {
 	QClipboard *presse_papier = QApplication::clipboard();
@@ -551,9 +551,10 @@ void DiagramView::dialogEditInfos() {
 	InsetProperties inset = scene -> border_and_inset.exportInset();
 	
 	// recupere les dimensions du schema
-	int columns_count_value  = scene -> border_and_inset.nbColumn();
+	int columns_count_value  = scene -> border_and_inset.nbColumns();
 	int columns_width_value  = qRound(scene -> border_and_inset.columnsWidth());
-	int columns_height_value = qRound(scene -> border_and_inset.columnsHeight());
+	int rows_count_value     = scene -> border_and_inset.nbRows();
+	int rows_height_value    = qRound(scene -> border_and_inset.rowsHeight());
 	
 	// construit le dialogue
 	QDialog popup;
@@ -566,28 +567,35 @@ void DiagramView::dialogEditInfos() {
 	QLabel *ds1 = new QLabel(tr("Colonnes :"));
 	
 	QSpinBox *columns_count  = new QSpinBox(diagram_size_box);
-	columns_count -> setMinimum(scene -> border_and_inset.minNbColumns());
+	columns_count -> setMinimum(BorderInset::minNbColumns());
 	columns_count -> setValue(columns_count_value);
 	
 	QSpinBox *columns_width  = new QSpinBox(diagram_size_box);
-	columns_width -> setMinimum(1);
+	columns_width -> setMinimum(BorderInset::minColumnsWidth());
 	columns_width -> setSingleStep(10);
 	columns_width -> setValue(columns_width_value);
 	columns_width -> setPrefix(tr("\327"));
 	columns_width -> setSuffix(tr("px"));
 	
-	QLabel *ds2 = new QLabel(tr("Hauteur :"));
+	QLabel *ds2 = new QLabel(tr("Lignes :"));
 	
-	QSpinBox *columns_height = new QSpinBox(diagram_size_box);
+	QSpinBox *rows_count = new QSpinBox(diagram_size_box);
-	columns_height -> setRange(qRound(scene -> border_and_inset.minColumnsHeight()), 10000);
+	rows_count -> setMinimum(BorderInset::minNbRows());
-	columns_height -> setSingleStep(80);
+	rows_count -> setValue(rows_count_value);
-	columns_height -> setValue(columns_height_value);
+	
+	QSpinBox *rows_height  = new QSpinBox(diagram_size_box);
+	rows_height -> setMinimum(BorderInset::minRowsHeight());
+	rows_height -> setSingleStep(10);
+	rows_height -> setValue(rows_height_value);
+	rows_height -> setPrefix(tr("\327"));
+	rows_height -> setSuffix(tr("px"));
 	
 	diagram_size_box_layout.addWidget(ds1,            0, 0);
 	diagram_size_box_layout.addWidget(columns_count,  0, 1);
 	diagram_size_box_layout.addWidget(columns_width,  0, 2);
 	diagram_size_box_layout.addWidget(ds2,            1, 0);
-	diagram_size_box_layout.addWidget(columns_height, 1, 1);
+	diagram_size_box_layout.addWidget(rows_count,     1, 1);
+	diagram_size_box_layout.addWidget(rows_height,    1, 2);
 	diagram_size_box_layout.setColumnStretch(0, 1);
 	diagram_size_box_layout.setColumnStretch(1, 1);
 	diagram_size_box_layout.setColumnStretch(2, 1);
@@ -619,12 +627,14 @@ void DiagramView::dialogEditInfos() {
 		if (
 			columns_count_value  != columns_count  -> value() ||\
 			columns_width_value  != columns_width  -> value() ||\
-			columns_height_value != columns_height -> value()
+			rows_count_value     != rows_count     -> value() ||\
+			rows_height_value    != rows_height    -> value()
 		) {
 			ChangeBorderCommand *cbc = new ChangeBorderCommand(scene);
 			cbc -> columnsCountDifference  = columns_count  -> value() - columns_count_value;
 			cbc -> columnsWidthDifference  = columns_width  -> value() - columns_width_value;
-			cbc -> columnsHeightDifference = columns_height -> value() - columns_height_value;
+			cbc -> rowsCountDifference     = rows_count     -> value() - rows_count_value;
+			cbc -> rowsHeightDifference    = rows_height    -> value() - rows_height_value;
 			scene -> undoStack().push(cbc);
 		}
 	}
@@ -658,18 +668,18 @@ void DiagramView::removeColumn() {
 /**
 	Agrandit le schema en hauteur
 */
-void DiagramView::expand() {
+void DiagramView::addRow() {
 	ChangeBorderCommand *cbc = new ChangeBorderCommand(scene);
-	cbc -> columnsHeightDifference = 80.0;
+	cbc -> rowsCountDifference = 1;
 	scene -> undoStack().push(cbc);
 }
 
 /**
 	Retrecit le schema en hauteur
 */
-void DiagramView::shrink() {
+void DiagramView::removeRow() {
 	ChangeBorderCommand *cbc = new ChangeBorderCommand(scene);
-	cbc -> columnsHeightDifference = -80.0;
+	cbc -> rowsCountDifference = -1;
 	scene -> undoStack().push(cbc);
 }
 
@@ -897,8 +907,8 @@ void DiagramView::contextMenuEvent(QContextMenuEvent *e) {
 			context_menu -> addAction(qde -> infos_diagram);
 			context_menu -> addAction(qde -> add_column);
 			context_menu -> addAction(qde -> remove_column);
-			context_menu -> addAction(qde -> expand_diagram);
+			context_menu -> addAction(qde -> add_row);
-			context_menu -> addAction(qde -> shrink_diagram);
+			context_menu -> addAction(qde -> remove_row);
 		} else {
 			context_menu -> addAction(qde -> cut);
 			context_menu -> addAction(qde -> copy);
@@ -936,7 +946,7 @@ void DiagramView::mouseDoubleClickEvent(QMouseEvent *e) {
 	// recupere le rectangle corespondant au cartouche
 	QRectF inset_rect(
 		Diagram::margin,
-		Diagram::margin + bi.columnsHeight(),
+		Diagram::margin + bi.diagramHeight(),
 		bi.insetWidth(),
 		bi.insetHeight()
 	);
@@ -949,6 +959,14 @@ void DiagramView::mouseDoubleClickEvent(QMouseEvent *e) {
 		bi.columnsHeaderHeight()
 	);
 	
+	// recupere le rectangle correspondant aux en-tetes des lignes
+	QRectF rows_rect(
+		Diagram::margin,
+		Diagram::margin,
+		bi.rowsHeaderWidth(),
+		bi.diagramHeight()
+	);
+	
 	// coordonnees du clic par rapport au schema
 	QPointF click_pos = viewportTransform().inverted().map(e -> pos());
 	
@@ -959,7 +977,7 @@ void DiagramView::mouseDoubleClickEvent(QMouseEvent *e) {
 		} else {
 			QGraphicsView::mouseDoubleClickEvent(e);
 		}
-	} else if (inset_rect.contains(click_pos) || columns_rect.contains(click_pos)) {
+	} else if (inset_rect.contains(click_pos) || columns_rect.contains(click_pos) || rows_rect.contains(click_pos)) {
 		// edite les proprietes du schema
 		dialogEditInfos();
 	} else {

sources/diagramview.h

@@ -59,8 +59,8 @@ class DiagramView : public QGraphicsView {
 	void dialogPrint();
 	void addColumn();
 	void removeColumn();
-	void expand();
+	void addRow();
-	void shrink();
+	void removeRow();
 	/// @return Le schema visualise par ce DiagramView
 	Diagram *diagram() { return(scene); }
 	QETDiagramEditor *diagramEditor() const;

sources/exportdialog.cpp

@@ -70,6 +70,7 @@ ExportDialog::ExportDialog(Diagram *dia, QWidget *parent) : QDialog(parent) {
 	connect(draw_border,       SIGNAL(stateChanged(int) ), this, SLOT(slot_refreshPreview()));
 	connect(draw_inset,        SIGNAL(stateChanged(int) ), this, SLOT(slot_refreshPreview()));
 	connect(draw_columns,      SIGNAL(stateChanged(int) ), this, SLOT(slot_refreshPreview()));
+	connect(draw_rows,         SIGNAL(stateChanged(int) ), this, SLOT(slot_refreshPreview()));
 	connect(draw_terminals,    SIGNAL(stateChanged(int) ), this, SLOT(slot_refreshPreview()));
 	connect(width,             SIGNAL(valueChanged(int) ), this, SLOT(slot_refreshPreview()));
 	connect(height,            SIGNAL(valueChanged(int) ), this, SLOT(slot_refreshPreview()));
@@ -158,6 +159,11 @@ QGroupBox *ExportDialog::setupOptionsGroupBox() {
 	optionshlayout -> addWidget(draw_columns, 2, 1);
 	draw_columns -> setChecked(diagram -> border_and_inset.columnsAreDisplayed());
 	
+	// dessiner les lignes
+	draw_rows = new QCheckBox(tr("Dessiner les lignes"), groupbox_options);
+	optionshlayout -> addWidget(draw_rows, 3, 1);
+	draw_rows -> setChecked(diagram -> border_and_inset.rowsAreDisplayed());
+	
 	// dessiner les bornes
 	draw_terminals = new QCheckBox(tr("Dessiner les bornes"), groupbox_options);
 	optionshlayout -> addWidget(draw_terminals, 3, 0);
@@ -305,6 +311,7 @@ QImage ExportDialog::generateImage() {
 void ExportDialog::saveReloadDiagramParameters(bool save) {
 	static bool state_drawBorder;
 	static bool state_drawColumns;
+	static bool state_drawRows;
 	static bool state_drawInset;
 	static bool state_drawGrid;
 	static bool state_drawTerm;
@@ -314,6 +321,7 @@ void ExportDialog::saveReloadDiagramParameters(bool save) {
 		// memorise les parametres relatifs au schema
 		state_drawBorder  = diagram -> border_and_inset.borderIsDisplayed();
 		state_drawColumns = diagram -> border_and_inset.columnsAreDisplayed();
+		state_drawRows    = diagram -> border_and_inset.rowsAreDisplayed();
 		state_drawInset   = diagram -> border_and_inset.insetIsDisplayed();
 		state_drawGrid    = diagram -> displayGrid();
 		state_drawTerm    = diagram -> drawTerminals();
@@ -324,11 +332,13 @@ void ExportDialog::saveReloadDiagramParameters(bool save) {
 		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.displayRows(draw_rows -> isChecked());
 		diagram -> border_and_inset.displayInset(draw_inset -> isChecked());
 	} else {
 		// restaure les parametres relatifs au schema
 		diagram -> border_and_inset.displayBorder(state_drawBorder);
 		diagram -> border_and_inset.displayColumns(state_drawColumns);
+		diagram -> border_and_inset.displayRows(state_drawRows);
 		diagram -> border_and_inset.displayInset(state_drawInset);
 		diagram -> setDisplayGrid(state_drawGrid);
 		diagram -> setDrawTerminals(state_drawTerm);

sources/exportdialog.h

@@ -48,6 +48,7 @@ class ExportDialog : public QDialog {
 	QCheckBox *draw_border;
 	QCheckBox *draw_inset;
 	QCheckBox *draw_columns;
+	QCheckBox *draw_rows;
 	QCheckBox *draw_terminals;
 	QRadioButton *export_elements;
 	QRadioButton *export_border;

sources/hotspoteditor.cpp

@@ -44,8 +44,11 @@ HotspotEditor::HotspotEditor(QWidget *parent) :
 	sb_hotspot_y -> setSingleStep(10);
 	
 	diagram_scene = new Diagram();
-	diagram_scene -> border_and_inset.setNbColumns(4);
+	diagram_scene -> border_and_inset.setColumnsWidth(50.0);
-	diagram_scene -> border_and_inset.setColumnsHeight(140);
+	diagram_scene -> border_and_inset.setNbColumns(3);
+	diagram_scene -> border_and_inset.setRowsHeight(60.0);
+	diagram_scene -> border_and_inset.setNbRows(2);
+	diagram_scene -> border_and_inset.displayRows(false);
 	diagram_scene -> border_and_inset.displayInset(false);
 	
 	diagram_view = new QGraphicsView(diagram_scene);

sources/qetdiagrameditor.cpp

@@ -194,8 +194,8 @@ void QETDiagramEditor::actions() {
 	add_text          = new QAction(QIcon(":/ico/textfield.png"),  tr("Ajouter un champ de texte"),            this);
 	add_column        = new QAction(QIcon(":/ico/add_col.png"),    tr("Ajouter une colonne"),                  this);
 	remove_column     = new QAction(QIcon(":/ico/remove_col.png"), tr("Enlever une colonne"),                  this);
-	expand_diagram    = new QAction(                               tr("Agrandir le sch\351ma"),                this);
+	add_row           = new QAction(QIcon(":/ico/add_row.png"),    tr("Ajouter une ligne"),                    this);
-	shrink_diagram    = new QAction(                               tr("R\351tr\351cir le sch\351ma"),          this);
+	remove_row        = new QAction(QIcon(":/ico/remove_row.png"), tr("Enlever une ligne"),                    this);
 	
 	zoom_in           = new QAction(QIcon(":/ico/viewmag+.png"),   tr("Zoom avant"),                           this);
 	zoom_out          = new QAction(QIcon(":/ico/viewmag-.png"),   tr("Zoom arri\350re"),                      this);
@@ -281,8 +281,8 @@ void QETDiagramEditor::actions() {
 	infos_diagram     -> setStatusTip(tr("\311dite les informations affich\351es par le cartouche"));
 	add_column        -> setStatusTip(tr("Ajoute une colonne au sch\351ma"));
 	remove_column     -> setStatusTip(tr("Enl\350ve une colonne au sch\351ma"));
-	expand_diagram    -> setStatusTip(tr("Agrandit le sch\351ma en hauteur"));
+	add_row           -> setStatusTip(tr("Agrandit le sch\351ma en hauteur"));
-	shrink_diagram    -> setStatusTip(tr("R\351tr\351cit le sch\351ma en hauteur"));
+	remove_row        -> setStatusTip(tr("R\351tr\351cit le sch\351ma en hauteur"));
 	
 	zoom_in           -> setStatusTip(tr("Agrandit le sch\351ma"));
 	zoom_out          -> setStatusTip(tr("R\351tr\351cit le sch\351ma"));
@@ -356,8 +356,8 @@ void QETDiagramEditor::actions() {
 	connect(add_text,         SIGNAL(triggered()), this,       SLOT(slot_addText())             );
 	connect(add_column,       SIGNAL(triggered()), this,       SLOT(slot_addColumn())           );
 	connect(remove_column,    SIGNAL(triggered()), this,       SLOT(slot_removeColumn())        );
-	connect(expand_diagram,   SIGNAL(triggered()), this,       SLOT(slot_expand())              );
+	connect(add_row,          SIGNAL(triggered()), this,       SLOT(slot_addRow())              );
-	connect(shrink_diagram,   SIGNAL(triggered()), this,       SLOT(slot_shrink())              );
+	connect(remove_row,       SIGNAL(triggered()), this,       SLOT(slot_removeRow())           );
 }
 
 /**
@@ -419,8 +419,8 @@ void QETDiagramEditor::menus() {
 	menu_edition -> addAction(infos_diagram);
 	menu_edition -> addAction(add_column);
 	menu_edition -> addAction(remove_column);
-	menu_edition -> addAction(expand_diagram);
+	menu_edition -> addAction(add_row);
-	menu_edition -> addAction(shrink_diagram);
+	menu_edition -> addAction(remove_row);
 	
 	// menu Configurer > Afficher
 	QMenu *display_toolbars = createPopupMenu();
@@ -767,8 +767,8 @@ void QETDiagramEditor::slot_updateActions() {
 	add_text         -> setEnabled(opened_document);
 	add_column       -> setEnabled(opened_document);
 	remove_column    -> setEnabled(opened_document);
-	expand_diagram   -> setEnabled(opened_document);
+	add_row   -> setEnabled(opened_document);
-	shrink_diagram   -> setEnabled(opened_document);
+	remove_row   -> setEnabled(opened_document);
 	
 	// affiche les actions correspondant au diagram view en cours
 	if (sv) undo_group.setActiveStack(&(sv -> diagram() -> undoStack()));
@@ -957,45 +957,45 @@ void QETDiagramEditor::slot_updateWindowsMenu() {
 	Edite les informations du schema en cours
 */
 void QETDiagramEditor::slot_editInfos() {
-	DiagramView *sv = currentDiagram();
+	if (DiagramView *dv = currentDiagram()) {
-	if (!sv) return;
+		dv -> dialogEditInfos();
-	sv -> dialogEditInfos();
+	}
 }
 
 /**
 	Ajoute une colonne au schema en cours
 */
 void QETDiagramEditor::slot_addColumn() {
-	DiagramView *sv = currentDiagram();
+	if (DiagramView *dv = currentDiagram()) {
-	if (!sv) return;
+		dv -> addColumn();
-	sv -> addColumn();
+	}
 }
 
 /**
 	Enleve une colonne au schema en cours
 */
 void QETDiagramEditor::slot_removeColumn() {
-	DiagramView *sv = currentDiagram();
+	if (DiagramView *dv = currentDiagram()) {
-	if (!sv) return;
+		dv -> removeColumn();
-	sv -> removeColumn();
+	}
 }
 
 /**
 	Allonge le schema en cours en hauteur
 */
-void QETDiagramEditor::slot_expand() {
+void QETDiagramEditor::slot_addRow() {
-	DiagramView *sv = currentDiagram();
+	if (DiagramView *dv = currentDiagram()) {
-	if (!sv) return;
+		dv -> addRow();
-	sv -> expand();
+	}
 }
 
 /**
 	Retrecit le schema en cours en hauteur
 */
-void QETDiagramEditor::slot_shrink() {
+void QETDiagramEditor::slot_removeRow() {
-	DiagramView *sv = currentDiagram();
+	if (DiagramView *dv = currentDiagram()) {
-	if (!sv) return;
+		dv -> removeRow();
-	sv -> shrink();
+	}
 }
 
 /**

sources/qetdiagrameditor.h

@@ -92,8 +92,8 @@ class QETDiagramEditor : public QMainWindow {
 	void slot_updateWindowsMenu();
 	void slot_addColumn();
 	void slot_removeColumn();
-	void slot_expand();
+	void slot_addRow();
-	void slot_shrink();
+	void slot_removeRow();
 	void slot_editConductor();
 	void slot_resetConductors();
 	void slot_editDefaultConductors();
@@ -133,8 +133,8 @@ class QETDiagramEditor : public QMainWindow {
 	QAction *add_text;           ///< Passe en mode "Ajout de texte"
 	QAction *add_column;         ///< Ajoute une colonne au schema
 	QAction *remove_column;      ///< Enleve une colonne du schema
-	QAction *expand_diagram;     ///< Augmente la hauteur du schema
+	QAction *add_row;            ///< Augmente la hauteur du schema
-	QAction *shrink_diagram;     ///< Reduit la hauteur du schema
+	QAction *remove_row;         ///< Reduit la hauteur du schema
 	QAction *zoom_in;            ///< Zoome avant
 	QAction *zoom_out;           ///< Zoome arriere
 	QAction *zoom_fit;           ///< Ajuste le zoom de facon a voir l'integralite des elements