WIP2

sources/QetGraphicsItemModeler/qetgraphicshandleritem.h

@@ -46,7 +46,7 @@ class QetGraphicsHandlerItem : public QGraphicsItem
 		QRectF m_handler_rect,
 			   m_br;
         qreal m_size;
-        QColor m_color{Qt::black};
+		QColor m_color;
 		QPen m_pen;
 		
 	public:

sources/borderproperties.cpp

@@ -32,7 +32,15 @@
 	- 17 colonnes affichees de 60.0 px de large pour 20.0px de haut
 	- 8    lignes affichees de 80.0 px de haut pour 20.0px de large
 */
-BorderProperties::BorderProperties()
+BorderProperties::BorderProperties() :
+	columns_count(17),
+	columns_width(60.0),
+	columns_header_height(20.0),
+	display_columns(true),
+	rows_count(8),
+	rows_height(80.0),
+	rows_header_width(20.0),
+	display_rows(true)
 {
 }
 
@@ -86,21 +94,16 @@ bool BorderProperties::operator!=(const BorderProperties &bp) {
 	- XML element to which attributes will be added
 	- Element XML auquel seront ajoutes des attributs
 */
-QDomElement BorderProperties::toXml(QDomDocument &dom_doc) const {
+void BorderProperties::toXml(QDomElement &e) const {
-
+	e.setAttribute("cols",        columns_count);
-    QDomElement e = dom_doc.createElement("border");
+	e.setAttribute("colsize",     QString("%1").arg(columns_width));
-
+	e.setAttribute("rows",        rows_count);
-    e.appendChild(createXmlProperty(dom_doc, "cols", columns_count));
+	e.setAttribute("rowsize",     QString("%1").arg(rows_height));
-    e.appendChild(createXmlProperty(dom_doc, "colsize", columns_width));
+	e.setAttribute("displaycols", display_columns ? "true" : "false");
-    e.appendChild(createXmlProperty(dom_doc, "rows", rows_count));
+	e.setAttribute("displayrows", display_rows    ? "true" : "false");
-    e.appendChild(createXmlProperty(dom_doc, "rowsize", rows_height));
-    e.appendChild(createXmlProperty(dom_doc, "displayrows", display_rows));
-    e.appendChild(createXmlProperty(dom_doc, "displaycols", display_columns));
-
-    return e;
 }
 
-/**RETURNS True
+/**
 	@brief BorderProperties::fromXml
 	- Import dimensions from XML attributes of element e
 	- Importe les dimensions a partir des attributs XML de l'element e
@@ -108,29 +111,13 @@ QDomElement BorderProperties::toXml(QDomDocument &dom_doc) const {
 	- XML element whose attributes will be read
 	- Element XML dont les attributs seront lus
 */
-bool BorderProperties::fromXml(const QDomElement &e) {
+void BorderProperties::fromXml(QDomElement &e) {
-
+	if (e.hasAttribute("cols"))        columns_count   = e.attribute("cols").toInt();
-    if (propertyInteger(e, "cols", &columns_count) == PropertyFlags::NoValidConversion ||
+	if (e.hasAttribute("colsize"))     columns_width   = e.attribute("colsize").toInt();
-        propertyDouble(e, "colsize", &columns_width) == PropertyFlags::NoValidConversion ||
+	if (e.hasAttribute("rows"))        rows_count      = e.attribute("rows").toInt();
-        propertyInteger(e, "rows", &rows_count) == PropertyFlags::NoValidConversion ||
+	if (e.hasAttribute("rowsize"))     rows_height     = e.attribute("rowsize").toInt();
-        propertyDouble(e, "rowsize", &rows_height) == PropertyFlags::NoValidConversion ||
+	if (e.hasAttribute("displaycols")) display_columns = e.attribute("displaycols") == "true";
-        propertyBool(e, "displaycols", &display_columns) == PropertyFlags::NoValidConversion ||
+	if (e.hasAttribute("displayrows")) display_rows    = e.attribute("displayrows") == "true";
-        propertyBool(e, "displayrows", &display_rows) == PropertyFlags::NoValidConversion)
-        return false;
-
-    return true;
-}
-
-bool BorderProperties::valideXml(QDomElement& e) {
-
-    if (propertyInteger(e, "cols") == PropertyFlags::Success ||
-        propertyDouble(e, "colsize") == PropertyFlags::Success ||
-        propertyInteger(e, "rows") == PropertyFlags::Success ||
-        propertyDouble(e, "rowsize") == PropertyFlags::Success ||
-        propertyBool(e, "displaycols") == PropertyFlags::Success ||
-        propertyBool(e, "displayrows") == PropertyFlags::Success)
-        return true;
-    return false;
 }
 
 /**
@@ -164,7 +151,7 @@ void BorderProperties::toSettings(QSettings &settings, const QString &prefix) co
 	- prefix to be added before the names of the parameters
 	- prefixe a ajouter devant les noms des parametres
 */
-void BorderProperties::fromSettings(const QSettings &settings, const QString &prefix) {
+void BorderProperties::fromSettings(QSettings &settings, const QString &prefix) {
 	columns_count   = settings.value(prefix + "cols",            columns_count).toInt();
 	columns_width   = qRound(settings.value(prefix + "colsize",  columns_width).toDouble());
 	display_columns = settings.value(prefix + "displaycols",     display_columns).toBool();

sources/borderproperties.h

@@ -20,15 +20,13 @@
 #include <QtCore>
 #include <QtXml>
 
-#include "propertiesinterface.h"
-
 /**
 	@brief The BorderProperties class
 	This class is a container for dimensions and display properties of a
 	diagram.
 	@remark Attributes are public
 */
-class BorderProperties : public PropertiesInterface {
+class BorderProperties {
 	public:
 		// constructor, destructor, operators
 		BorderProperties();
@@ -37,23 +35,22 @@ class BorderProperties : public PropertiesInterface {
 		bool operator==(const BorderProperties &);
 		bool operator!=(const BorderProperties &);
 	
-        QDomElement toXml(QDomDocument &dom_doc) const override;
+		void toXml(QDomElement &) const;
-        bool fromXml(const QDomElement &) override;
+		void fromXml(QDomElement &);
-        static bool valideXml(QDomElement& e);
+		void toSettings(QSettings &, const QString & = QString()) const;
-        void toSettings(QSettings &, const QString & = QString()) const override;
+		void fromSettings(QSettings &, const QString & = QString());
-        void fromSettings(const QSettings &, const QString & = QString()) override;
 
 		static BorderProperties defaultProperties();
 	
 		// attributes
-        int columns_count{17};            ///< Columns count
+		int columns_count;            ///< Columns count
-        qreal columns_width{60.0};          ///< Columns width
+		qreal columns_width;          ///< Columns width
-        qreal columns_header_height{20.0};  ///< Column headers height
+		qreal columns_header_height;  ///< Column headers height
-        bool display_columns{true};         ///< Whether to display column headers
+		bool display_columns;         ///< Whether to display column headers
 	
-        int rows_count{8};               ///< Rows count
+		int rows_count;               ///< Rows count
-        qreal rows_height{80.0};            ///< Rows height
+		qreal rows_height;            ///< Rows height
-        qreal rows_header_width{20.0};      ///< Row headers width
+		qreal rows_header_width;      ///< Row headers width
-        bool display_rows{true};            ///< Whether to display row headers
+		bool display_rows;            ///< Whether to display row headers
 };
 #endif

sources/bordertitleblock.cpp

@@ -168,8 +168,8 @@ QRectF BorderTitleBlock::insideBorderRect() const
 	Exports the title block current values to XML.
 	@param xml_elmt the XML element attributes will be added to
 */
-void BorderTitleBlock::titleBlockToXml(QDomElement& doc) {
+void BorderTitleBlock::titleBlockToXml(QDomElement &xml_elmt) {
-    exportTitleBlock().toXml(doc);
+	exportTitleBlock().toXml(xml_elmt);
 }
 
 /**

sources/bordertitleblock.h

@@ -152,7 +152,7 @@ class BorderTitleBlock : public QObject
 		void setPreviousFolioNum(const QString &previous);
 		void setNextFolioNum(const QString &next);
 		
-        void titleBlockToXml(QDomElement &doc);
+		void titleBlockToXml(QDomElement &);
 		void titleBlockFromXml(const QDomElement &);
 		void borderToXml(QDomElement &);
 		void borderFromXml(const QDomElement &);

sources/conductorproperties.cpp

@@ -22,7 +22,11 @@
 /**
 	Constructeur par defaut
 */
-SingleLineProperties::SingleLineProperties()
+SingleLineProperties::SingleLineProperties() :
+	hasGround(true),
+	hasNeutral(true),
+	is_pen(false),
+	phases(1)
 {
 }
 
@@ -192,17 +196,11 @@ void SingleLineProperties::drawPen(QPainter *painter, QET::ConductorSegmentType
 	ajoutes a l'element e.
 	@param e Element XML auquel seront ajoutes des attributs
 */
-QDomElement SingleLineProperties::toXml(QDomDocument &doc) const {
+void SingleLineProperties::toXml(QDomElement &e) const {
-
+	e.setAttribute("ground",  hasGround  ? "true" : "false");
-    QDomElement e = doc.createElement("SingleLine");
+	e.setAttribute("neutral", hasNeutral ? "true" : "false");
-    e.appendChild(createXmlProperty(doc, "ground", hasGround));
+	e.setAttribute("phase",   phases);
-    e.appendChild(createXmlProperty(doc, "neutral", hasNeutral));
+	if (isPen()) e.setAttribute("pen", "true");
-    e.appendChild(createXmlProperty(doc, "phase", phases));
-
-    if (isPen())
-        e.appendChild(createXmlProperty(doc, "pen", true));
-
-    return e;
 }
 
 /**
@@ -210,36 +208,11 @@ QDomElement SingleLineProperties::toXml(QDomDocument &doc) const {
 	de l'element e
 	@param e Element XML dont les attributs seront lus
 */
-bool SingleLineProperties::fromXml(const QDomElement &e) {
+void SingleLineProperties::fromXml(QDomElement &e) {
-    if (propertyBool(e, "ground", &hasGround) != PropertyFlags::Success ||
+	hasGround  = e.attribute("ground")  == "true";
-        propertyBool(e, "neutral", &hasNeutral) != PropertyFlags::Success)
+	hasNeutral = e.attribute("neutral") == "true";
-        return false;
+	setPhasesCount(e.attribute("phase").toInt());
-
+	is_pen = (hasGround && hasNeutral && e.attribute("pen", "false") == "true");
-    int phase;
-    if (propertyInteger(e, "phase", &phase) != PropertyFlags::Success)
-        return false;
-    setPhasesCount(phase);
-
-    bool pen;
-    if (propertyBool(e, "pen", &pen) != PropertyFlags::Success)
-        return false;
-    is_pen = (hasGround && hasNeutral && pen);
-
-    return true;
-}
-
-bool SingleLineProperties::valideXml(QDomElement& e) {
-    if (propertyBool(e, "ground") != PropertyFlags::Success ||
-        propertyBool(e, "neutral") != PropertyFlags::Success)
-        return false;
-
-    if (propertyInteger(e, "phase") != PropertyFlags::Success)
-        return false;
-
-    if (propertyBool(e, "pen") != PropertyFlags::Success)
-        return false;
-
-    return true;
 }
 
 /**
@@ -272,134 +245,99 @@ ConductorProperties::~ConductorProperties() {
  * Export conductor propertie, in the XML element 'e'
  * @param e the xml element
  */
-QDomElement ConductorProperties::toXml(QDomDocument& doc) const
+void ConductorProperties::toXml(QDomElement &e) const
 {
+	e.setAttribute("type", typeToString(type));
 
-    QDomElement e = doc.createElement("defaultconductor");
+	if (color != QColor(Qt::black))
+		e.setAttribute("color", color.name());
 	
-    e.appendChild(createXmlProperty(doc, "type", typeToString(type)));
+	e.setAttribute("bicolor", m_bicolor? "true" : "false");
-    e.appendChild(createXmlProperty(doc, "color", color));
+	e.setAttribute("color2", m_color_2.name());
-
+	e.setAttribute("dash-size", QString::number(m_dash_size));
-    e.appendChild(createXmlProperty(doc, "bicolor", m_bicolor));
-    e.appendChild(createXmlProperty(doc, "color2", m_color_2));
-    e.appendChild(createXmlProperty(doc, "dash-size", m_dash_size));
 	
 	if (type == Single)
-        e.appendChild(singleLineProperties.toXml(doc));
+		singleLineProperties.toXml(e);
 
-    e.appendChild(createXmlProperty(doc, "num", text));
+	e.setAttribute("num", text);
-    e.appendChild(createXmlProperty(doc, "text_color", text_color));
+	e.setAttribute("text_color", text_color.name());
-    e.appendChild(createXmlProperty(doc, "formula", m_formula));
+	e.setAttribute("formula", m_formula);
-    e.appendChild(createXmlProperty(doc, "function", m_function));
+	e.setAttribute("function", m_function);
-    e.appendChild(createXmlProperty(doc, "tension_protocol", m_tension_protocol));
+	e.setAttribute("tension_protocol", m_tension_protocol);
-    e.appendChild(createXmlProperty(doc, "conductor_color", m_wire_color));
+	e.setAttribute("conductor_color", m_wire_color);
-    e.appendChild(createXmlProperty(doc, "conductor_section", m_wire_section));
+	e.setAttribute("conductor_section", m_wire_section);
-    e.appendChild(createXmlProperty(doc, "numsize", text_size));
+	e.setAttribute("numsize", QString::number(text_size));
-    e.appendChild(createXmlProperty(doc, "condsize", cond_size));
+	e.setAttribute("condsize", QString::number(cond_size));
-    e.appendChild(createXmlProperty(doc, "displaytext", m_show_text));
+	e.setAttribute("displaytext", m_show_text);
-    e.appendChild(createXmlProperty(doc, "onetextperfolio", m_one_text_per_folio));
+	e.setAttribute("onetextperfolio", m_one_text_per_folio);
-    e.appendChild(createXmlProperty(doc, "onetextperfolio", verti_rotate_text));
+	e.setAttribute("vertirotatetext", QString::number(verti_rotate_text));
-    e.appendChild(createXmlProperty(doc, "horizrotatetext", horiz_rotate_text));
+	e.setAttribute("horizrotatetext", QString::number(horiz_rotate_text));
 	
 	QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
-    e.appendChild(createXmlProperty(doc, "horizontal-alignment", me.valueToKey(m_horizontal_alignment)));
+	e.setAttribute("horizontal-alignment", me.valueToKey(m_horizontal_alignment));
-    e.appendChild(createXmlProperty(doc, "vertical-alignment", me.valueToKey(m_vertical_alignment)));
+	e.setAttribute("vertical-alignment", me.valueToKey(m_vertical_alignment));
 	
 	QString conductor_style = writeStyle();
 	if (!conductor_style.isEmpty())
-        e.appendChild(createXmlProperty(doc, "style", conductor_style));
+		e.setAttribute("style", conductor_style);
-
-    return e;
 }
 
 
-/** RETURNS True
+/**
  * @brief ConductorProperties::fromXml
  * Import conductor propertie, from the attribute of the xml element 'e'
  * @param e the xml document
  */
-bool ConductorProperties::fromXml(const QDomElement &e)
+void ConductorProperties::fromXml(QDomElement &e)
 {
 		// get conductor color
-    propertyColor(e, "color", &color);
+	QColor xml_color= QColor(e.attribute("color"));
-    propertyBool(e, "bicolor", &m_bicolor);
+	color = (xml_color.isValid()? xml_color : QColor(Qt::black));
-    propertyColor(e, "color2", &m_color_2);
+
-    propertyInteger(e, "dash-size", &m_dash_size);
+	QString bicolor_str = e.attribute("bicolor", "false");
+	m_bicolor = bicolor_str == "true"? true : false;
+	
+	QColor xml_color_2 = QColor(e.attribute("color2"));
+	m_color_2 = xml_color_2.isValid()? xml_color_2 : QColor(Qt::black);
+	
+	m_dash_size = e.attribute("dash-size", QString::number(1)).toInt();
 	
 		// read style of conductor
-    QString style_string;
+	readStyle(e.attribute("style"));
-    propertyString(e, "style", &style_string);
-    readStyle(style_string);
 	
-    QString type_t;
+	if (e.attribute("type") == typeToString(Single))
-    if (propertyString(e, "type", &type_t) == PropertyFlags::Success) {
+	{
-        if (type_t == typeToString(Single))
+			// get specific properties for single conductor
-        {
+		singleLineProperties.fromXml(e);
-                // get specific properties for single conductor
+		type = Single;
-            singleLineProperties.fromXml(e);
+	}
-            type = Single;
+	else
-        }
+		type = Multi;
-        else if (type_t == typeToString(Multi))
-            type = Multi;
-        else {
-            //Keep retrocompatible with version older than 0,4
-            //If the propertie @type is simple (removed since QET 0,4), we set text no visible.
-            //@TODO remove this code for qet 0.6 or later
-
-            if (type_t == "simple") m_show_text = false;
-        }
-    }
-
-    propertyString(e, "num", &text);
 
+	text                 = e.attribute("num");
 	// get text color
-    propertyColor(e, "text_color", &text_color);
+	QColor xml_text_color= QColor(e.attribute("text_color"));
-    propertyString(e, "formula", &m_formula);
+	text_color = (xml_text_color.isValid()? xml_text_color : QColor(Qt::black));
-    propertyString(e, "function", &m_function);
+	m_formula            = e.attribute("formula");
-    propertyString(e, "tension_protocol", &m_tension_protocol);
+	m_function           = e.attribute("function");
-    propertyString(e, "conductor_color", &m_wire_color);
+	m_tension_protocol   = e.attribute("tension_protocol");
-    propertyString(e, "conductor_section", &m_wire_section);
+	m_wire_color         = e.attribute("conductor_color");
-    propertyInteger(e, "numsize", &text_size);
+	m_wire_section       = e.attribute("conductor_section");
-    propertyDouble(e, "condsize", &cond_size);
+	text_size            = e.attribute("numsize", QString::number(9)).toInt();
-    propertyBool(e, "displaytext", &m_show_text);
+	cond_size            = e.attribute("condsize", QString::number(1)).toDouble();
-    propertyBool(e, "onetextperfolio", &m_one_text_per_folio);
+	m_show_text          = e.attribute("displaytext", QString::number(1)).toInt();
-    propertyDouble(e, "vertirotatetext", &verti_rotate_text);
+	m_one_text_per_folio = e.attribute("onetextperfolio", QString::number(0)).toInt();
-    propertyDouble(e, "horizrotatetext", &horiz_rotate_text);
+	verti_rotate_text    = e.attribute("vertirotatetext").toDouble();
+	horiz_rotate_text    = e.attribute("horizrotatetext").toDouble();
 	
 	QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
+	m_horizontal_alignment = Qt::Alignment(me.keyToValue(e.attribute("horizontal-alignment", "AlignBottom").toStdString().data()));
+	m_vertical_alignment = Qt::Alignment(me.keyToValue(e.attribute("vertical-alignment", "AlignRight").toStdString().data()));
 
-    QString alinment_temp;
+		//Keep retrocompatible with version older than 0,4
-    if (propertyString(e, "horizontal-alignment", &alinment_temp) == PropertyFlags::Success)
+		//If the propertie @type is simple (removed since QET 0,4), we set text no visible.
-        m_horizontal_alignment = Qt::Alignment(me.keyToValue(alinment_temp.toStdString().data()));
+		//@TODO remove this code for qet 0.6 or later
-    if (propertyString(e, "vertical-alignment", &alinment_temp) == PropertyFlags::Success)
+	if (e.attribute("type") == "simple") m_show_text = false;
-        m_vertical_alignment = Qt::Alignment(me.keyToValue(alinment_temp.toStdString().data()));
-
-    return true;
-}
-
-bool ConductorProperties::valideXml(QDomElement& e) {
-    if (propertyColor(e, "color") ||
-        propertyBool(e, "bicolor") ||
-        propertyColor(e, "color2") ||
-        propertyInteger(e, "dash-size") ||
-        propertyString(e, "type") ||
-        propertyString(e, "num") ||
-        propertyColor(e, "text_color") ||
-        propertyString(e, "formula") ||
-        propertyString(e, "function") ||
-        propertyString(e, "tension_protocol") ||
-        propertyString(e, "conductor_color") ||
-        propertyString(e, "conductor_section") ||
-        propertyInteger(e, "numsize") ||
-        propertyDouble(e, "condsize") ||
-        propertyBool(e, "displaytext") ||
-        propertyBool(e, "onetextperfolio") ||
-        propertyDouble(e, "vertirotatetext") ||
-        propertyDouble(e, "horizrotatetext") ||
-        propertyString(e, "horizontal-alignment") ||
-        propertyString(e, "vertical-alignment"))
-        return false;
-    return true;
 }
 
 /**
@@ -439,7 +377,7 @@ void ConductorProperties::toSettings(QSettings &settings, const QString &prefix)
 	@param settings Parametres a lire
 	@param prefix prefixe a ajouter devant les noms des parametres
 */
-void ConductorProperties::fromSettings(const QSettings &settings, const QString &prefix)
+void ConductorProperties::fromSettings(QSettings &settings, const QString &prefix)
 {
 	QColor settings_color = QColor(settings.value(prefix + "color").toString());
 	color = (settings_color.isValid()? settings_color : QColor(Qt::black));
@@ -883,7 +821,7 @@ void SingleLineProperties::toSettings(QSettings &settings, const QString &prefix
 	@param settings Parametres a lire
 	@param prefix prefix a ajouter devant les noms des parametres
 */
-void SingleLineProperties::fromSettings(const QSettings &settings, const QString &prefix) {
+void SingleLineProperties::fromSettings(QSettings &settings, const QString &prefix) {
 	hasGround  = settings.value(prefix + "hasGround",  true).toBool();
 	hasNeutral = settings.value(prefix + "hasNeutral", true).toBool();
 	phases     = settings.value(prefix + "phases",     1).toInt();

sources/conductorproperties.h

@@ -22,14 +22,12 @@
 #include <QColor>
 #include <QSettings>
 
-#include "propertiesinterface.h"
-
 class QPainter;
 
 /**
 	This class represents the properties of a singleline conductor.
 */
-class SingleLineProperties: public PropertiesInterface {
+class SingleLineProperties {
 	public:
 	SingleLineProperties();
 	virtual ~SingleLineProperties();
@@ -38,24 +36,23 @@ class SingleLineProperties: public PropertiesInterface {
 	unsigned short int phasesCount();
 	bool isPen() const;
 	void draw(QPainter *, QET::ConductorSegmentType, const QRectF &);
-    QDomElement toXml(QDomDocument& doc) const override;
+	void toXml(QDomElement &) const;
-    bool fromXml(const QDomElement &) override;
+	void fromXml(QDomElement &);
-    static bool valideXml(QDomElement& element);
+	void toSettings(QSettings &, const QString & = QString()) const;
-    void toSettings(QSettings &, const QString & = QString()) const override;
+	void fromSettings(QSettings &, const QString & = QString());
-    void fromSettings(const QSettings &, const QString & = QString()) override;  
 	
 	/// Whether the singleline conductor should display the ground symbol
-    bool hasGround{true};
+	bool hasGround;
 	/// Whether the singleline conductor should display the neutral symbol
-    bool hasNeutral{true};
+	bool hasNeutral;
 	/// Protective Earth Neutral: visually merge neutral and ground
-    bool is_pen{false};
+	bool is_pen;
 	
 	int operator==(const SingleLineProperties &) const;
 	int operator!=(const SingleLineProperties &) const;
 	
 	private:
-    unsigned short int phases{1};
+	unsigned short int phases;
 	void drawGround (QPainter *, QET::ConductorSegmentType, QPointF, qreal);
 	void drawNeutral(QPainter *, QET::ConductorSegmentType, QPointF, qreal);
 	void drawPen(QPainter *, QET::ConductorSegmentType, QPointF, qreal);
@@ -65,7 +62,7 @@ class SingleLineProperties: public PropertiesInterface {
 	This class represents the functional properties of a particular conductor,
 	i.e. properties other than path and terminals.
 */
-class ConductorProperties: public PropertiesInterface
+class ConductorProperties
 {
 	public:
 		ConductorProperties();
@@ -80,12 +77,11 @@ class ConductorProperties: public PropertiesInterface
 
 
 			//Attributes
-        ConductorType type{ConductorType::Single};
+		ConductorType type;
 		
-        // TODO: set default values!
+		QColor		color,
-        QColor		color{QColor(Qt::black)},
+				m_color_2,
-                m_color_2{QColor(Qt::black)},
+				text_color;
-                text_color{QColor(Qt::black)};
 		
 		QString text,
 				m_function,
@@ -94,30 +90,29 @@ class ConductorProperties: public PropertiesInterface
 				m_wire_section,
 				m_formula;
 		
-        int text_size{9},
+		int text_size,
 			m_dash_size = 1;
 		
-            double  cond_size{1},
+		double  cond_size,
 				verti_rotate_text,
 				horiz_rotate_text;
 		
-        bool	m_show_text{true},
+		bool	m_show_text,
-                m_one_text_per_folio{true},
+				m_one_text_per_folio,
 				m_bicolor = false;
 		
 		Qt::Alignment m_horizontal_alignment = Qt::AlignBottom,
 					  m_vertical_alignment = Qt::AlignRight;
 		
-        Qt::PenStyle style{Qt::PenStyle::SolidLine};
+		Qt::PenStyle style;
 		
 		SingleLineProperties singleLineProperties;
 	
 			// methods
-        QDomElement toXml(QDomDocument &doc) const override;
+		void toXml(QDomElement &) const;
-        bool fromXml(const QDomElement &) override;
+		void fromXml(QDomElement &);
-        static bool valideXml(QDomElement& element);
+		void toSettings(QSettings &, const QString & = QString()) const;
-        void toSettings(QSettings &, const QString & = QString()) const override;
+		void fromSettings(QSettings &, const QString & = QString());
-        void fromSettings(const QSettings &, const QString & = QString()) override;
 		static QString typeToString(ConductorType);
 		void applyForEqualAttributes(QList<ConductorProperties> list);
 

sources/diagram.cpp

@@ -624,12 +624,13 @@ QDomDocument Diagram::toXml(bool whole_content) {
 	
 	// proprietes du schema
 	if (whole_content) {
-        // TODO: compare with old version
+		border_and_titleblock.titleBlockToXml(dom_root);
-        border_and_titleblock.titleBlockToXml(dom_root);
 		border_and_titleblock.borderToXml(dom_root);
 		
 		// Default conductor properties
-        dom_root.appendChild(defaultConductorProperties.toXml(document));
+		QDomElement default_conductor = document.createElement("defaultconductor");
+		defaultConductorProperties.toXml(default_conductor);
+		dom_root.appendChild(default_conductor);
 
 		// Conductor autonum
 		if (!m_conductors_autonum_name.isEmpty()) {
@@ -750,11 +751,12 @@ QDomDocument Diagram::toXml(bool whole_content) {
 	}
 	
 		// table de correspondance entre les adresses des bornes et leurs ids
+	QHash<Terminal *, int> table_adr_id;
 	
 	if (!list_elements.isEmpty()) {
 		auto dom_elements = document.createElement("elements");
 		for (auto elmt : list_elements) {
-            dom_elements.appendChild(elmt->toXml(document));
+			dom_elements.appendChild(elmt->toXml(document, table_adr_id));
 		}
 		dom_root.appendChild(dom_elements);
 	}
@@ -762,7 +764,7 @@ QDomDocument Diagram::toXml(bool whole_content) {
 	if (!list_conductors.isEmpty()) {
 		auto dom_conductors = document.createElement("conductors");
 		for (auto cond : list_conductors) {
-            dom_conductors.appendChild(cond->toXml(document));
+			dom_conductors.appendChild(cond->toXml(document, table_adr_id));
 		}
 		dom_root.appendChild(dom_conductors);
 	}
@@ -870,14 +872,14 @@ bool Diagram::initFromXml(QDomElement &document, QPointF position, bool consider
  * \param added_elements Elements found in the xml file
  * \return
  */
-Terminal* findTerminal(int conductor_index, QDomElement& conductor, QHash<int, Terminal *>& table_adr_id, QList<Element *>& added_elements) {
+Terminal* findTerminal(int conductor_index, QDomElement& f, QHash<int, Terminal *>& table_adr_id, QList<Element *>& added_elements) {
 	assert(conductor_index == 1 || conductor_index == 2);
 
 	QString element_index = "element" + QString::number(conductor_index);
 	QString terminal_index = "terminal" + QString::number(conductor_index);
 
-    QUuid element_uuid;
+	if (f.hasAttribute(element_index)) {
-    if (PropertiesInterface::propertyUuid(conductor, element_index, &element_uuid) == PropertiesInterface::PropertyFlags::Success) {
+		QUuid element_uuid = QUuid(f.attribute(element_index));
 		// element1 did not exist in the conductor part of the xml until prior 0.7
 		// It is used as an indicator that uuid's are used to identify terminals
 		bool element_found = false;
@@ -885,8 +887,7 @@ Terminal* findTerminal(int conductor_index, QDomElement& conductor, QHash<int, T
 			if (element->uuid() != element_uuid)
 				continue;
 			element_found = true;
-            QUuid terminal_uuid;
+			QUuid terminal_uuid = QUuid(f.attribute(terminal_index));
-            PropertiesInterface::propertyUuid(conductor, terminal_index, &terminal_uuid);
 			for (auto terminal: element->terminals()) {
 				if (terminal->uuid() != terminal_uuid)
 					continue;
@@ -900,16 +901,12 @@ Terminal* findTerminal(int conductor_index, QDomElement& conductor, QHash<int, T
 			qDebug() << "Diagram::fromXml() : " <<  element_index << ": " << element_uuid << "not found";
 	} else {
 		// Backward compatibility. Until version 0.7 a generated id is used to link the terminal.
-        int id_p1 = -1;
+		int id_p1 = f.attribute(terminal_index).toInt();
-        if (PropertiesInterface::propertyInteger(conductor, terminal_index, &id_p1) != PropertiesInterface::PropertyFlags::Success) {
-            qDebug() << "diagramm.cpp:findTerminal(): Reading Id was not successfull";
-        }
 		if (!table_adr_id.contains(id_p1)) {
 			qDebug() << "Diagram::fromXml() : terminal id " << id_p1 << " not found";
 		} else
 			return table_adr_id.value(id_p1);
 	}
-    qDebug() << "Diagram::findTerminal(): No terminal found.";
 	return nullptr;
 }
 
@@ -927,11 +924,11 @@ Terminal* findTerminal(int conductor_index, QDomElement& conductor, QHash<int, T
 	@return true si l'import a reussi, false sinon
 */
 bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_informations, DiagramContent *content_ptr) {
-    const QDomElement& root = document;
+	const QDomElement& root = document;
 	// The first element must be a diagram
 	if (root.tagName() != "diagram") return(false);
 
-    qDebug() << "Diagram::fromXml; Diagram: " << root.attribute("title");
+    qDebug() << "Diagram: " << root.attribute("title");
 	
 	// Read attributes of this diagram
 	if (consider_informations) {
@@ -943,7 +940,7 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 		}
 		
 		// Load border and titleblock
-        border_and_titleblock.titleBlockFromXml(root);
+		border_and_titleblock.titleBlockFromXml(root);
 		border_and_titleblock.borderFromXml(root);
 		
 		// Find the element "defaultconductor".
@@ -953,7 +950,6 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 			defaultConductorProperties.fromXml(default_conductor_elmt);
 		}
 
-
 		// Load the autonum
 		m_conductors_autonum_name = root.attribute("conductorAutonum");
 
@@ -1011,10 +1007,10 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 			}
 		}
 	}
-        //Load all elements from the collection in the XML
+		//Load all elements from the XML
 	QList<Element *> added_elements;
 	QHash<int, Terminal *> table_adr_id;
-    foreach (QDomElement element_xml, QET::findInDomElement(root, "elements", "element")) // read all elements from the diagram
+	foreach (QDomElement element_xml, QET::findInDomElement(root, "elements", "element"))
 	{
 		if (!Element::valideXml(element_xml)) continue;
 		
@@ -1029,8 +1025,8 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 		}
 		
 		int state = 0;
-        // Create element from the collection
+        qDebug() << "Element from collection: " << element_location;
-        Element *nvel_elmt = ElementFactory::Instance() -> createElement(element_location, nullptr, &state); // read element definition from the collection!
+		Element *nvel_elmt = ElementFactory::Instance() -> createElement(element_location, nullptr, &state);
 		if (state)
 		{
 			QString debug_message = QString("Diagram::fromXml() : Le chargement de la description de l'element %1 a echoue avec le code d'erreur %2").arg(element_location.path()).arg(state);
@@ -1041,7 +1037,7 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 		
 		addItem(nvel_elmt);
 			//Loading fail, remove item from the diagram
-        if (!nvel_elmt->fromXml(element_xml, table_adr_id, handle_inputs_rotation)) // load element definition from the diagram
+		if (!nvel_elmt->fromXml(element_xml, table_adr_id, handle_inputs_rotation))
 		{
 			removeItem(nvel_elmt);
 			delete nvel_elmt;
@@ -1080,29 +1076,27 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf
 
 		// Load conductor
 	QList<Conductor *> added_conductors;
-    foreach (QDomElement conductorElement, QET::findInDomElement(root, "conductors", "conductor"))
+	foreach (QDomElement f, QET::findInDomElement(root, "conductors", "conductor"))
 	{
-        if (!Conductor::valideXml(conductorElement)) continue;
+		if (!Conductor::valideXml(f)) continue;
 
 			//Check if terminal that conductor must be linked is know
 
-        Terminal* p1 = findTerminal(1, conductorElement, table_adr_id, added_elements);
+		Terminal* p1 = findTerminal(1, f, table_adr_id, added_elements);
-        Terminal* p2 = findTerminal(2, conductorElement, table_adr_id, added_elements);
+		Terminal* p2 = findTerminal(2, f, table_adr_id, added_elements);
 
-        if (p1 && p2 && p1 != p2) // why the condition for unequal is required?
+		if (p1 && p2 && p1 != p2)
 		{
 			Conductor *c = new Conductor(p1, p2);
 			if (c->isValid())
 			{
 				addItem(c);
-                c -> fromXml(conductorElement);
+				c -> fromXml(f);
 				added_conductors << c;
 			}
 			else
 				delete c;
-        } else {
+		}
-            qDebug() << "Diagramm::fromXML(): No matching terminals found.";
-        }
 	}
 
 		//Load tables

sources/diagram.h

@@ -96,7 +96,7 @@ class Diagram : public QGraphicsScene
 		/// margin around the diagram
 		static const qreal margin;
 		/// background color of diagram
-        static QColor background_color; // default value set in cpp file
+		static QColor background_color;
 		/// Hash containing max values for folio sequential autonums in this diagram
 		QHash <QString, QStringList> m_elmt_unitfolio_max;
 		QHash <QString, QStringList> m_elmt_tenfolio_max;
@@ -166,7 +166,7 @@ class Diagram : public QGraphicsScene
 		QList < QSet <Conductor *> > potentials();
 	
 		// methods related to XML import/export
-        QDomDocument toXml(bool = true);
+		QDomDocument toXml(bool = true);
 		bool initFromXml(QDomElement &, QPointF = QPointF(),
 				bool = true, DiagramContent * = nullptr);
 		bool fromXml(QDomDocument &, QPointF = QPointF(),

sources/diagramcontext.cpp

@@ -118,7 +118,7 @@ int DiagramContext::count() {
 
 /**
  * @brief DiagramContext::keyMustShow
- * @return the value pairs with key, if key no found, return false
+ * @return the value pairs with key, if key not found, return false
  */
 bool DiagramContext::keyMustShow(const QString &key) const {
 	if (m_content_show.contains(key))
@@ -197,17 +197,15 @@ void DiagramContext::toSettings(QSettings &settings, const QString &array_name)
 	Read this context properties from \a settings by running through the array
 	named \a array_name.
 */
-void DiagramContext::fromSettings(const QSettings &settings, const QString &array_name) {
+void DiagramContext::fromSettings(QSettings &settings, const QString &array_name) {
-    // TODO: find better solution than const cast
+	int size = settings.beginReadArray(array_name);
-    QSettings& s = const_cast<QSettings&>(settings);
-    int size = s.beginReadArray(array_name);
 	for (int i = 0 ; i < size; ++ i) {
-        s.setArrayIndex(i);
+		settings.setArrayIndex(i);
 		QString key = settings.value("name").toString();
 		if (key.isEmpty()) continue;
 		addValue(key, settings.value("value").toString());
 	}
-    s.endArray();
+	settings.endArray();
 }
 
 /**

sources/diagramcontext.h

@@ -79,7 +79,7 @@ class DiagramContext
 		void fromXml(const QDomElement &, const QString & = "property");
 		void fromXml(const pugi::xml_node &dom_element, const QString &tag_name = "property");
 		void toSettings(QSettings &, const QString &) const;
-        void fromSettings(const QSettings &, const QString &);
+		void fromSettings(QSettings &, const QString &);
 		
 		static QString validKeyRegExp();
 	

sources/diagramprintdialog.cpp

@@ -41,6 +41,7 @@ DiagramPrintDialog::DiagramPrintDialog(QETProject *project, QWidget *parent) :
 	
 	// orientation paysage par defaut
 	printer_ -> setOrientation(QPrinter::Landscape);
+	backup_diagram_background_color = Diagram::background_color;
 	Diagram::background_color = Qt::white;
 }
 

sources/diagramprintdialog.h

@@ -88,6 +88,6 @@ class DiagramPrintDialog : public QWidget
 	QLineEdit *filepath_field_;
 	QPushButton *browse_button_;
 	QDialogButtonBox *buttons_;
-    QColor backup_diagram_background_color{Diagram::background_color};
+	QColor backup_diagram_background_color;
 };
 #endif

sources/editor/graphicspart/customelementgraphicpart.cpp

@@ -144,7 +144,7 @@ void CustomElementGraphicPart::setAntialiased(const bool b)
  * Each style separate by ; and name-style/value are separate by :
  * @param qde : QDOmElement used to write the style.
  */
-void CustomElementGraphicPart::stylesToXml(QDomDocument &xml_document, QDomElement &qde) const
+void CustomElementGraphicPart::stylesToXml(QDomElement &qde) const
 {
 	QString css_like_styles;
 	
@@ -479,8 +479,9 @@ void CustomElementGraphicPart::stylesToXml(QDomDocument &xml_document, QDomEleme
 	else if (_color == HTMLGrayBlackColor)  css_like_styles += "HTMLGrayBlack";
 	else if (_color == NoneColor)  css_like_styles += "none";
 
-    qde.appendChild(createXmlProperty(xml_document, "style", css_like_styles));
+
-    qde.appendChild(createXmlProperty(xml_document, "antialias", _antialiased ? "true" : "false"));
+	qde.setAttribute("style", css_like_styles);
+	qde.setAttribute("antialias", _antialiased ? "true" : "false");
 }
 
 
@@ -493,18 +494,13 @@ void CustomElementGraphicPart::stylesFromXml(const QDomElement &qde)
 {
 	resetStyles();
 	
-    QString style_string;
-    propertyString(qde, "style", &style_string);
-	
 		//Get the list of pair style/value
 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)	// ### Qt 6: remove
-    QStringList styles = style_string.split(";", QString::SkipEmptyParts);
+	QStringList styles = qde.attribute("style").split(";", QString::SkipEmptyParts);
 #else
-    QStringList styles = style_string.split(";", Qt::SkipEmptyParts);
+	QStringList styles = qde.attribute("style").split(";", Qt::SkipEmptyParts);
 #endif
 	
-
-	
 		//Check each pair of style
 	QRegExp rx("^\\s*([a-z-]+)\\s*:\\s*([a-zA-Z-]+)\\s*$");
 	foreach (QString style, styles)
@@ -847,9 +843,7 @@ void CustomElementGraphicPart::stylesFromXml(const QDomElement &qde)
 		}
 	}
 		//Get antialiasing
-    QString a;
+	_antialiased = qde.attribute("antialias") == "true";
-    propertyString(qde, "antialias", &a);
-    _antialiased = a == "true";
 }
 
 

sources/editor/graphicspart/customelementgraphicpart.h

@@ -95,7 +95,7 @@ class CustomElementGraphicPart : public QGraphicsObject, public CustomElementPar
         virtual void resetAllHandlerColor() {}
 
 	protected:
-        void stylesToXml  (QDomDocument &xml_document, QDomElement &) const;
+		void stylesToXml  (QDomElement &) const;
 		void stylesFromXml(const QDomElement &);
 		void resetStyles  ();
 		void applyStylesToQPainter(QPainter &) const;

sources/editor/graphicspart/customelementpart.h

@@ -19,7 +19,6 @@
 #define CUSTOM_ELEMENT_PART_H
 
 #include "qet.h"
-#include "propertiesinterface.h"
 
 class CustomElement;
 class ElementPrimitiveDecorator;
@@ -36,7 +35,7 @@ class QGraphicsSceneMouseEvent;
 	is no point for those classes to store their visual representation with
 	anything more complex than a QImage.
 */
-class CustomElementPart: public PropertiesInterface {
+class CustomElementPart {
 	// constructors, destructor
 	public:
 	/**
@@ -56,6 +55,14 @@ class CustomElementPart: public PropertiesInterface {
 	
 	// methods
 	public:
+	/**
+		Load the primitive from an XML element that describes it
+	*/
+	virtual void fromXml(const QDomElement &) = 0;
+	/**
+		Export the primitive as an XML element
+	*/
+	virtual const QDomElement toXml(QDomDocument &) const = 0;
 	/**
 		Set a specific property of the primitive
 	*/

sources/editor/graphicspart/partarc.cpp

@@ -95,21 +95,17 @@ void PartArc::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
  * @param xml_document : Xml document to use for create the xml element.
  * @return : an xml element that describe this arc
  */
-QDomElement PartArc::toXml(QDomDocument &xml_document) const {
+const QDomElement PartArc::toXml(QDomDocument &xml_document) const {
 	QDomElement xml_element = xml_document.createElement("arc");
 	QPointF top_left(sceneTopLeft());
-
+	xml_element.setAttribute("x", QString("%1").arg(top_left.x()));
-    xml_element.appendChild(createXmlProperty(xml_document, "x", top_left.x()));
+	xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
-    xml_element.appendChild(createXmlProperty(xml_document, "y", top_left.y()));
+	xml_element.setAttribute("width",  QString("%1").arg(rect().width()));
-    xml_element.appendChild(createXmlProperty(xml_document, "width", rect().width()));
+	xml_element.setAttribute("height", QString("%1").arg(rect().height()));
-    xml_element.appendChild(createXmlProperty(xml_document, "height", rect().height()));
+		//to maintain compatibility with the previous version, we write the angle in degrees.
-
+	xml_element.setAttribute("start", QString("%1").arg(m_start_angle / 16));
-    //to maintain compatibility with the previous version, we write the angle in degrees.
+	xml_element.setAttribute("angle", QString("%1").arg(m_span_angle / 16));
-    xml_element.appendChild(createXmlProperty(xml_document, "start", m_start_angle / 16));
+	stylesToXml(xml_element);
-    xml_element.appendChild(createXmlProperty(xml_document, "angle", m_span_angle / 16));
-
-
-	stylesToXml(xml_document, xml_element);
 	return(xml_element);
 }
 
@@ -118,41 +114,15 @@ QDomElement PartArc::toXml(QDomDocument &xml_document) const {
  * Import the properties of this arc from a xml element.
  * @param qde : Xml document to use.
  */
-bool PartArc::fromXml(const QDomElement &qde) {
+void PartArc::fromXml(const QDomElement &qde) {
-    stylesFromXml(qde);
+	stylesFromXml(qde);
+	m_rect = QRectF(mapFromScene(qde.attribute("x", "0").toDouble(),
+								 qde.attribute("y", "0").toDouble()),
+					QSizeF(qde.attribute("width",  "0").toDouble(),
+						   qde.attribute("height", "0").toDouble()) );
 
-    double x=0, y=0, w=0, h=0;
+	m_start_angle = qde.attribute("start", "0").toDouble() * 16;
-    if (propertyDouble(qde, "x", &x) == PropertyFlags::NoValidConversion ||
+	m_span_angle  = qde.attribute("angle", "-1440").toDouble() * 16;
-        propertyDouble(qde, "y", &y) == PropertyFlags::NoValidConversion ||
-        propertyDouble(qde, "width", &w) == PropertyFlags::NoValidConversion ||
-        propertyDouble(qde, "height", &h) == PropertyFlags::NoValidConversion)
-        return false;
-
-    m_rect = QRectF(mapFromScene(x, y), QSizeF(w, h) );
-
-    m_start_angle = 0;
-    if (propertyDouble(qde, "start", &m_start_angle)  == PropertyFlags::NoValidConversion)
-        return false;
-    m_start_angle *= 16;
-
-    m_span_angle = -1440;
-    if (propertyDouble(qde, "angle", &m_span_angle) == PropertyFlags::NoValidConversion)
-        return false;
-    m_span_angle *= 16;
-
-    return true;
-}
-
-bool PartArc::valideXml(QDomElement& element) {
-
-    if (propertyDouble(element, "x") == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "y") == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "width") == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "height") == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "start")  == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "angle") == PropertyFlags::NoValidConversion)
-        return false;
-    return true;
 }
 
 /**

sources/editor/graphicspart/partarc.h

@@ -51,9 +51,8 @@ class PartArc : public AbstractPartEllipse
 			//Name and XML
 		QString name()    const override { return(QObject::tr("arc", "element part name")); }
 		QString xmlName() const override { return(QString("arc")); }
-        QDomElement toXml   (QDomDocument &) const override;
+		const QDomElement toXml   (QDomDocument &) const override;
-        bool fromXml (const QDomElement &) override;
+		void              fromXml (const QDomElement &) override;
-        static bool valideXml(QDomElement& element);
 
 		QPainterPath shape() const override;
 		QPainterPath shadowShape() const override;

sources/editor/graphicspart/partdynamictextfield.cpp

@@ -85,38 +85,37 @@ void PartDynamicTextField::handleUserTransformation(const QRectF &initial_select
  * @param document
  * @return 
  */
-QDomElement PartDynamicTextField::toXml(QDomDocument &dom_doc) const
+const QDomElement PartDynamicTextField::toXml(QDomDocument &dom_doc) const
 {
 	QDomElement root_element = dom_doc.createElement(xmlName());
 	
-    root_element.appendChild(createXmlProperty(dom_doc, "x", pos().x()));
+	root_element.setAttribute("x", QString::number(pos().x()));
-    root_element.appendChild(createXmlProperty(dom_doc, "y", pos().y()));
+	root_element.setAttribute("y", QString::number(pos().y()));
-    root_element.appendChild(createXmlProperty(dom_doc, "z", zValue()));
+	root_element.setAttribute("z", QString::number(zValue()));
-    root_element.appendChild(createXmlProperty(dom_doc, "rotation", QET::correctAngle(rotation())));
+	root_element.setAttribute("rotation", QString::number(QET::correctAngle(rotation())));
-
+	root_element.setAttribute("font", font().toString());
-    root_element.appendChild(createXmlProperty(dom_doc, "font", font().toString()));
+	root_element.setAttribute("uuid", m_uuid.toString());
-    root_element.appendChild(createXmlProperty(dom_doc, "uuid", m_uuid));
+	root_element.setAttribute("frame", m_frame? "true" : "false");
-    root_element.appendChild(createXmlProperty(dom_doc, "frame", m_frame));
+	root_element.setAttribute("text_width", QString::number(m_text_width));
-    root_element.appendChild(createXmlProperty(dom_doc, "text_width", m_text_width));
 	
 
 	QMetaEnum me = DynamicElementTextItem::textFromMetaEnum();
-    root_element.appendChild(createXmlProperty(dom_doc, "text_from", me.valueToKey(m_text_from)));
+	root_element.setAttribute("text_from", me.valueToKey(m_text_from));
 	
 	me = QMetaEnum::fromType<Qt::Alignment>();
 	if(this->alignment() &Qt::AlignRight)
-        root_element.appendChild(createXmlProperty(dom_doc, "Halignment", me.valueToKey(Qt::AlignRight)));
+		root_element.setAttribute("Halignment", me.valueToKey(Qt::AlignRight));
 	else if(this->alignment() &Qt::AlignLeft)
-        root_element.appendChild(createXmlProperty(dom_doc, "Halignment", me.valueToKey(Qt::AlignLeft)));
+		root_element.setAttribute("Halignment", me.valueToKey(Qt::AlignLeft));
 	else if(this->alignment() &Qt::AlignHCenter)
-        root_element.appendChild(createXmlProperty(dom_doc, "Halignment", me.valueToKey(Qt::AlignHCenter)));
+		root_element.setAttribute("Halignment", me.valueToKey(Qt::AlignHCenter));
 	
 	if(this->alignment() &Qt::AlignBottom)
-        root_element.appendChild(createXmlProperty(dom_doc, "Valignment", me.valueToKey(Qt::AlignBottom)));
+		root_element.setAttribute("Valignment", me.valueToKey(Qt::AlignBottom));
 	else if(this->alignment() & Qt::AlignTop)
-        root_element.appendChild(createXmlProperty(dom_doc, "Valignment", me.valueToKey(Qt::AlignTop)));
+		root_element.setAttribute("Valignment", me.valueToKey(Qt::AlignTop));
 	else if(this->alignment() &Qt::AlignVCenter)
-        root_element.appendChild(createXmlProperty(dom_doc, "Valignment", me.valueToKey(Qt::AlignVCenter)));
+		root_element.setAttribute("Valignment", me.valueToKey(Qt::AlignVCenter));
 	
     QDomElement dom_text = dom_doc.createElement("text");
     dom_text.appendChild(dom_doc.createTextNode(toPlainText()));
@@ -153,54 +152,39 @@ QDomElement PartDynamicTextField::toXml(QDomDocument &dom_doc) const
  * @brief PartDynamicTextField::fromXml
  * @param element
  */
-bool PartDynamicTextField::fromXml(const QDomElement &dom_elmt)
+void PartDynamicTextField::fromXml(const QDomElement &dom_elmt)
 {
 	if (dom_elmt.tagName() != xmlName()) {
 		qDebug() << "PartDynamicTextField::fromXml : Wrong tagg name";
-        return false;
+		return;
 	}
 	
-    double x=0, y=0, z=0, rot=0;
+	QGraphicsTextItem::setPos(dom_elmt.attribute("x", QString::number(0)).toDouble(),
+							  dom_elmt.attribute("y", QString::number(0)).toDouble());
+	setZValue(dom_elmt.attribute("z", QString::number(zValue())).toDouble());
+	QGraphicsTextItem::setRotation(dom_elmt.attribute("rotation", QString::number(0)).toDouble());
 
-    if (propertyDouble(dom_elmt, "x", &x) == PropertyFlags::NoValidConversion ||
+	if (dom_elmt.hasAttribute("font"))
-        propertyDouble(dom_elmt, "y", &y) == PropertyFlags::NoValidConversion ||
-        propertyDouble(dom_elmt, "z", &z) == PropertyFlags::NoValidConversion ||
-        propertyDouble(dom_elmt, "rotation", &rot) == PropertyFlags::NoValidConversion)
-        return false;
-	
-    QGraphicsTextItem::setPos(x, y);
-    setZValue(z);
-    QGraphicsTextItem::setRotation(rot);
-
-    QString font;
-    if (propertyString(dom_elmt, "font", &font) == PropertyFlags::Success)
 	{
 		QFont font_;
-        font_.fromString(font);
+		font_.fromString(dom_elmt.attribute("font"));
 		setFont(font_);
 	} else {	//Keep compatibility TODO remove in futur
 		setFont(QETApp::dynamicTextsItemFont(9));
 	}
 
-    propertyUuid(dom_elmt, "uuid", &m_uuid);
+	m_uuid = QUuid(dom_elmt.attribute("uuid", QUuid::createUuid().toString()));
-    bool frame;
+	setFrame(dom_elmt.attribute("frame", "false") == "true"? true : false);
-    propertyBool(dom_elmt, "frame", &frame);
+	setTextWidth(dom_elmt.attribute("text_width", QString::number(-1)).toDouble());
-
-    double text_width=-1;
-    propertyDouble(dom_elmt, "text_width", &text_width);
-    setTextWidth(text_width);
 	
 	QMetaEnum me = DynamicElementTextItem::textFromMetaEnum();
-    QString text_from;
+	m_text_from = DynamicElementTextItem::TextFrom(me.keyToValue(dom_elmt.attribute("text_from").toStdString().data()));
-    propertyString(dom_elmt, "text_from", &text_from);
-    m_text_from = DynamicElementTextItem::TextFrom(me.keyToValue(text_from.toStdString().data()));
 	
 	me = QMetaEnum::fromType<Qt::Alignment>();
-    QString alignment;
+	if(dom_elmt.hasAttribute("Halignment"))
-    if(propertyString(dom_elmt, "Halignment", &alignment) != PropertyFlags::NotFound)
+		setAlignment(Qt::Alignment(me.keyToValue(dom_elmt.attribute("Halignment").toStdString().data())));
-        setAlignment(Qt::Alignment(me.keyToValue(alignment.toStdString().data())));
+	if(dom_elmt.hasAttribute(("Valignment")))
-    if(propertyString(dom_elmt, "Valignment", &alignment) != PropertyFlags::NotFound)
+		setAlignment(Qt::Alignment(me.keyToValue(dom_elmt.attribute("Valignment").toStdString().data())) | this->alignment());
-        setAlignment(Qt::Alignment(me.keyToValue(alignment.toStdString().data())) | this->alignment());
 
 		//Text
     QDomElement dom_text = dom_elmt.firstChildElement("text");
@@ -226,29 +210,6 @@ bool PartDynamicTextField::fromXml(const QDomElement &dom_elmt)
 	QDomElement dom_color = dom_elmt.firstChildElement("color");
 	if(!dom_color.isNull())
 		setColor(QColor(dom_color.text()));
-
-    return true;
-}
-
-bool PartDynamicTextField::valideXml(QDomElement& dom_elmt) {
-    if (propertyDouble(dom_elmt, "x") == PropertyFlags::NoValidConversion ||
-        propertyDouble(dom_elmt, "y") == PropertyFlags::NoValidConversion ||
-        propertyDouble(dom_elmt, "z") == PropertyFlags::NoValidConversion ||
-        propertyDouble(dom_elmt, "rotation") == PropertyFlags::NoValidConversion)
-        return false;
-
-    if (propertyUuid(dom_elmt, "uuid") == PropertyFlags::NoValidConversion)
-        return false;
-
-    if (propertyString(dom_elmt, "text_from"))
-        return false;
-
-    if(propertyString(dom_elmt, "Halignment") == PropertyFlags::NotFound)
-        return false;
-    if(propertyString(dom_elmt, "Valignment") == PropertyFlags::NotFound)
-        return false;
-
-    return true;
 }
 
 /**

sources/editor/graphicspart/partdynamictextfield.h

@@ -74,10 +74,9 @@ class PartDynamicTextField : public QGraphicsTextItem, public CustomElementPart
 		void startUserTransformation(const QRectF &initial_selection_rect) override;
 		void handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect) override;
 		
-        QDomElement toXml(QDomDocument &dom_doc) const override;
+		const QDomElement toXml(QDomDocument &dom_doc) const override;
-        bool fromXml(const QDomElement &dom_elmt) override;
+		void fromXml(const QDomElement &dom_elmt) override;
 		void fromTextFieldXml(const QDomElement &dom_element);
-        static bool valideXml(QDomElement& dom_elmt);
 		
 		DynamicElementTextItem::TextFrom textFrom() const;
 		void setTextFrom (DynamicElementTextItem::TextFrom text_from);
@@ -117,7 +116,7 @@ class PartDynamicTextField : public QGraphicsTextItem, public CustomElementPart
 				m_info_name,
 				m_composite_text;
 		DynamicElementTextItem::TextFrom m_text_from = DynamicElementTextItem::UserText;
-        QUuid m_uuid{QUuid::createUuid()};
+		QUuid m_uuid;
 		bool m_frame = false,
 			 m_first_add = true,
 			 m_block_alignment = false;

sources/editor/graphicspart/partellipse.cpp

@@ -76,26 +76,26 @@ void PartEllipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *optio
  * @param xml_document : Xml document to use for create the xml element.
  * @return : an xml element that describe this ellipse
  */
-QDomElement PartEllipse::toXml(QDomDocument &xml_document) const
+const QDomElement PartEllipse::toXml(QDomDocument &xml_document) const
 {
 	QDomElement xml_element;
 	if (qFuzzyCompare(rect().width(), rect().height()))
 	{
 		xml_element = xml_document.createElement("circle");
-        xml_element.appendChild(createXmlProperty(xml_document, "diameter", rect().width()));
+		xml_element.setAttribute("diameter", QString("%1").arg(rect().width()));
 	}
 	else
 	{
 		xml_element = xml_document.createElement("ellipse");
-        xml_element.appendChild(createXmlProperty(xml_document, "width", rect().width()));
+		xml_element.setAttribute("width",  QString("%1").arg(rect().width()));
-        xml_element.appendChild(createXmlProperty(xml_document, "height", rect().height()));
+		xml_element.setAttribute("height", QString("%1").arg(rect().height()));
 	}
 
 	QPointF top_left(sceneTopLeft());
-    xml_element.appendChild(createXmlProperty(xml_document, "x", top_left.x()));
+	xml_element.setAttribute("x", QString("%1").arg(top_left.x()));
-    xml_element.appendChild(createXmlProperty(xml_document, "y", top_left.y()));
+	xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
 
-	stylesToXml(xml_document, xml_element);
+	stylesToXml(xml_element);
 
 	return(xml_element);
 }
@@ -105,51 +105,22 @@ QDomElement PartEllipse::toXml(QDomDocument &xml_document) const
  * Import the properties of this ellipse from a xml element.
  * @param qde : Xml document to use.
  */
-bool PartEllipse::fromXml(const QDomElement &qde)
+void PartEllipse::fromXml(const QDomElement &qde)
 {
 	stylesFromXml(qde);
-    double x=0, y=0, width=0, height=0;
+	qreal width, height;
 
 	if (qde.tagName() == "ellipse")
 	{
-        if (propertyDouble(qde, "width", &width) == PropertyFlags::NoValidConversion ||
+		width = qde.attribute("width",  "0").toDouble();
-            propertyDouble(qde, "height", &height) == PropertyFlags::NoValidConversion)
+		height = qde.attribute("height", "0").toDouble();
-            return false;
 	}
-    else {
+	else
-        if (propertyDouble(qde, "diameter", &width) == PropertyFlags::NoValidConversion)
+		width = height = qde.attribute("diameter", "0").toDouble();
-            return false;
-        height = width;
-    }
 
-
+	m_rect = QRectF(mapFromScene(qde.attribute("x", "0").toDouble(),
-    if (propertyDouble(qde, "x", &x) == PropertyFlags::NoValidConversion ||
+								 qde.attribute("y", "0").toDouble()),
-        propertyDouble(qde, "y", &y) == PropertyFlags::NoValidConversion)
+					QSizeF(width, height));
-        return false;
-
-    m_rect = QRectF(mapFromScene(x, y), QSizeF(width, height));
-
-    return true;
-}
-
-bool PartEllipse::valideXml(QDomElement& element) {
-    if (element.tagName() == "ellipse")
-    {
-        if (propertyDouble(element, "width") & PropertyFlags::NoValidConversion ||
-            propertyDouble(element, "height") & PropertyFlags::NoValidConversion)
-            return false;
-    }
-    else {
-        if (propertyDouble(element, "diameter") & PropertyFlags::NoValidConversion)
-            return false;
-    }
-
-
-    if ((propertyDouble(element, "x") & PropertyFlags::NoValidConversion) ||
-        (propertyDouble(element, "y") & PropertyFlags::NoValidConversion))
-        return false;
-
-    return true;
 }
 
 /**

sources/editor/graphicspart/partellipse.h

@@ -52,9 +52,8 @@ class PartEllipse : public  AbstractPartEllipse
 			//Name and XML
 		QString name()    const override { return(QObject::tr("ellipse", "element part name")); }
 		QString xmlName() const override { return(QString("ellipse")); }
-        QDomElement toXml   (QDomDocument &) const override;
+		const QDomElement toXml   (QDomDocument &) const override;
-        bool  fromXml (const QDomElement &) override;
+		void              fromXml (const QDomElement &) override;
-        static bool valideXml(QDomElement& element);
 		QPainterPath shape() const override;
 		QPainterPath shadowShape() const override;
 		void setRect(const QRectF &rect) override {AbstractPartEllipse::setRect(rect); adjusteHandlerPos();}

sources/editor/graphicspart/partline.cpp

@@ -102,24 +102,22 @@ void PartLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
  * @param xml_document : Xml document to use for create the xml element.
  * @return an xml element that describe this line
  */
-QDomElement PartLine::toXml(QDomDocument &xml_document) const
+const QDomElement PartLine::toXml(QDomDocument &xml_document) const
 {
 	QPointF p1(sceneP1());
 	QPointF p2(sceneP2());
 	
 	QDomElement xml_element = xml_document.createElement("line");
+	xml_element.setAttribute("x1", QString("%1").arg(p1.x()));
+	xml_element.setAttribute("y1", QString("%1").arg(p1.y()));
+	xml_element.setAttribute("x2", QString("%1").arg(p2.x()));
+	xml_element.setAttribute("y2", QString("%1").arg(p2.y()));
+	xml_element.setAttribute("end1", Qet::endTypeToString(first_end));
+	xml_element.setAttribute("length1", QString("%1").arg(first_length));
+	xml_element.setAttribute("end2", Qet::endTypeToString(second_end));
+	xml_element.setAttribute("length2", QString("%1").arg(second_length));
 	
-    xml_element.appendChild(createXmlProperty(xml_document, "x1", p1.x()));
+	stylesToXml(xml_element);
-    xml_element.appendChild(createXmlProperty(xml_document, "y1", p1.y()));
-    xml_element.appendChild(createXmlProperty(xml_document, "x2", p2.x()));
-    xml_element.appendChild(createXmlProperty(xml_document, "y2", p2.y()));
-
-    xml_element.appendChild(createXmlProperty(xml_document, "end1", Qet::endTypeToString(first_end)));
-    xml_element.appendChild(createXmlProperty(xml_document, "length1", first_length));
-    xml_element.appendChild(createXmlProperty(xml_document, "end2", Qet::endTypeToString(second_end)));
-    xml_element.appendChild(createXmlProperty(xml_document, "length2", second_length));
-	
-	stylesToXml(xml_document, xml_element);
 	return(xml_element);
 }
 
@@ -128,48 +126,17 @@ QDomElement PartLine::toXml(QDomDocument &xml_document) const
  * Import the properties of this line from a xml element.
  * @param qde : Xml document to use
  */
-bool PartLine::fromXml(const QDomElement &qde) {
+void PartLine::fromXml(const QDomElement &qde) {
 	stylesFromXml(qde);
+	m_line = QLineF(mapFromScene(qde.attribute("x1", "0").toDouble(),
+								 qde.attribute("y1", "0").toDouble()),
+					mapFromScene(qde.attribute("x2", "0").toDouble(),
+								 qde.attribute("y2", "0").toDouble()));
 
-    double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+	first_end     = Qet::endTypeFromString(qde.attribute("end1"));
-    if (propertyDouble(qde, "x1", &x1) == PropertyFlags::NoValidConversion ||
+	first_length  = qde.attribute("length1", "1.5").toDouble();
-    propertyDouble(qde, "y1", &y1) == PropertyFlags::NoValidConversion ||
+	second_end    = Qet::endTypeFromString(qde.attribute("end2"));
-    propertyDouble(qde, "x2", &x2) == PropertyFlags::NoValidConversion ||
+	second_length = qde.attribute("length2", "1.5").toDouble();
-    propertyDouble(qde, "y2", &y2) == PropertyFlags::NoValidConversion)
-        return false;
-
-    m_line = QLineF(mapFromScene(x1, y1),
-                    mapFromScene(x2, y2));
-
-    QString s;
-    if (propertyString(qde, "end1", &s) != PropertyFlags::Success)
-        return false;
-    first_end = Qet::endTypeFromString(s);
-
-    if (propertyString(qde, "end2", &s) != PropertyFlags::Success)
-        return false;
-
-    first_end = Qet::endTypeFromString(s);
-
-    if (propertyDouble(qde, "length1", &first_length) == PropertyFlags::NoValidConversion ||
-        propertyDouble(qde, "length2", &second_length) == PropertyFlags::NoValidConversion)
-        return false;
-
-    return true;
-}
-
-bool PartLine::valideXml(QDomElement& element) const {
-    if (propertyDouble(element, "x1") ||
-        propertyDouble(element, "y1") ||
-        propertyDouble(element, "x2") ||
-        propertyDouble(element, "y2") ||
-        propertyString(element, "end1") ||
-        propertyString(element, "end2") ||
-        propertyDouble(element, "length1") ||
-        propertyDouble(element, "length2") )
-        return false;
-
-    return true;
 }
 
 /**

sources/editor/graphicspart/partline.h

@@ -70,9 +70,8 @@ class PartLine : public CustomElementGraphicPart
 		void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget * = nullptr) override;
 		QString name() const override { return(QObject::tr("ligne", "element part name")); }
 		QString xmlName() const override { return(QString("line")); }
-        QDomElement toXml(QDomDocument &) const override;
+		const QDomElement toXml(QDomDocument &) const override;
-        bool fromXml(const QDomElement &) override;
+		void fromXml(const QDomElement &) override;
-        bool valideXml(QDomElement& element) const;
 		virtual QPointF sceneP1() const;
 		virtual QPointF sceneP2() const;
 		QPainterPath shape() const override;
@@ -118,10 +117,10 @@ class PartLine : public CustomElementGraphicPart
 
 		/*****************/
 		Qet::EndType first_end;
-        qreal        first_length{1.5};
+		qreal        first_length;
 
 		Qet::EndType second_end;
-        qreal        second_length{1.5};
+		qreal        second_length;
 		QList<QPointF> saved_points_;
 		QLineF m_line;
 		int m_vector_index = -1;

sources/editor/graphicspart/partpolygon.cpp

@@ -82,37 +82,29 @@ void PartPolygon::paint(QPainter *painter, const QStyleOptionGraphicsItem *optio
  * Import the properties of this polygon from a xml element
  * @param qde : Xml document to use
  */
-bool PartPolygon::fromXml(const QDomElement &qde)
+void PartPolygon::fromXml(const QDomElement &qde)
 {
 	stylesFromXml(qde);
 
-    int error_counter = 0;
 	int i = 1;
 	while(true)
 	{
-        if (propertyDouble(qde, QString("x%1").arg(i)) == PropertyFlags::Success &&
+		if (QET::attributeIsAReal(qde, QString("x%1").arg(i)) &&\
-            propertyDouble(qde, QString("y%1").arg(i)) == PropertyFlags::Success)
+			QET::attributeIsAReal(qde, QString("y%1").arg(i)))
-            i++;
+			++ i;
 
 		else break;
 	}
 	
 	QPolygonF temp_polygon;
-    double x, y;
 	for (int j = 1 ; j < i ; ++ j)
 	{
-        error_counter += propertyDouble(qde, QString("x%1").arg(j), &x);
+		temp_polygon << QPointF(qde.attribute(QString("x%1").arg(j)).toDouble(),
-        error_counter += propertyDouble(qde, QString("y%1").arg(j), &y);
+								qde.attribute(QString("y%1").arg(j)).toDouble());
-        if (error_counter)
-            return false;
-        temp_polygon << QPointF(x, y);
 	}
 	m_polygon = temp_polygon;
 	
-    if (propertyBool(qde, "closed", &m_closed) != PropertyFlags::Success)
+	m_closed = qde.attribute("closed") != "false";
-        return false;
-
-    return true;
 }
 
 /**
@@ -121,28 +113,21 @@ bool PartPolygon::fromXml(const QDomElement &qde)
  * @param xml_document : Xml document to use for create the xml element
  * @return an xml element that describe this polygon
  */
-QDomElement PartPolygon::toXml(QDomDocument &xml_document) const
+const QDomElement PartPolygon::toXml(QDomDocument &xml_document) const
 {
 	QDomElement xml_element = xml_document.createElement("polygon");
 	int i = 1;
 	foreach(QPointF point, m_polygon) {
 		point = mapToScene(point);
-        xml_element.appendChild(createXmlProperty(xml_document, QString("x%1").arg(i), point.x()));
+		xml_element.setAttribute(QString("x%1").arg(i), QString("%1").arg(point.x()));
-        xml_element.appendChild(createXmlProperty(xml_document, QString("y%1").arg(i), point.y()));
+		xml_element.setAttribute(QString("y%1").arg(i), QString("%1").arg(point.y()));
 		++ i;
 	}
-
+	if (!m_closed) xml_element.setAttribute("closed", "false");
-    xml_element.appendChild(createXmlProperty(xml_document, "closed", m_closed));
+	stylesToXml(xml_element);
-
-    stylesToXml(xml_document, xml_element);
 	return(xml_element);
 }
 
-bool PartPolygon::valideXml(QDomElement& element) {
-    // TODO: implement
-    return true;
-}
-
 /**
  * @brief PartPolygon::isUseless
  * @return true if this part is irrelevant and does not deserve to be Retained / registered.

sources/editor/graphicspart/partpolygon.h

@@ -61,10 +61,8 @@ class PartPolygon : public CustomElementGraphicPart
 
 		QString name() const override { return(QObject::tr("polygone", "element part name")); }
 		QString xmlName() const override { return(QString("polygon")); }
-        bool fromXml(const QDomElement &) override;
+		void fromXml(const QDomElement &) override;
-        QDomElement toXml(QDomDocument &) const override;
+		const QDomElement toXml(QDomDocument &) const override;
-        static bool valideXml(QDomElement& element);
-
 
 		QPainterPath shape () const override;
 		QPainterPath shadowShape() const override;

sources/editor/graphicspart/partrectangle.cpp

@@ -77,15 +77,14 @@ void PartRectangle::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
  * @param xml_document : Xml document to use for create the xml element.
  * @return an xml element that describe this ellipse
  */
-QDomElement PartRectangle::toXml(QDomDocument &xml_document) const
+const QDomElement PartRectangle::toXml(QDomDocument &xml_document) const
 {
 	QDomElement xml_element = xml_document.createElement("rect");
 	QPointF top_left(sceneTopLeft());
-
+	xml_element.setAttribute("x", QString("%1").arg(top_left.x()));
-    xml_element.appendChild(createXmlProperty(xml_document, "x", top_left.x()));
+	xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
-    xml_element.appendChild(createXmlProperty(xml_document, "y", top_left.y()));
+	xml_element.setAttribute("width",  QString("%1").arg(m_rect.width()));
-    xml_element.appendChild(createXmlProperty(xml_document, "width", m_rect.width()));
+	xml_element.setAttribute("height", QString("%1").arg(m_rect.height()));
-    xml_element.appendChild(createXmlProperty(xml_document, "height", m_rect.height()));
 	
 	QRectF rect = m_rect.normalized();
 	qreal x = m_xRadius;
@@ -100,10 +99,7 @@ QDomElement PartRectangle::toXml(QDomDocument &xml_document) const
 	xml_element.setAttribute("rx", QString::number(m_xRadius));
 	xml_element.setAttribute("ry", QString::number(m_yRadius));
 	
-    xml_element.appendChild(createXmlProperty(xml_document, "rx", m_xRadius));
+	stylesToXml(xml_element);
-    xml_element.appendChild(createXmlProperty(xml_document, "ry", m_yRadius));
-	
-    stylesToXml(xml_document, xml_element);
 	return(xml_element);
 }
 
@@ -112,45 +108,18 @@ QDomElement PartRectangle::toXml(QDomDocument &xml_document) const
  * Import the properties of this rectangle from a xml element.
  * @param qde : Xml document to use.
  */
-bool PartRectangle::fromXml(const QDomElement &qde)
+void PartRectangle::fromXml(const QDomElement &qde)
 {
 	stylesFromXml(qde);
+	setPos(mapFromScene(qde.attribute("x", "0").toDouble(),
+						qde.attribute("y", "0").toDouble()));
 
-    double x=0, y=0, w=0, h=0, rx=0, ry=0;
+	QRectF rect(QPointF(0,0), QSizeF(qde.attribute("width",  "0").toDouble(),
-    if (propertyDouble(qde, "x", &x) == PropertyFlags::NoValidConversion ||
+									 qde.attribute("height", "0").toDouble()));
-        propertyDouble(qde, "y", &y) == PropertyFlags::NoValidConversion)
-        return false;
-
-    setPos(mapFromScene(x, y));
-
-    if (propertyDouble(qde, "width", &w) == PropertyFlags::NoValidConversion ||
-        propertyDouble(qde, "width", &h) == PropertyFlags::NoValidConversion)
-        return false;
-
-    QRectF rect(QPointF(x,y), QSizeF(w, h));
 
 	setRect(rect.normalized());
-
+	setXRadius(qde.attribute("rx", "0").toDouble());
-    if (propertyDouble(qde, "rx", &rx) == PropertyFlags::NoValidConversion ||
+	setYRadius(qde.attribute("ry", "0").toDouble());
-        propertyDouble(qde, "ry", &ry) == PropertyFlags::NoValidConversion)
-        return false;
-
-    setXRadius(rx);
-    setYRadius(ry);
-
-    return true;
-}
-
-bool PartRectangle::valideXml(QDomElement& element) {
-    // parameters have default values so no value is not a non valid xml element
-    if ((propertyDouble(element, "x") & PropertyFlags::NoValidConversion) |
-        (propertyDouble(element, "y") & PropertyFlags::NoValidConversion) |
-        (propertyDouble(element, "width") & PropertyFlags::NoValidConversion) |
-        (propertyDouble(element, "width") & PropertyFlags::NoValidConversion) |
-        (propertyDouble(element, "rx") & PropertyFlags::NoValidConversion) |
-        (propertyDouble(element, "ry") & PropertyFlags::NoValidConversion))
-        return false;
-    return true;
 }
 
 /**

sources/editor/graphicspart/partrectangle.h

@@ -60,9 +60,8 @@ class PartRectangle :  public CustomElementGraphicPart
 		QString name  () const override { return(QObject::tr("rectangle", "element part name")); }
 
 		QString           xmlName () const override { return(QString("rect")); }
-        QDomElement toXml   (QDomDocument &) const override;
+		const QDomElement toXml   (QDomDocument &) const override;
-        bool fromXml (const QDomElement &) override;
+		void              fromXml (const QDomElement &) override;
-        static bool valideXml(QDomElement& element);
 
 		QRectF rect() const;
 		void   setRect(const QRectF &rect);

sources/editor/graphicspart/partterminal.cpp

@@ -28,7 +28,6 @@ PartTerminal::PartTerminal(QETElementEditor *editor, QGraphicsItem *parent) :
     CustomElementGraphicPart(editor, parent)
 {
     d = new TerminalData(this);
-    d->m_name = tr("terminal");
     d->m_orientation = Qet::North;
     d->m_uuid = QUuid::createUuid(); // if part is loaded this uuid will be overwritten, but being sure that terminal has a uuid
 	updateSecondPoint();
@@ -43,21 +42,10 @@ PartTerminal::~PartTerminal() {
 	Importe les proprietes d'une borne depuis un element XML
 	@param xml_elmt Element XML a lire
 */
-bool PartTerminal::fromXml(const QDomElement &xml_elmt) {
+void PartTerminal::fromXml(const QDomElement &xml_elmt) {
-
+    d->fromXml(xml_elmt);
-    QUuid uuid;
-    // update part and add uuid, which is used in the new version to connect terminals together
-    // if the attribute not exists, means, the element is created with an older version of qet. So use the legacy approach
-    // to identify terminals
-    propertyUuid(xml_elmt, "uuid", &d->m_uuid);
-
-    if (!d->fromXml(xml_elmt))
-        return false;
-
     setPos(d->m_pos);
 	updateSecondPoint();
-
-    return true;
 }
 
 /**
@@ -65,25 +53,8 @@ bool PartTerminal::fromXml(const QDomElement &xml_elmt) {
 	@param xml_document Document XML a utiliser pour creer l'element XML
 	@return un element XML decrivant la borne
 */
-QDomElement PartTerminal::toXml(QDomDocument &xml_document) const {
+const QDomElement PartTerminal::toXml(QDomDocument &xml_document) const {
-
+    return d->toXml(xml_document);
-    QDomElement qdo = xml_document.createElement("terminal");
-
-    qdo.appendChild(createXmlProperty(xml_document, "uuid", d->m_uuid));
-
-    d->m_pos = pos();
-
-    // Do not store terminal data in its own child
-    QDomElement terminalDataElement = d->toXml(xml_document);
-    for (int i=0; i < terminalDataElement.childNodes().length(); i++) {
-        qdo.appendChild(terminalDataElement.childNodes().at(i).cloneNode()); // cloneNode() is important, otherwise no deep clone is made
-    }
-
-    return qdo;
-}
-
-bool PartTerminal::valideXml(QDomElement& element) {
-    return TerminalData::valideXml(element);
 }
 
 /**

sources/editor/graphicspart/partterminal.h

@@ -57,10 +57,8 @@ class PartTerminal : public CustomElementGraphicPart
 		int type() const override { return Type; }
         QString name() const override { return d->m_name; }
 		QString xmlName() const override { return(QString("terminal")); }
-        bool fromXml(const QDomElement &) override;
+		void fromXml(const QDomElement &) override;
-        QDomElement toXml(QDomDocument &) const override;
+		const QDomElement toXml(QDomDocument &) const override;
-        static bool valideXml(QDomElement& element);
-
 		void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) override;
 
 		QPainterPath shape() const override;

sources/editor/graphicspart/parttext.cpp

@@ -55,49 +55,32 @@ PartText::~PartText() {
 	Importe les proprietes d'un texte statique depuis un element XML
 	@param xml_element Element XML a lire
 */
-bool PartText::fromXml(const QDomElement &xml_element)
+void PartText::fromXml(const QDomElement &xml_element)
 {
-    int size;
+	bool ok;
-    QString font;
 
-    if (propertyInteger(xml_element, "size", &size) != PropertyFlags::NotFound)
+	if (xml_element.hasAttribute("size"))
 	{
-        if (size < 1) {
+		int font_size = xml_element.attribute("size").toInt(&ok);
-            size = 20;
+		if (!ok || font_size < 1) {
+			font_size = 20;
 		}
 		QFont font_ = this->font();
-        font_.setPointSize(size);
+		font_.setPointSize(font_size);
 		setFont(font_);
 	}
-    else if (propertyString(xml_element, "font", &font) != PropertyFlags::NotFound)
+	else if (xml_element.hasAttribute("font"))
 	{
 		QFont font_;
-        font_.fromString(font);
+		font_.fromString(xml_element.attribute("font"));
 		setFont(font_);
-    } else {
+	}
-        return false;
-    }
 	
-    QColor color;
+	setDefaultTextColor(QColor(xml_element.attribute("color", "#000000")));
-    QString text;
+	setPlainText(xml_element.attribute("text"));
-    propertyColor(xml_element, "color", &color);
+	setPos(xml_element.attribute("x").toDouble(),
-    setDefaultTextColor(color);
+		   xml_element.attribute("y").toDouble());
-
+	setRotation(xml_element.attribute("rotation", QString::number(0)).toDouble());
-
-    propertyString(xml_element, "text", &text);
-    setPlainText(text);
-
-    double x=0, y=0, rot=0;
-    if (propertyDouble(xml_element, "x", &x) == PropertyFlags::NoValidConversion ||
-        propertyDouble(xml_element, "y", &y) == PropertyFlags::NoValidConversion)
-        return false;
-    setPos(x, y);
-
-    if (propertyDouble(xml_element, "rotation", &rot) == PropertyFlags::NoValidConversion)
-        return false;
-    setRotation(rot);
-
-    return true;
 }
 
 /**
@@ -105,44 +88,20 @@ bool PartText::fromXml(const QDomElement &xml_element)
 	@param xml_document Document XML a utiliser pour creer l'element XML
 	@return un element XML decrivant le texte statique
 */
-QDomElement PartText::toXml(QDomDocument &xml_document) const
+const QDomElement PartText::toXml(QDomDocument &xml_document) const
 {
 	QDomElement xml_element = xml_document.createElement(xmlName());
 
-    xml_element.appendChild(createXmlProperty(xml_document, "x", pos().x()));
+	xml_element.setAttribute("x", QString::number(pos().x()));
-    xml_element.appendChild(createXmlProperty(xml_document, "y", pos().y()));
+	xml_element.setAttribute("y", QString::number(pos().y()));
-    xml_element.appendChild(createXmlProperty(xml_document, "text", toPlainText()));
+	xml_element.setAttribute("text", toPlainText());
-    xml_element.appendChild(createXmlProperty(xml_document, "font", font().toString()));
+	xml_element.setAttribute("font", font().toString());
-    xml_element.appendChild(createXmlProperty(xml_document, "rotation", rotation()));
+	xml_element.setAttribute("rotation", QString::number(rotation()));
-    xml_element.appendChild(createXmlProperty(xml_document, "color", defaultTextColor().name()));
+	xml_element.setAttribute("color", defaultTextColor().name());
 
 	return(xml_element);
 }
 
-bool PartText::valideXml(QDomElement& element) {
-
-    if (propertyInteger(element, "size") == PropertyFlags::NotFound ||
-        propertyString(element, "font") == PropertyFlags::NotFound) {
-        return false;
-    }
-
-    if (propertyString(element, "color") == PropertyFlags::NoValidConversion)
-        return false;
-
-
-    if (propertyString(element, "text"))
-        return false;
-
-    if (propertyDouble(element, "x") == PropertyFlags::NoValidConversion ||
-        propertyDouble(element, "y") == PropertyFlags::NoValidConversion)
-        return false;
-
-    if (propertyDouble(element, "rotation", 0) == PropertyFlags::NoValidConversion)
-        return false;
-
-    return true;
-}
-
 /**
 	@return Les coordonnees du point situe en bas a gauche du texte.
 */

sources/editor/graphicspart/parttext.h

@@ -59,9 +59,8 @@ class PartText : public QGraphicsTextItem, public CustomElementPart
 		int type() const override { return Type; }
 		QString name() const override { return(QObject::tr("texte", "element part name")); }
 		QString xmlName() const override { return(QString("text")); }
-        bool fromXml(const QDomElement &) override;
+		void fromXml(const QDomElement &) override;
-        static bool valideXml(QDomElement& element);
+		const QDomElement toXml(QDomDocument &) const override;
-        QDomElement toXml(QDomDocument &) const override;
 		void setRotation(qreal angle) {(QGraphicsObject::setRotation(QET::correctAngle(angle)));}
 		bool isUseless() const override;
 		QRectF sceneGeometricRect() const override;

sources/elementtextpattern.cpp

@@ -108,7 +108,8 @@ QDomDocument ExportElementTextPattern::xmlConf() const
 	root.setAttribute("name", m_name);
 	doc.appendChild(root);
 	
-    QDomElement elmt = m_element->toXml(doc);
+	QHash<Terminal *, int> H;
+	QDomElement elmt = m_element->toXml(doc, H);
 	QDomElement texts = elmt.firstChildElement("dynamic_texts");
 	QDomElement groups = elmt.firstChildElement("texts_groups");
 	

sources/properties/propertiesinterface.cpp

@@ -17,313 +17,6 @@
 */
 #include "propertiesinterface.h"
 
-#include <QDebug>
-
-/*!
- * Available property types
- */
-namespace  {
-    const QString integerS = "int";
-    const QString doubleS = "double";
-    const QString boolS = "bool";
-    const QString stringS = "string";
-    const QString uuidS = "uuid";
-    const QString colorS = "color";
-}
-
 PropertiesInterface::PropertiesInterface()
 {
 }
-
-bool PropertiesInterface::valideXml(QDomElement& element) {
-    qDebug(QString("ValideXml() is not implemented. File: %1, Line: %2").arg(__FILE__).arg(__LINE__).toStdString().data());
-    return false;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument &doc, const QString& name, const QString value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", stringS);
-    p.setAttribute("value", value);
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument &doc, const QString& name, const char* value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", stringS);
-    p.setAttribute("value", value);
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument& doc, const QString& name, const int value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", integerS);
-    p.setAttribute("value", QString::number(value));
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument& doc, const QString& name, const double value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", doubleS);
-    p.setAttribute("value", QString::number(value));
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument& doc, const QString& name, const bool value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", boolS);
-    p.setAttribute("value", QString::number(value));
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument& doc, const QString& name, const QUuid value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", uuidS);
-    p.setAttribute("value", value.toString());
-    return p;
-}
-
-QDomElement PropertiesInterface::createXmlProperty(QDomDocument& doc, const QString& name, const QColor value) {
-    QDomElement p = doc.createElement("property");
-    p.setAttribute("name", name);
-    p.setAttribute("type", colorS);
-    p.setAttribute("value", value.name());
-    return p;
-}
-
-QDomElement PropertiesInterface::property(const QDomElement& e, const QString& name) {
-    for (int i=0; i < e.childNodes().count(); i++) {
-        QDomElement child = e.childNodes().at(i).toElement();
-        if (!validXmlProperty(child))
-            continue; // there might also non property childs
-
-        if (child.attribute("name") == name)
-            return child;
-    }
-    return QDomElement();
-}
-
-/*!
- * \brief PropertiesInterface::attribute
- * Returns the property with the name \p attribute_name and type \p type
- * \param e Xml element which contains the property
- * \param attribute_name
- * \param type Type of the property
- * \param attr
- * \return
- */
-bool PropertiesInterface::attribute(const QDomElement& e, const QString& attribute_name, const QString& type, QString* attr) {
-    QDomElement p = property(e, attribute_name);
-    if (p.isNull()) {
-        // check if legacy property is available,
-        // where the property is inside the element as attribute
-        if (!e.hasAttribute(attribute_name)) {
-            qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "Property " << attribute_name << "is not available";
-            return false;
-        }
-
-        *attr = e.attribute(attribute_name);
-
-    } else {
-        if (p.attribute("type") != type) {
-            qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ", Property: " << attribute_name << "(" << p.attribute("type") << ") has not type: " << type;
-            return false;
-        }
-
-        *attr = p.attribute("value");
-
-    }
-    return true;
-}
-
-/*!
- * \brief PropertiesInterface::propertyInteger
- * Reads an interger from the XML element.
- * \param e DomElement which contains the property attribute
- * \param attribute_name Name of the attribute
- * \param entier Return value if success
- * \return True if reading an integer was successful, else False. If the attribute was not found,
- *          \p entier is not valid and the return value is False
- */
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyInteger(const QDomElement &e, const QString& attribute_name, int* entier) {
-
-    QString attr;
-
-    if (!attribute(e, attribute_name, integerS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    // verifie la validite de l'attribut
-    bool ok;
-    int tmp = attr.toInt(&ok);
-    if (!ok) {
-        qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << integerS << ". value: " << attr;
-        return PropertyFlags::NoValidConversion;
-    }
-
-    if (entier != nullptr)
-        *entier = tmp;
-
-    return PropertyFlags::Success;
-}
-
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyDouble(const QDomElement &e, const QString& attribute_name, double* reel) {
-
-    QString attr;
-
-    if (!attribute(e, attribute_name, doubleS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    // verifie la validite de l'attribut
-    bool ok;
-    double tmp = attr.toDouble(&ok);
-    if (!ok) {
-        qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << doubleS << ". value: " << attr;
-        return PropertyFlags::NoValidConversion;
-    }
-
-    if (reel != nullptr)
-        *reel = tmp;
-
-    return PropertyFlags::Success;
-}
-
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyBool(const QDomElement &e, const QString& attribute_name, bool* boolean) {
-
-    QString attr;
-
-    if (!attribute(e, attribute_name, boolS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    // verifie la validite de l'attribut
-    bool ok;
-    bool tmp = attr.toInt(&ok);
-    if (!ok) {
-        if (attr == "true" || attr == "1")
-            tmp = true;
-        else if (attr == "false" || attr == "0")
-            tmp = false;
-        else {
-            qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << integerS << ". value: " << attr;
-            return PropertyFlags::NoValidConversion;
-        }
-    }
-
-    if (boolean != nullptr)
-        *boolean = tmp;
-
-    return PropertyFlags::Success;
-}
-
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyColor(const QDomElement &e, const QString& attribute_name, QColor* color) {
-
-    QString attr;
-
-    if (!attribute(e, attribute_name, colorS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    // verifie la validite de l'attribut
-    QColor tmp = QColor(attr);
-    if (!tmp.isValid()) {
-        qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << colorS << ". value: " << attr;
-        return PropertyFlags::NoValidConversion;
-    }
-
-    if (color != nullptr)
-        *color = tmp;
-
-    return PropertyFlags::Success;
-}
-
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyUuid(const QDomElement &e, const QString& attribute_name, QUuid* uuid) {
-    QString attr;
-
-    if (!attribute(e, attribute_name, uuidS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    if (QUuid(attr).isNull()){
-        qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << uuidS << ". value: " << attr;
-        return PropertyFlags::NoValidConversion;
-    }
-
-
-    if (uuid != nullptr)
-        *uuid = QUuid(attr);
-
-    return PropertyFlags::Success;
-}
-
-PropertiesInterface::PropertyFlags PropertiesInterface::propertyString(const QDomElement& e, const QString& attribute_name, QString* string) {
-
-    QString attr;
-    if (!attribute(e, attribute_name, stringS, &attr)) {
-        return PropertyFlags::NotFound;
-    }
-
-    // verifie la validite de l'attribut
-    if (string != nullptr)
-        *string = attr;
-
-    return PropertyFlags::Success;
-}
-
-/*!
- * \brief PropertiesInterface::validXmlProperty
- * Check if the Xml element contains the needed fields
- * \param e Xml Property
- * \return True if name, type, value attribute are available, else false
- */
-bool PropertiesInterface::validXmlProperty(const QDomElement& e) {
-    if (!e.hasAttribute("name"))
-        return false;
-
-    if (!e.hasAttribute("type"))
-        return false;
-
-    if (!e.hasAttribute("value"))
-        return false;
-
-    return true;
-}
-
-/**
-    Permet de convertir une chaine de caracteres ("n", "s", "e" ou "w")
-    en orientation. Si la chaine fait plusieurs caracteres, seul le
-    premier est pris en compte. En cas d'incoherence, Qet::North est
-    retourne.
-    @param s Chaine de caractere cense representer une orientation
-    @return l'orientation designee par la chaine de caractere
-*/
-Qet::Orientation PropertiesInterface::orientationFromString(const QString &s) {
-    QChar c = s[0];
-    // in some cases/ old projects? (affuteuse_250h.qet) numbers instead of characters are
-    // used for the orientation
-    if (c == 'e' || c == '1') return(Qet::East);
-    else if (c == 's' || c == '2') return(Qet::South);
-    else if (c == 'w' || c == '3') return (Qet::West);
-    else return(Qet::North); // c == '0'
-}
-
-/**
-    @param o une orientation
-    @return une chaine de caractere representant l'orientation
-*/
-QString PropertiesInterface::orientationToString(Qet::Orientation o) {
-    QString ret;
-    switch(o) {
-        case Qet::North: ret = "n"; break;
-        case Qet::East : ret = "e"; break;
-        case Qet::South: ret = "s"; break;
-        case Qet::West : ret = "w"; break;
-    }
-    return(ret);
-}

sources/properties/propertiesinterface.h

@@ -20,11 +20,7 @@
 
 #include <QString>
 #include <QSettings>
-#include <QColor>
 #include <QDomElement>
-#include <limits>
-#include "qet.h"
-#include <QUuid>
 
 /**
  * @brief The PropertiesInterface class
@@ -35,64 +31,11 @@ class PropertiesInterface
 	public:
 	PropertiesInterface();
 	// Save/load properties to setting file. QString is use for prefix a word befor the name of each paramètre
-    virtual void toSettings	  (QSettings &settings, const QString& = QString()) const {Q_UNUSED(settings)};
+	virtual void toSettings	  (QSettings &settings, const QString = QString()) const =0;
-    virtual void fromSettings (const QSettings &settings, const QString& = QString()) {Q_UNUSED(settings)};
+	virtual void fromSettings (const QSettings &settings, const QString = QString()) =0;
 	// Save/load properties to xml element
     virtual QDomElement toXml		  (QDomDocument &xml_document) const =0;
     virtual bool fromXml	  (const QDomElement &xml_element) =0;
-    static bool valideXml(QDomElement& element);
-
-    /*!
-     * Use this functions to add properties to the xml document
-     */
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const QString value);
-    static QDomElement createXmlProperty(QDomDocument &doc, const QString& name, const char* value);
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const int value);
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const double value);
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const bool value);
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const QUuid value);
-    static QDomElement createXmlProperty(QDomDocument& doc, const QString& name, const QColor value);
-
-    static QDomElement property(const QDomElement& e, const QString& name);
-    static bool attribute(const QDomElement& e, const QString& attribute_name, const QString& type, QString* attr);
-
-    enum PropertyFlags {
-        Success = 0,
-        NotFound = 1,
-        NoValidConversion = 2,
-        // = 4
-    };
-
-    /*!
-     * Try not using the default Value feature. It is better to initialize the class members in the class definition!
-     */
-    static PropertyFlags propertyInteger(const QDomElement &e, const QString& attribute_name, int *entier = nullptr);
-    static PropertyFlags propertyDouble(const QDomElement &e, const QString& attribute_name, double *reel = nullptr);
-    static PropertyFlags propertyString(const QDomElement& e, const QString& attribute_name, QString* string = nullptr);
-    static PropertyFlags propertyBool(const QDomElement &e, const QString& attribute_name, bool* boolean = nullptr);
-    static PropertyFlags propertyUuid(const QDomElement &e, const QString& attribute_name, QUuid* uuid = nullptr);
-    static PropertyFlags propertyColor(const QDomElement &e, const QString& attribute_name, QColor* color = nullptr);
-
-
-    static bool validXmlProperty(const QDomElement& e);
-
-    QVariant XmlProperty(const QDomElement& element);
-
-    /**
-        Permet de convertir une chaine de caracteres ("n", "s", "e" ou "w")
-        en orientation. Si la chaine fait plusieurs caracteres, seul le
-        premier est pris en compte. En cas d'incoherence, Qet::North est
-        retourne.
-        @param s Chaine de caractere cense representer une orientation
-        @return l'orientation designee par la chaine de caractere
-    */
-    static Qet::Orientation orientationFromString(const QString &s);
-
-    /**
-        @param o une orientation
-        @return une chaine de caractere representant l'orientation
-    */
-    static QString orientationToString(Qet::Orientation o);
 };
 
 #endif // PROPERTIESINTERFACE_H

sources/properties/terminaldata.cpp

@@ -28,81 +28,60 @@ void TerminalData::setParent(QGraphicsObject* parent)
     q = parent;
 }
 
-void TerminalData::toSettings(QSettings& settings, const QString&) const
+void TerminalData::toSettings(QSettings &settings, const QString) const
 
 {
 	Q_UNUSED(settings);
 }
 
-void TerminalData::fromSettings(const QSettings& settings, const QString&)
+void TerminalData::fromSettings(const QSettings &settings, const QString)
 {
 	Q_UNUSED(settings);
 }
 
 QDomElement TerminalData::toXml(QDomDocument &xml_document) const
 {
-    QDomElement xml_element = xml_document.createElement("terminaldata");
+    QDomElement xml_element = xml_document.createElement("terminal");
+
+    // ecrit la position de la borne
+    xml_element.setAttribute("x", QString("%1").arg(q->scenePos().x()));
+    xml_element.setAttribute("y", QString("%1").arg(q->scenePos().y()));
 
 
-    // m_pos cannot be stored, because in the partterminal it will not be updated.
+    xml_element.setAttribute("uuid", m_uuid.toString());
-    // In PartTerminal m_pos is the position of the dock, in Terminal m_pos is the second side of the terminal
+    xml_element.setAttribute("name", m_name);
-    // This is hold for legacy compability reason
+
-    xml_element.appendChild(createXmlProperty(xml_document, "x", m_pos.x()));
+    // ecrit l'orientation de la borne
-    xml_element.appendChild(createXmlProperty(xml_document, "y", m_pos.y()));
+    xml_element.setAttribute("orientation", Qet::orientationToString(m_orientation));
-    xml_element.appendChild(createXmlProperty(xml_document, "name", m_name));
+    // Write name and number to XML
-    xml_element.appendChild(createXmlProperty(xml_document, "orientation", orientationToString(m_orientation)));
 
     return(xml_element);
 }
-
+bool TerminalData::fromXml (const QDomElement &xml_element)
-bool TerminalData::fromXml (const QDomElement &xml_element) // RETURNS True
 {
     // lit la position de la borne
     qreal term_x = 0.0, term_y = 0.0;
-
+    if (!QET::attributeIsAReal(xml_element, "x", &term_x))
-    if (propertyDouble(xml_element, "x", &term_x))
         return false;
 
-    if (propertyDouble(xml_element, "y", &term_y))
+    if (!QET::attributeIsAReal(xml_element, "y", &term_y))
         return false;
 
     m_pos = QPointF(term_x, term_y);
 
-//    emit posFromXML(QPointF(term_x, term_y));
+    //emit posFromXML(QPointF(term_x, term_y));
 
-    // do not write uuid from this class, because only PartTerminal::fromXml need
+    QString uuid = xml_element.attribute("uuid");
-    // to write it to xml file. Terminal::fromXml does not need.
+    // update part and add uuid, which is used in the new version to connect terminals together
+    // if the attribute not exists, means, the element is created with an older version of qet. So use the legacy approach
+    // to identify terminals
+    if (!uuid.isEmpty())
+        m_uuid = QUuid(uuid);
 
-
+    m_name = xml_element.attribute("name");
-    //if (propertyString(xml_element, "name", &m_name))
-    //    return false;
-    propertyString(xml_element, "name", &m_name); // some parts do not have a name. Example: affuteuse_250h.qet, Terminal at x="0" y="-20"
-
-    QString o;
-    if (propertyString(xml_element, "orientation", &o))
-        return false;
 
     // lit l'orientation de la borne
-    m_orientation = orientationFromString(o);
+    m_orientation = Qet::orientationFromString(xml_element.attribute("orientation"));
 
     return true;
 }
-
-bool TerminalData::valideXml(const QDomElement& xml_element) {
-    if (propertyDouble(xml_element, "x"))
-        return false;
-
-    if (propertyDouble(xml_element, "y"))
-        return false;
-
-      // legacy elements do not have an uuid
-//    if (propertyUuid(xml_element, "uuid"))
-//        return false;
-
-    //if (propertyString(xml_element, "name")) // some parts do not have a name. Example: affuteuse_250h.qet, Terminal at x="0" y="-20"
-    //    return false;
-
-    if (propertyString(xml_element, "orientation"))
-        return false;
-    return true;
-}

sources/properties/terminaldata.h

@@ -28,15 +28,13 @@ public:
     void setParent(QGraphicsObject* parent);
 
     // Save/load properties to setting file. QString is use for prefix a word befor the name of each paramètre
-    void toSettings(QSettings &settings, const QString& = QString()) const override;
+    void toSettings(QSettings &settings, const QString = QString()) const override;
-    void fromSettings(const QSettings &settings, const QString& = QString()) override;
+    void fromSettings(const QSettings &settings, const QString = QString()) override;
     // Save/load properties to xml element
     // This method is only called from the PartTerminal and should never called from the Terminal class
     QDomElement toXml(QDomDocument &xml_element) const override;
     bool fromXml(const QDomElement &xml_element) override;
 
-    static bool valideXml(const QDomElement &xml_element);
-
     // must be public, because this class is a private member of PartTerminal/Terminal and they must
     // access this data
 public:
@@ -44,12 +42,12 @@ public:
      * \brief m_orientation
      * Orientation of the terminal
      */
-    Qet::Orientation m_orientation{Qet::Orientation::North};
+    Qet::Orientation m_orientation;
     /*!
      * \brief second_point
      * Position of the second point of the terminal in scene coordinates
      */
-    QPointF second_point{0,0};
+    QPointF second_point;
     /*!
      * \brief m_uuid
      * Uuid of the terminal.
@@ -60,7 +58,7 @@ public:
      * uuid, the conductor after updating the part is anymore valid. So if in the loaded document a uuid exists,
      * use this one and don't create a new one.
      */
-    QUuid m_uuid; // default is an invalid uuid.
+    QUuid m_uuid;
     /*!
      * \brief m_name
      * Name of the element. It can be used to create wiring harness tables
@@ -73,7 +71,7 @@ public:
      * Important: this variable is only updated during read from xml and not during mouse move!
      * It is used to store the initial position so that PartTerminal and Terminal have access to it.
      */
-    QPointF m_pos{0,0};
+    QPointF m_pos;
 private:
     QGraphicsObject* q{nullptr};
 };

sources/properties/xrefproperties.cpp

@@ -25,6 +25,14 @@
  */
 XRefProperties::XRefProperties()
 {
+	m_show_power_ctc = true;
+	m_display = Cross;
+	m_snap_to = Bottom;
+	m_prefix_keys << "power" << "delay" << "switch";
+	m_master_label = "%f-%l%c";
+	m_slave_label = "(%f-%l%c)";
+	m_offset = 0;
+	m_xref_pos = Qt::AlignBottom;
 }
 
 /**
@@ -33,7 +41,7 @@ XRefProperties::XRefProperties()
  * @param settings: QSettings to use
  * @param prefix: prefix before properties name
  */
-void XRefProperties::toSettings(QSettings &settings, const QString &prefix) const {
+void XRefProperties::toSettings(QSettings &settings, const QString prefix) const {
 	settings.setValue(prefix + "showpowerctc", m_show_power_ctc);
 	QString display = m_display == Cross? "cross" : "contacts";
 	settings.setValue(prefix + "displayhas", display);
@@ -61,7 +69,7 @@ void XRefProperties::toSettings(QSettings &settings, const QString &prefix) cons
  * @param settings: QSettings to use
  * @param prefix: prefix before properties name
  */
-void XRefProperties::fromSettings(const QSettings &settings, const QString &prefix)
+void XRefProperties::fromSettings(const QSettings &settings, const QString prefix)
 {
 	m_show_power_ctc = settings.value(prefix + "showpowerctc", true).toBool();
 	QString display = settings.value(prefix + "displayhas", "cross").toString();
@@ -88,60 +96,58 @@ void XRefProperties::fromSettings(const QSettings &settings, const QString &pref
 QDomElement XRefProperties::toXml(QDomDocument &xml_document) const {
 
     QDomElement xml_element = xml_document.createElement("xref");
+    xml_element.setAttribute("type", m_key);
 
-    xml_element.appendChild(createXmlProperty(xml_document, "type", m_key));
+    xml_element.setAttribute("showpowerctc", m_show_power_ctc? "true" : "false");
-    xml_element.appendChild(createXmlProperty(xml_document, "showpowerctc", m_show_power_ctc));
+	QString display = m_display == Cross? "cross" : "contacts";
-    xml_element.appendChild(createXmlProperty(xml_document, "displayhas", m_display == Cross? "cross" : "contacts"));
+	xml_element.setAttribute("displayhas", display);
-    xml_element.appendChild(createXmlProperty(xml_document, "snapto", m_snap_to == Bottom? "bottom" : "label"));
+	QString snap = m_snap_to == Bottom? "bottom" : "label";
+	xml_element.setAttribute("snapto", snap);
 
+	QString xrefpos;
 	
-    QMetaEnum var = QMetaEnum::fromType<Qt::Alignment>();
+	QMetaEnum var = QMetaEnum::fromType<Qt::Alignment>();
-    xml_element.appendChild(createXmlProperty(xml_document, "xrefpos", var.valueToKey(m_xref_pos)));
+	xml_element.setAttribute("xrefpos",  var.valueToKey(m_xref_pos));
-    xml_element.appendChild(createXmlProperty(xml_document, "offset", m_offset));
-    xml_element.appendChild(createXmlProperty(xml_document, "master_label", m_master_label));
-    xml_element.appendChild(createXmlProperty(xml_document, "slave_label", m_slave_label));
 
+	int offset = m_offset;
+	xml_element.setAttribute("offset", QString::number(offset));
+	QString master_label = m_master_label;
+	xml_element.setAttribute("master_label", master_label);
+	QString slave_label = m_slave_label;
+	xml_element.setAttribute("slave_label", slave_label);
 	foreach (QString key, m_prefix.keys()) {
-        xml_element.appendChild(createXmlProperty(xml_document, key + "prefix", m_prefix.value(key)));
+		xml_element.setAttribute(key + "prefix", m_prefix.value(key));
 	}
 
     return xml_element;
 }
 
-/** RETURNS True
+/**
  * @brief XRefProperties::fromXml
  * Load from xml
  * @param xml_element: QDomElement to use for load
  */
 bool XRefProperties::fromXml(const QDomElement &xml_element) {
+	m_show_power_ctc = xml_element.attribute("showpowerctc")  == "true";
+	QString display = xml_element.attribute("displayhas", "cross");
+	display == "cross"? m_display = Cross : m_display = Contacts;
+	QString snap = xml_element.attribute("snapto", "label");
+	snap == "bottom"? m_snap_to = Bottom : m_snap_to = Label;
 
-    if (propertyBool(xml_element, "showpowerctc", &m_show_power_ctc))
+	QString xrefpos = xml_element.attribute("xrefpos","Left");
-        return false;
 
-    QString display;
+	QMetaEnum var = QMetaEnum::fromType<Qt::Alignment>();
-    if (propertyString(xml_element, "displayhas", &display) != PropertyFlags::NotFound) {
-        display == "cross"? m_display = Cross : m_display = Contacts;
-    }
 
+	if(xml_element.hasAttribute("xrefpos"))
+		m_xref_pos = Qt::AlignmentFlag(var.keyToValue(xml_element.attribute("xrefpos").toStdString().data()));
+	else
+		m_xref_pos = Qt::AlignBottom;
 
-    QString snap;
+	m_offset = xml_element.attribute("offset", "0").toInt();
-    if (propertyString(xml_element, "snapto", &snap)  != PropertyFlags::NotFound) {
+	m_master_label = xml_element.attribute("master_label", "%f-%l%c");
-        snap == "bottom"? m_snap_to = Bottom : m_snap_to = Label;
+	m_slave_label = xml_element.attribute("slave_label","(%f-%l%c)");
-    }
-
-    QString xrefpos;
-    if (propertyString(xml_element, "xrefpos", &xrefpos) != PropertyFlags::NotFound) {
-        QMetaEnum var = QMetaEnum::fromType<Qt::Alignment>();
-        m_xref_pos = Qt::AlignmentFlag(var.keyToValue(xrefpos.toStdString().data()));
-    }
-    // TODO: why it compiles without this true??
-    propertyInteger(xml_element, "offset", &m_offset);
-    propertyString(xml_element, "master_label", &m_master_label);
-    propertyString(xml_element, "slave_label", &m_slave_label);
-    QString value;
 	foreach (QString key, m_prefix_keys) {
-        if (!propertyString(xml_element, key + "prefix", &value));
+		m_prefix.insert(key, xml_element.attribute(key + "prefix"));
-            m_prefix.insert(key, value);
 	}
     return true;
 }

sources/properties/xrefproperties.h

@@ -40,8 +40,8 @@ class XRefProperties : public PropertiesInterface
 		Label
 	};
 
-    void toSettings	  (QSettings &settings, const QString& = QString()) const override;
+	void toSettings	  (QSettings &settings, const QString = QString()) const override;
-    void fromSettings (const QSettings &settings, const QString& = QString()) override;
+	void fromSettings (const QSettings &settings, const QString = QString()) override;
     QDomElement toXml		  (QDomDocument &xml_document) const override;
     bool fromXml(const QDomElement &xml_element) override;
 
@@ -76,15 +76,15 @@ class XRefProperties : public PropertiesInterface
     void setKey(QString& key) {m_key = key;}
 
 	private:
-    bool m_show_power_ctc{true};
+	bool m_show_power_ctc;
-    DisplayHas m_display{Cross};
+	DisplayHas m_display;
-    SnapTo m_snap_to{Bottom};
+	SnapTo m_snap_to;
-    Qt::AlignmentFlag m_xref_pos{Qt::AlignBottom};
+	Qt::AlignmentFlag m_xref_pos;
 	QHash <QString, QString> m_prefix;
-    QStringList m_prefix_keys{"power","delay","switch"};
+	QStringList m_prefix_keys;
-    QString m_master_label{"%f-%l%c"};
+	QString m_master_label;
-    QString m_slave_label{"(%f-%l%c)"};
+	QString m_slave_label;
-    int     m_offset{0};
+	int     m_offset;
     QString m_key;
 };
 

sources/qet.cpp

@@ -25,6 +25,37 @@
 #include <QSaveFile>
 #include <QTextStream>
 
+/**
+	Permet de convertir une chaine de caracteres ("n", "s", "e" ou "w")
+	en orientation. Si la chaine fait plusieurs caracteres, seul le
+	premier est pris en compte. En cas d'incoherence, Qet::North est
+	retourne.
+	@param s Chaine de caractere cense representer une orientation
+	@return l'orientation designee par la chaine de caractere
+*/
+Qet::Orientation Qet::orientationFromString(const QString &s) {
+	QChar c = s[0];
+	if (c == 'e') return(Qet::East);
+	else if (c == 's') return(Qet::South);
+	else if (c == 'w') return (Qet::West);
+	else return(Qet::North);
+}
+
+/**
+	@param o une orientation
+	@return une chaine de caractere representant l'orientation
+*/
+QString Qet::orientationToString(Qet::Orientation o) {
+	QString ret;
+	switch(o) {
+		case Qet::North: ret = "n"; break;
+		case Qet::East : ret = "e"; break;
+		case Qet::South: ret = "s"; break;
+		case Qet::West : ret = "w"; break;
+	}
+	return(ret);
+}
+
 /**
 	Indique si deux orientations de Borne sont sur le meme axe (Vertical / Horizontal).
 	@param a La premiere orientation de Borne

sources/qetgraphicsitem/conductor.cpp

@@ -76,7 +76,14 @@ class ConductorXmlRetroCompatibility
  */
 Conductor::Conductor(Terminal *p1, Terminal* p2) :
 	terminal1(p1),
-    terminal2(p2)
+	terminal2(p2),
+	m_mouse_over(false),
+	m_text_item(nullptr),
+	segments(nullptr),
+	m_moving_segment(false),
+	modified_path(false),
+	has_to_save_profile(false),
+	must_highlight_(Conductor::None)
 {
 		//set Zvalue at 11 to be upper than the DiagramImageItem and element
 	setZValue(11);
@@ -566,16 +573,36 @@ ConductorTextItem *Conductor::textItem() const {
 	@return true si l'element XML represente bien un Conducteur ; false sinon
 */
 bool Conductor::valideXml(QDomElement &e){
+	// verifie le nom du tag
+	if (e.tagName() != "conductor") return(false);
 	
-//    // TODO: seems to short! (see fromXML)
+	// verifie la presence des attributs minimaux
-//    if (propertyDouble(e, "x") ||
+	if (!e.hasAttribute("terminal1")) return(false);
-//        propertyDouble(e, "y"))
+	if (!e.hasAttribute("terminal2")) return(false);
-//        return false;
 	
-//    if (propertyBool(e, "freezeLabel"))
+	bool conv_ok;
-//        return false;
+	// parse l'abscisse
+	if (e.hasAttribute("element1")) {
+		if (QUuid(e.attribute("element1")).isNull())
+			return false;
+		if (QUuid(e.attribute("terminal1")).isNull())
+			return false;
+	} else {
+		e.attribute("terminal1").toInt(&conv_ok);
+		if (!conv_ok) return(false);
+	}
 	
-    return true;
+	// parse l'ordonnee
+	if (e.hasAttribute("element2")) {
+		if (QUuid(e.attribute("element2")).isNull())
+			return false;
+		if (QUuid(e.attribute("terminal2")).isNull())
+			return false;
+	} else {
+		e.attribute("terminal2").toInt(&conv_ok);
+		if (!conv_ok) return(false);
+	}
+	return(true);
 }
 
 /**
@@ -946,13 +973,10 @@ void Conductor::pointsToSegments(const QList<QPointF>& points_list) {
  * @param e
  * @return true is loading success else return false
  */
-bool Conductor::fromXml(const QDomElement &dom_element)
+bool Conductor::fromXml(QDomElement &dom_element)
 {
-    // TODO: seems to short!
+	setPos(dom_element.attribute("x", nullptr).toDouble(),
-    double x=0, y=0;
+		   dom_element.attribute("y", nullptr).toDouble());
-    propertyDouble(dom_element, "x", &x);
-    propertyDouble(dom_element, "y", &y);
-    setPos(x, y);
 
 	bool return_ = pathFromXml(dom_element);
 
@@ -966,77 +990,13 @@ bool Conductor::fromXml(const QDomElement &dom_element)
 	else
 		m_autoNum_seq.fromXml(dom_element.firstChildElement("sequentialNumbers"));
 
-    propertyBool(dom_element, "freezeLabel", &m_freeze_label);
+	m_freeze_label = dom_element.attribute("freezeLabel") == "true"? true : false;
+
 	setProperties(pr);
 
 	return return_;
 }
 
-// does not support legacy method
-// dom_element.setAttribute("terminal1", table_adr_id.value(terminal1));
-QDomElement Conductor::toXml(QDomDocument & doc) const {
-    QDomElement dom_element = doc.createElement("conductor");
-
-    dom_element.appendChild(createXmlProperty(doc, "x", pos().x()));
-    dom_element.appendChild(createXmlProperty(doc, "y", pos().y()));
-
-    // Terminal is uniquely identified by the uuid of the terminal and the element
-    QUuid terminal = terminal1->uuid();
-    QUuid terminalParent = terminal1->parentElement()->uuid();
-    if (terminalParent.isNull() || terminal.isNull()) {
-        // legacy when the terminal does not have a valid uuid
-        // do not store element1 information, because this is used to determine in the fromXml
-        // process that legacy file format
-        dom_element.appendChild(createXmlProperty(doc, "terminal1", terminal1->ID()));
-    } else {
-        dom_element.appendChild(createXmlProperty(doc, "element1", terminalParent));
-        dom_element.appendChild(createXmlProperty(doc, "terminal1", terminal));
-    }
-
-    terminal = terminal2->uuid();
-    terminalParent = terminal2->parentElement()->uuid();
-    if (terminalParent.isNull() || terminal.isNull()) {
-        // legacy when the terminal does not have a valid uuid
-        // do not store element1 information, because this is used to determine in the fromXml
-        // process that legacy file format
-        dom_element.appendChild(createXmlProperty(doc, "terminal2", terminal2->ID()));
-    } else {
-        dom_element.appendChild(createXmlProperty(doc, "element2", terminal2->parentElement()->uuid()));
-        dom_element.appendChild(createXmlProperty(doc, "terminal2", terminal2->uuid()));
-    }
-
-    dom_element.appendChild(createXmlProperty(doc, "freezeLabel", m_freeze_label));
-
-    // on n'exporte les segments du conducteur que si ceux-ci ont
-    // ete modifies par l'utilisateur
-    if (modified_path)
-    {
-        // parcours et export des segments
-        QDomElement current_segment;
-        foreach(ConductorSegment *segment, segmentsList())
-        {
-            current_segment = doc.createElement("segment");
-            current_segment.appendChild(createXmlProperty(doc, "orientation", segment->isHorizontal() ? "horizontal": "vertical"));
-            current_segment.appendChild(createXmlProperty(doc, "length", segment -> length()));
-            dom_element.appendChild(current_segment);
-        }
-    }
-
-    QDomElement dom_seq = m_autoNum_seq.toXml(doc); // swquentialNumbers tag
-    dom_element.appendChild(dom_seq);
-
-        // Export the properties and text
-    QDomElement conductorProperties = m_properties.toXml(doc);
-    for (int i=0; i < conductorProperties.childNodes().count(); i++) {
-        QDomNode node = conductorProperties.childNodes().at(i).cloneNode(); // cloneNode() is important!
-        dom_element.appendChild(node);
-    }
-
-    m_text_item->toXml(doc, dom_element);
-
-    return(dom_element);
-}
-
 /**
 	Exporte les caracteristiques du conducteur sous forme d'une element XML.
 	@param d Le document XML a utiliser pour creer l'element XML
@@ -1044,61 +1004,61 @@ QDomElement Conductor::toXml(QDomDocument & doc) const {
 	bornes dans le document XML et leur adresse en memoire
 	@return Un element XML representant le conducteur
 */
-//QDomElement Conductor::toXml(QDomDocument &dom_document, QHash<Terminal *, int> &table_adr_id) const
+QDomElement Conductor::toXml(QDomDocument &dom_document, QHash<Terminal *, int> &table_adr_id) const
-//{
+{
-//	QDomElement dom_element = dom_document.createElement("conductor");
+	QDomElement dom_element = dom_document.createElement("conductor");
 
-//	dom_element.setAttribute("x", QString::number(pos().x()));
+	dom_element.setAttribute("x", QString::number(pos().x()));
-//	dom_element.setAttribute("y", QString::number(pos().y()));
+	dom_element.setAttribute("y", QString::number(pos().y()));
 
-//    // Terminal is uniquely identified by the uuid of the terminal and the element
+    // Terminal is uniquely identified by the uuid of the terminal and the element
-//    if (terminal1->uuid().isNull()) {
+    if (terminal1->uuid().isNull()) {
-//        // legacy method to identify the terminal
+        // legacy method to identify the terminal
-//        dom_element.setAttribute("terminal1", table_adr_id.value(terminal1)); // for backward compability
+        dom_element.setAttribute("terminal1", table_adr_id.value(terminal1)); // for backward compability
-//    } else {
+    } else {
-//        dom_element.setAttribute("element1", terminal1->parentElement()->uuid().toString());
+        dom_element.setAttribute("element1", terminal1->parentElement()->uuid().toString());
-//        dom_element.setAttribute("terminal1", terminal1->uuid().toString());
+        dom_element.setAttribute("terminal1", terminal1->uuid().toString());
-//    }
+    }
 
-//    if (terminal2->uuid().isNull()) {
+    if (terminal2->uuid().isNull()) {
-//        // legacy method to identify the terminal
+        // legacy method to identify the terminal
-//        dom_element.setAttribute("terminal2", table_adr_id.value(terminal2)); // for backward compability
+        dom_element.setAttribute("terminal2", table_adr_id.value(terminal2)); // for backward compability
-//    } else {
+    } else {
-//        dom_element.setAttribute("element2", terminal2->parentElement()->uuid().toString());
+        dom_element.setAttribute("element2", terminal2->parentElement()->uuid().toString());
-//        dom_element.setAttribute("terminal2", terminal2->uuid().toString());
+        dom_element.setAttribute("terminal2", terminal2->uuid().toString());
-//    }
+    }
-//	dom_element.setAttribute("freezeLabel", m_freeze_label? "true" : "false");
+	dom_element.setAttribute("freezeLabel", m_freeze_label? "true" : "false");
 	
-//	// on n'exporte les segments du conducteur que si ceux-ci ont
+	// on n'exporte les segments du conducteur que si ceux-ci ont
-//	// ete modifies par l'utilisateur
+	// ete modifies par l'utilisateur
-//	if (modified_path)
+	if (modified_path)
-//	{
+	{
-//		// parcours et export des segments
+		// parcours et export des segments
-//		QDomElement current_segment;
+		QDomElement current_segment;
-//		foreach(ConductorSegment *segment, segmentsList())
+		foreach(ConductorSegment *segment, segmentsList())
-//		{
+		{
-//			current_segment = dom_document.createElement("segment");
+			current_segment = dom_document.createElement("segment");
-//			current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical");
+			current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical");
-//			current_segment.setAttribute("length", QString("%1").arg(segment -> length()));
+			current_segment.setAttribute("length", QString("%1").arg(segment -> length()));
-//			dom_element.appendChild(current_segment);
+			dom_element.appendChild(current_segment);
-//		}
+		}
-//	}
+	}
 
-//	QDomElement dom_seq = m_autoNum_seq.toXml(dom_document);
+	QDomElement dom_seq = m_autoNum_seq.toXml(dom_document);
-//	dom_element.appendChild(dom_seq);
+	dom_element.appendChild(dom_seq);
 	
-//		// Export the properties and text
+		// Export the properties and text
-//    m_properties.toXml(dom_document);
+	m_properties. toXml(dom_element);
-//	if(m_text_item->wasMovedByUser())
+	if(m_text_item->wasMovedByUser())
-//	{
+	{
-//		dom_element.setAttribute("userx", QString::number(m_text_item->pos().x()));
+		dom_element.setAttribute("userx", QString::number(m_text_item->pos().x()));
-//		dom_element.setAttribute("usery", QString::number(m_text_item->pos().y()));
+		dom_element.setAttribute("usery", QString::number(m_text_item->pos().y()));
-//	}
+	}
-//	if(m_text_item->wasRotateByUser())
+	if(m_text_item->wasRotateByUser())
-//		dom_element.setAttribute("rotation", QString::number(m_text_item->rotation()));
+		dom_element.setAttribute("rotation", QString::number(m_text_item->rotation()));
 
-//	return(dom_element);
+	return(dom_element);
-//}
+}
 
 /**
  * @brief Conductor::pathFromXml
@@ -1117,21 +1077,14 @@ bool Conductor::pathFromXml(const QDomElement &e) {
 		if (current_segment.isNull() || current_segment.tagName() != "segment") continue;
 
 		// le segment doit avoir une longueur
-        qreal segment_length;
+		if (!current_segment.hasAttribute("length")) continue;
-        if (propertyDouble(current_segment, "length", & segment_length))
-            continue;
 
-        bool isHorizontal = false;
+		// cette longueur doit etre un reel
-        QString orientation;
+		bool ok;
-        if (propertyString(current_segment, "orientation", &orientation) == PropertyFlags::Success) {
+		qreal segment_length = current_segment.attribute("length").toDouble(&ok);
-            if (orientation == "horizontal")
+		if (!ok) continue;
-                isHorizontal = true;
-        } else {
-            qDebug() << "PathFromXML failed";
-            return false;
-        }
 
-        if (isHorizontal) {
+		if (current_segment.attribute("orientation") == "horizontal") {
 			segments_x << segment_length;
 			segments_y << 0.0;
 		} else {

sources/qetgraphicsitem/conductor.h

@@ -19,7 +19,6 @@
 #define CONDUCTOR_H
 
 #include "conductorproperties.h"
-#include "propertiesinterface.h"
 #include <QGraphicsPathItem>
 #include "assignvariables.h"
 
@@ -40,7 +39,7 @@ typedef QHash<Qt::Corner, ConductorProfile> ConductorProfilesGroup;
 	This class represents a conductor, i.e. a wire between two element
 	terminals.
 */
-class Conductor : public QGraphicsObject, public PropertiesInterface
+class Conductor : public QGraphicsObject
 {
 	Q_OBJECT
 
@@ -96,9 +95,8 @@ class Conductor : public QGraphicsObject, public PropertiesInterface
 
 	public:
 		static bool valideXml (QDomElement &);
-        bool        fromXml   (const QDomElement &) override;
+		bool        fromXml   (QDomElement &);
-        //QDomElement toXml     (QDomDocument &, QHash<Terminal *, int> &) const;
+		QDomElement toXml     (QDomDocument &, QHash<Terminal *, int> &) const;
-        QDomElement toXml     (QDomDocument &doc) const override;
 	private:
 		bool pathFromXml(const QDomElement &);
 
@@ -156,28 +154,28 @@ class Conductor : public QGraphicsObject, public PropertiesInterface
 		
 		QVector<QetGraphicsHandlerItem *> m_handler_vector;
 		int m_vector_index = -1;
-        bool m_mouse_over{false};
+		bool m_mouse_over;
 			/// Functional properties
 		ConductorProperties m_properties;
 			/// Text input for non simple, non-singleline conductors
-        ConductorTextItem *m_text_item{nullptr};
+		ConductorTextItem *m_text_item;
 			/// Segments composing the conductor
-        ConductorSegment *segments{nullptr};
+		ConductorSegment *segments;
 			/// Attributs related to mouse interaction
-        bool m_moving_segment{false};
+		bool m_moving_segment;
 		int moved_point;
 		qreal m_previous_z_value;
 		ConductorSegment *m_moved_segment;
 		QPointF before_mov_text_pos_;
 			/// Whether the conductor was manually modified by users
-        bool modified_path{false};
+		bool modified_path;
 			/// Whether the current profile should be saved as soon as possible
-        bool has_to_save_profile{false};
+		bool has_to_save_profile;
 			/// conductor profile: "photography" of what the conductor is supposed to look
 			/// like - there is one profile per kind of traject
 		ConductorProfilesGroup conductor_profiles;
 			/// Define whether and how the conductor should be highlighted
-        Highlight must_highlight_{Conductor::None};
+		Highlight must_highlight_;
 		bool m_valid;
 		bool m_freeze_label = false;
 

sources/qetgraphicsitem/conductortextitem.cpp

@@ -27,7 +27,9 @@
 */
 ConductorTextItem::ConductorTextItem(Conductor *parent_conductor) :
 	DiagramTextItem(parent_conductor),
-    parent_conductor_(parent_conductor)
+	parent_conductor_(parent_conductor),
+	moved_by_user_(false),
+	rotate_by_user_(false)
 {
 	setAcceptHoverEvents(true);
 }
@@ -59,36 +61,21 @@ Conductor *ConductorTextItem::parentConductor() const {
 	return(parent_conductor_);
 }
 
-void ConductorTextItem::toXml(QDomDocument& doc, QDomElement& e) {
-    if(moved_by_user_)
-    {
-        e.appendChild(PropertiesInterface::createXmlProperty(doc, "userx", pos().x()));
-        e.appendChild(PropertiesInterface::createXmlProperty(doc, "usery", pos().y()));
-    }
-    if(rotate_by_user_)
-        e.appendChild(PropertiesInterface::createXmlProperty(doc, "rotation", rotation()));
-}
-
-
 /**
  * @brief ConductorTextItem::fromXml
  * Read the properties stored in the xml element given in parameter
  * @param e
  */
 void ConductorTextItem::fromXml(const QDomElement &e) {
-
+	if (e.hasAttribute("userx")) {
-    double userx=0, usery=0;
+		setPos(e.attribute("userx").toDouble(),
-    if (PropertiesInterface::propertyDouble(e, "userx", &userx) == PropertiesInterface::PropertyFlags::Success &&
+			   e.attribute("usery").toDouble());
-        PropertiesInterface::propertyDouble(e, "usery", &usery) == PropertiesInterface::PropertyFlags::Success) {
+		moved_by_user_ = true;
-        setPos(userx, usery);
+	}
-        moved_by_user_ = true;
+	if (e.hasAttribute("rotation")) {
-    }
+		setRotation(e.attribute("rotation").toDouble());
-
+		rotate_by_user_ = true;
-    double rotation;
+	}
-    if (PropertiesInterface::propertyDouble(e, "rotation", &rotation) == PropertiesInterface::PropertyFlags::Success) {
-        setRotation(rotation);
-        rotate_by_user_ = true;
-    }
 }
 
 /**

sources/qetgraphicsitem/conductortextitem.h

@@ -42,7 +42,6 @@ class ConductorTextItem : public DiagramTextItem
         enum { Type = UserType + 1006 };
         Conductor *parentConductor() const;
         void fromXml(const QDomElement &) override;
-        void toXml(QDomDocument& doc, QDomElement& e);
         int type() const override { return Type; }
         virtual bool wasMovedByUser() const;
         virtual bool wasRotateByUser() const;
@@ -62,8 +61,8 @@ class ConductorTextItem : public DiagramTextItem
         // attributes
 	private:
         Conductor *parent_conductor_;
-        bool moved_by_user_{false};
+        bool moved_by_user_;
-        bool rotate_by_user_{false};
+        bool rotate_by_user_;
         QPointF before_mov_pos_;
 };
 #endif

sources/qetgraphicsitem/dynamicelementtextitem.cpp

@@ -212,7 +212,7 @@ void DynamicElementTextItem::fromXml(const QDomElement &dom_elmt)
 		setColor(QColor(dom_color.text()));
 	
 		//Force the update of the displayed text
-    setTextFrom(m_text_from); // TODO: does not update because there is a retrun inside if the textfrom argument is the same as m_text_from
+	setTextFrom(m_text_from);
 	
 	QGraphicsTextItem::setPos(dom_elmt.attribute("x", QString::number(0)).toDouble(),
 							  dom_elmt.attribute("y", QString::number(0)).toDouble());

sources/qetgraphicsitem/dynamicelementtextitem.h

@@ -150,7 +150,7 @@ class DynamicElementTextItem : public DiagramTextItem
 		QMetaObject::Connection m_report_formula_con;
 		QList<QMetaObject::Connection> m_formula_connection,
 									   m_update_slave_Xref_connection;
-        QColor m_user_color{QColor()};
+		QColor m_user_color;
 		bool m_frame = false,
 			 m_first_scene_change = true;
 		CrossRefItem *m_Xref_item = nullptr;

sources/qetgraphicsitem/element.cpp

@@ -65,7 +65,6 @@ class ElementXmlRetroCompatibility
 
 /**
  * @brief Element::Element
- * New element from xml
  * @param location, location of this element
  * @param parent, parent graphics item
  * @param state, state of the instanciation
@@ -84,8 +83,7 @@ Element::Element(const ElementsLocation &location, QGraphicsItem *parent, int *s
 		}
 	}
 	int elmt_state;
-    qDebug() << "\tCollection Path: " << location.collectionPath();
+	buildFromXml(location.xml(), &elmt_state);
-    buildFromXml(location.xml(), &elmt_state); // build from the collection definition
 	if (state) {
 		*state = elmt_state;
 	}
@@ -338,7 +336,7 @@ void Element::drawHighlight(QPainter *painter, const QStyleOptionGraphicsItem *o
 
 /**
  * @brief Element::buildFromXml
- * Build this element from an xml description (from the collection)
+ * Build this element from an xml description
  * @param xml_def_elmt
  * @param state
  * Optional pointer which define the status of build
@@ -420,6 +418,7 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
 		{
 				//Minor workaround to find if there is a "input" tagg as label.
 				//If not, we set the tagg "label" to the first "input.
+            // TODO: Remove in later version begin
 			QList <QDomElement> input_field;
 			bool have_label = false;
 			for (QDomElement input_node = node.firstChildElement("input") ; !input_node.isNull() ; input_node = input_node.nextSiblingElement("input"))
@@ -431,8 +430,11 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
 						have_label = true;
 				}
 			}
-			if(!have_label && !input_field.isEmpty())
+            if(!have_label && !input_field.isEmpty()) {
+                qDebug() << input_field.first().attribute("text");
 				input_field.first().setAttribute("tagg", "label");
+            }
+            // TODO: Remove in later version end
 			
 				//Parse the definition
 			for (QDomNode n = node.firstChild() ; !n.isNull() ; n = n.nextSibling())
@@ -441,15 +443,11 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
 				if (qde.isNull())
 					continue;
 				
-                qDebug() << "\t\tElement.cpp:buildFromXml;parseElement: " << qde.tagName();
+				if (parseElement(qde)) {
-				
-                if (parseElement(qde)) { // TODO: why lines are not parsed here?
-                    qDebug() << "\t\t\tParsing Element success";
 					++ parsed_elements_count;
 				}
 				else
 				{
-                    qDebug() << "\t\t\tParsing Element no success";
 					if (state)
 						*state = 7;
 					m_state = QET::GIOK;
@@ -473,11 +471,13 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
 		m_state = QET::GIOK;
 		return(false);
 	}
-
+	else
-    if (state)
+	{
-        *state = 0;
+		if (state)
-    m_state = QET::GIOK;
+			*state = 0;
-    return(true);
+		m_state = QET::GIOK;
+		return(true);
+	}
 }
 
 /**
@@ -574,11 +574,13 @@ DynamicElementTextItem *Element::parseDynamicText(const QDomElement &dom_element
 Terminal *Element::parseTerminal(const QDomElement &dom_element)
 {
 
-    if (!Terminal::valideXml(dom_element))
+    TerminalData* data = new TerminalData();
+    if (!data->fromXml(dom_element)) {
+        delete data;
         return nullptr;
+    }
 	
-    Terminal *new_terminal = new Terminal(0, 0, Qet::Orientation::North, this); // does not matter which values are typed in here, because they get overwritten by the fromXML() function
+    Terminal *new_terminal = new Terminal(data, this);
-    new_terminal->fromXml(dom_element);
 	m_terminals << new_terminal;
 	
 		//Sort from top to bottom and left to rigth
@@ -590,7 +592,7 @@ Terminal *Element::parseTerminal(const QDomElement &dom_element)
 			return (a->dockConductor().y() < b->dockConductor().y());
 	});
 	
-    return(new_terminal); // TODO: makes not sense
+	return(new_terminal);
 }
 
 /**
@@ -638,41 +640,24 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 		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; // terminals in the element in the diagram
+	QList<QDomElement> liste_terminals;
 	foreach(QDomElement qde, QET::findInDomElement(e, "terminals", "terminal")) {
 		if (Terminal::valideXml(qde)) liste_terminals << qde;
 	}
 	
 	QHash<int, Terminal *> priv_id_adr;
 	int terminals_non_trouvees = 0;
-    // The added childs from the collection now must match with the terminals from the diagram. Iterate through
+	foreach(QGraphicsItem *qgi, childItems()) {
-    // all Terminals in the collection and in the diagram to link them together
-    for(QGraphicsItem *qgi: childItems()) { // TODO: Where the Terminals are added as childs?
 		if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) {
 			bool terminal_trouvee = false;
-            for(QDomElement qde: liste_terminals) {
+			foreach(QDomElement qde, liste_terminals) {
-                // The position in the collection element definition is the origin position (originPos).
+				if (p -> fromXml(qde)) {
-                // The position in the diagram element definition  is the position where the conductor is connected (dock position)
-                // Therefore a simple operator overloading is not possible.
-                Terminal diagramTerminal(0,0, Qet::Orientation::East);
-                diagramTerminal.fromXml(qde);
-                QPointF dockPos1 = diagramTerminal.originPos(); // position here is directly the dock_elmt_ position (stored in the diagram)
-                QPointF dockPos2 = p->dockPos();
-                if (qFuzzyCompare(dockPos1.x(), dockPos2.x()) &&
-                    qFuzzyCompare(dockPos1.y(), dockPos2.y()) &&
-                    p->orientation() == diagramTerminal.orientation()) { // check if the part in the collection is the same as in the diagram stored
-                    qDebug() << "Matching Terminal found.";
-                    // store id for legacy purpose, because when opening a old project in the collection the terminal does not have an uuid. Therefore the id must be used
-                    if (p->uuid().isNull()) {
-                        p->setID(qde.attribute("id").toInt());
-                    }
-
 					priv_id_adr.insert(qde.attribute("id").toInt(), p);
 					terminal_trouvee = true;
 					// We used to break here, because we did not expect
 					// several terminals to share the same position.
 					// Of course, it finally happened.
-                }
+				}
 			}
 			if (!terminal_trouvee) ++ terminals_non_trouvees;
 		}
@@ -680,7 +665,6 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 	
 	if (terminals_non_trouvees > 0)
 	{
-        qDebug() << "element.cpp: Element::fromXML; Elements not found: " << terminals_non_trouvees;
 		m_state = QET::GIOK;
 		return(false);
 	} 
@@ -737,15 +721,20 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 		setRotation(90*read_ori);
 	}
 
-		//Befor load the dynamic text field,
+    // TODO: elementInformations are not read from the diagram section or? Yes see below
-		//we remove the dynamic text field created from the description of this element, to avoid doublons.
+	
+//#######################################################################################################################
+//####    START   #######################################################################################################
+//#######################################################################################################################
+        //Before load the dynamic text field,
+        //we remove the dynamic text field created from the description of this element, to avoid doublons.
 	for(DynamicElementTextItem *deti : m_dynamic_text_list)
 		delete deti;
 	m_dynamic_text_list.clear();
-    
 		//************************//
 		//***Dynamic texts item***//
-        //************************// read from the diagram section
+		//************************//
+        // Texts in diagram section
 	for (const QDomElement& qde : QET::findInDomElement(e, "dynamic_texts", DynamicElementTextItem::xmlTagName()))
     {
         DynamicElementTextItem *deti = new DynamicElementTextItem(this);
@@ -753,20 +742,24 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
         deti->fromXml(qde);
     }
 	
+    // TODO: remove in later version begin
 
 		//************************//
 		//***Element texts item***//
 		//************************//
-    QList<QDomElement> inputs = QET::findInDomElement(e, "inputs", "input"); // inputs in diagram section
+        // Inputs in diagram section
+    QList<QDomElement> inputs = QET::findInDomElement(e, "inputs", "input"); // Inputs in diagram section
 	
 		//First case, we check for the text item converted to dynamic text item
-	const QList <DynamicElementTextItem *> conv_deti_list = m_converted_text_from_xml_description.keys();
+    const QList <DynamicElementTextItem *> conv_deti_list = m_converted_text_from_xml_description.keys(); // Texts in element definition (elements collection)
 	QList <DynamicElementTextItem *> successfully_converted; 
 	const QList <QDomElement> dom_inputs = inputs;
-    // TODO: legacy???
+	
-    for (DynamicElementTextItem *deti : conv_deti_list) // elements read from the element collection definition
+
+
+    for (DynamicElementTextItem *deti : conv_deti_list) // Texts from element definition (elements collection)
 	{
-        for(const QDomElement& dom_input : dom_inputs)
+        for(const QDomElement& dom_input : dom_inputs) // Inputs in diagram section
 		{
 				//we use the same method used in ElementTextItem::fromXml to compar and know if the input dom element is for one of the text stored.
 				//The comparaison is made from the text position : if the position of the text is the same as the position stored in 'input' dom element
@@ -837,7 +830,7 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 		group->fromXml(qde);
 	}
 	
-		//load informations
+        //load elementInformations from diagram section
 	DiagramContext dc;
 	dc.fromXml(e.firstChildElement("elementInformations"), "elementInformation");
 		/**
@@ -1011,6 +1004,12 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 			}
 		}
 	}
+
+    // TODO: remove in later version end
+
+//#######################################################################################################################
+//####    END     #######################################################################################################
+//#######################################################################################################################
     m_state = QET::GIOK;
 	return(true);
 }
@@ -1023,7 +1022,7 @@ bool Element::fromXml(QDomElement &e, QHash<int, Terminal *> &table_id_adr, bool
 	methode
 	@return L'element XML representant cet element electrique
 */
-QDomElement Element::toXml(QDomDocument &document) const
+QDomElement Element::toXml(QDomDocument &document, QHash<Terminal *, int> &table_adr_id) const
 {
 	QDomElement element = document.createElement("element");
 	
@@ -1050,16 +1049,25 @@ QDomElement Element::toXml(QDomDocument &document) const
 	element.setAttribute("z", QString::number(this->zValue()));
 	element.setAttribute("orientation", QString::number(orientation()));
 	
+	/* recupere le premier id a utiliser pour les bornes de cet element */
+	int id_terminal = 0;
+	if (!table_adr_id.isEmpty()) {
+		// trouve le plus grand id
+		int max_id_t = -1;
+		foreach (int id_t, table_adr_id.values()) {
+			if (id_t > max_id_t) max_id_t = id_t;
+		}
+		id_terminal = max_id_t + 1;
+	}
+	
 	// enregistrement des bornes de l'appareil
 	QDomElement xml_terminals = document.createElement("terminals");
 	// pour chaque enfant de l'element
 	foreach(Terminal *t, terminals()) {
 		// alors on enregistre la borne
 		QDomElement terminal = t -> toXml(document);
-        if (t->ID() > 0) {
+        terminal.setAttribute("id", id_terminal); // for backward compatibility
-            // for backward compatibility
+		table_adr_id.insert(t, id_terminal ++);
-            terminal.setAttribute("id", t->ID()); // for backward compatibility
-        }
 		xml_terminals.appendChild(terminal);
 	}
 	element.appendChild(xml_terminals);

sources/qetgraphicsitem/element.h

@@ -37,7 +37,7 @@ class ElementTextItemGroup;
 /**
 	This is the base class for electrical elements.
 */
-class Element : public QetGraphicsItem // TODO: derive from propertiesInterface!
+class Element : public QetGraphicsItem
 {
 	friend class DiagramEventAddElement;
 	
@@ -55,7 +55,7 @@ class Element : public QetGraphicsItem // TODO: derive from propertiesInterface!
 				   Slave = 16,
 				   Terminale = 32};
 
-        Element(const ElementsLocation &location, QGraphicsItem * parent= nullptr, int *state = nullptr, Element::kind link_type = Element::Simple);
+		Element(const ElementsLocation &location, QGraphicsItem * = nullptr, int *state = nullptr, Element::kind link_type = Element::Simple);
 		~Element() override;
 	private:
 		Element(const Element &);
@@ -113,7 +113,7 @@ class Element : public QetGraphicsItem // TODO: derive from propertiesInterface!
         void editProperty() override;
         static bool valideXml(QDomElement &);
         virtual bool fromXml(QDomElement &, QHash<int, Terminal *> &, bool = false);
-        virtual QDomElement toXml(QDomDocument &) const;
+        virtual QDomElement toXml(QDomDocument &, QHash<Terminal *, int> &) const;
         QUuid uuid() const;
         int orientation() const;
 		

sources/qetgraphicsitem/elementtextitemgroup.cpp

@@ -384,7 +384,6 @@ QDomElement ElementTextItemGroup::toXml(QDomDocument &dom_document) const
 	return dom_element;
 }
 
-// TOOD: inherit from propertiesinterface
 /**
  * @brief ElementTextItemGroup::fromXml
  * Import data of this group from xml

sources/qetgraphicsitem/elementtextitemgroup.h

@@ -32,7 +32,7 @@ class CrossRefItem;
  * This class represent a group of element text
  * Texts in the group can be aligned left / center /right
  */
-class ElementTextItemGroup : public QObject, public  QGraphicsItemGroup // TODO: derive from PropertiesInterface
+class ElementTextItemGroup : public QObject, public  QGraphicsItemGroup
 {
 	Q_OBJECT
 	
@@ -108,7 +108,7 @@ class ElementTextItemGroup : public QObject, public  QGraphicsItemGroup // TODO:
 			 m_hold_to_bottom_of_page = false,
 			 m_block_alignment_update = false,
 			 m_frame = false;
-        QPointF m_initial_position{QPointF(0,0)};
+		QPointF m_initial_position;
 		int m_vertical_adjustment = 0;
 		CrossRefItem *m_Xref_item = nullptr;
 		Element *m_parent_element = nullptr;

sources/qetgraphicsitem/independenttextitem.cpp

@@ -49,7 +49,6 @@ IndependentTextItem::IndependentTextItem(const QString &text) :
 IndependentTextItem::~IndependentTextItem() {
 }
 
-// TODO: inherit from PropertiesInterface
 /**
 	Permet de lire le texte a mettre dans le champ a partir d'un element XML.
 	Cette methode se base sur la position du champ pour assigner ou non la

sources/qetgraphicsitem/qetgraphicsitem.cpp

@@ -25,7 +25,10 @@
  * @param parent, Parent Item
  */
 QetGraphicsItem::QetGraphicsItem(QGraphicsItem *parent):
-    QGraphicsObject(parent)
+	QGraphicsObject(parent),
+	is_movable_(true),
+	m_first_move(true),
+	snap_to_grid_(true)
 {}
 
 QetGraphicsItem::~QetGraphicsItem()

sources/qetgraphicsitem/qetgraphicsitem.h

@@ -53,10 +53,10 @@ class QetGraphicsItem : public QGraphicsObject
 		void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
 
 	protected:
-        bool is_movable_{true};
+		bool is_movable_;
-        bool m_first_move{true};
+		bool m_first_move;
-        bool snap_to_grid_{true};
+		bool snap_to_grid_;
-        QPointF m_mouse_to_origin_movement{QPointF(0,0)};
+		QPointF m_mouse_to_origin_movement;
 		QET::GraphicsItemState m_state = QET:: GIOK;
 
 };

sources/qetgraphicsitem/qetshapeitem.cpp

@@ -830,7 +830,6 @@ void QetShapeItem::handlerMouseReleaseEvent(QetGraphicsHandlerItem *qghi, QGraph
 	}
 }
 
-// TODO: inherit from Propertiesinterface!
 /**
  * @brief QetShapeItem::fromXml
  * Build this item from the xml description

sources/qetgraphicsitem/slaveelement.cpp

@@ -29,10 +29,10 @@
  * @param s parent diagram
  * @param state int used to know if the creation of element have error
  */
-SlaveElement::SlaveElement(const ElementsLocation &location, QGraphicsItem *parent, int *state) :
+SlaveElement::SlaveElement(const ElementsLocation &location, QGraphicsItem *qgi, int *state) :
-    Element(location, parent, state, Element::Slave)
+	Element(location, qgi, state, Element::Slave)
 {
-
+	m_xref_item = nullptr;
 }
 
 /**

sources/qetgraphicsitem/slaveelement.h

@@ -25,14 +25,14 @@ class SlaveElement : public Element
 {
 	Q_OBJECT
 	public:
-        explicit SlaveElement (const ElementsLocation &, QGraphicsItem * parent= nullptr, int * = nullptr);
+		explicit SlaveElement (const ElementsLocation &, QGraphicsItem * = nullptr, int * = nullptr);
 		~SlaveElement() override;
 		void linkToElement(Element *elmt) override;
 		void unlinkAllElements() override;
 		void unlinkElement(Element *elmt) override;
 	
 	private:
-        QGraphicsTextItem *m_xref_item{nullptr};
+		QGraphicsTextItem *m_xref_item;
 };
 
 #endif // SLAVEELEMENT_H

sources/qetgraphicsitem/terminal.cpp

@@ -30,7 +30,7 @@ QColor Terminal::neutralColor      = QColor(Qt::blue);
 QColor Terminal::allowedColor      = QColor(Qt::darkGreen);
 QColor Terminal::warningColor      = QColor("#ff8000");
 QColor Terminal::forbiddenColor    = QColor(Qt::red);
-const qreal Terminal::terminalSize = 4.0; // TODO: store terminalSize in terminaldata, because in PartTerminal there is the same parameter. So only one is needed
+const qreal Terminal::terminalSize = 4.0;
 const qreal Terminal::Z = 1000;
 
 /**
@@ -42,6 +42,8 @@ const qreal Terminal::Z = 1000;
 */
 void Terminal::init(QString number, QString name, bool hiddenName) {
 
+	hovered_color_  = Terminal::neutralColor;
+	
 	// calcul de la position du point d'amarrage a l'element
 	dock_elmt_ = d->m_pos;
 	switch(d->m_orientation) {
@@ -54,15 +56,17 @@ void Terminal::init(QString number, QString name, bool hiddenName) {
 	// Number of terminal
 	number_terminal_ = std::move(number);
 	// Name of terminal
-    d->m_name = std::move(name);
+	name_terminal_ = std::move(name);
 	name_terminal_hidden = hiddenName;
 	// par defaut : pas de conducteur
 	
 	// QRectF null
 	br_ = new QRectF();
+	previous_terminal_ = nullptr;
 	// divers
 	setAcceptHoverEvents(true);
 	setAcceptedMouseButtons(Qt::LeftButton);
+	hovered_ = false;
 	setToolTip(QObject::tr("Borne", "tooltip"));
 	setZValue(Z);
 }
@@ -193,18 +197,10 @@ void Terminal::setNumber(QString number) {
 	@param name
 */
 void Terminal::setName(QString name, bool hiddenName) {
-    d->m_name = std::move(name);
+	name_terminal_ = std::move(name);
 	name_terminal_hidden = hiddenName;
 }
 
-/**
-    @brief Terminal::name
-    @return the name of terminal.
-*/
-inline QString Terminal::name() const {
-    return(d->m_name);
-}
-
 /**
 	@brief Terminal::addConductor
 	Add a conductor to this terminal
@@ -706,10 +702,6 @@ bool Terminal::canBeLinkedTo(Terminal *other_terminal)
 	return true;
 }
 
-void Terminal::setID(int id) {
-    m_id = id;
-}
-
 /**
 	@brief Terminal::conductors
 	@return La liste des conducteurs lies a cette borne
@@ -727,24 +719,15 @@ QList<Conductor *> Terminal::conductors() const {
 QDomElement Terminal::toXml(QDomDocument &doc) const {
 	QDomElement qdo = doc.createElement("terminal");
 
-    qdo.appendChild(createXmlProperty(doc, "number", number_terminal_));
+	// for backward compatibility
-    qdo.appendChild(createXmlProperty(doc, "nameHidden", name_terminal_hidden));
+	qdo.setAttribute("x", QString("%1").arg(dock_elmt_.x()));
-
+	qdo.setAttribute("y",  QString("%1").arg(dock_elmt_.y()));
-    // store terminal data too!
+	// end for backward compatibility
-
-    // Do not store terminal data in its own child
-    // Bad hack. The problem is that in the diagrams the terminal is described by the position and in the Collection by the dock.
-    QPointF tempPos = d->m_pos;
-    d->m_pos = dock_elmt_;
-    QDomElement terminalDataElement = d->toXml(doc);
-    d->m_pos = tempPos;
-
-    int childsCount = terminalDataElement.childNodes().count();
-    for (int i=0; i < childsCount; i++) {
-        QDomNode node = terminalDataElement.childNodes().at(i).cloneNode(); // cloneNode() is important, otherwise no deep clone is made
-        qdo.appendChild(node);
-    }
 
+	qdo.setAttribute("orientation", d->m_orientation);
+	qdo.setAttribute("number", number_terminal_);
+	qdo.setAttribute("name", name_terminal_);
+	qdo.setAttribute("nameHidden", name_terminal_hidden);
 	return(qdo);
 }
 
@@ -754,24 +737,41 @@ QDomElement Terminal::toXml(QDomDocument &doc) const {
 	@param terminal Le QDomElement a analyser
 	@return true si le QDomElement passe en parametre est une borne, false sinon
 */
-bool Terminal::valideXml(const QDomElement &terminal) {
+bool Terminal::valideXml(QDomElement &terminal) {
+	// verifie le nom du tag
 	if (terminal.tagName() != "terminal") return(false);
 	
-// affuteuse_250h.qet contains in line 8398 terminals which do not have this
+	// verifie la presence des attributs minimaux
-//    if (propertyString(terminal, "number"))
+	if (!terminal.hasAttribute("x")) return(false);
-//        return false;
+	if (!terminal.hasAttribute("y")) return(false);
-// affuteuse_250h.qet contains in line 8398 terminals which do not have this
+	if (!terminal.hasAttribute("orientation")) return(false);
-//    if (propertyBool(terminal, "nameHidden"))
-//        return false;
 	
-    if (!TerminalData::valideXml(terminal))
+	bool conv_ok;
-        return false;
+	// parse l'abscisse
+	terminal.attribute("x").toDouble(&conv_ok);
+	if (!conv_ok) return(false);
 	
-    // a ce stade, la borne est syntaxiquement correcte
+	// parse l'ordonnee
-    return true;
+	terminal.attribute("y").toDouble(&conv_ok);
+	if (!conv_ok) return(false);
+	
+	// parse l'id
+	terminal.attribute("id").toInt(&conv_ok);
+	if (!conv_ok) return(false);
+	
+	// parse l'orientation
+	int terminal_or = terminal.attribute("orientation").toInt(&conv_ok);
+	if (!conv_ok) return(false);
+	if (terminal_or != Qet::North
+			&& terminal_or != Qet::South
+			&& terminal_or != Qet::East
+			&& terminal_or != Qet::West) return(false);
+	
+	// a ce stade, la borne est syntaxiquement correcte
+	return(true);
 }
 
-/** RETURNS True
+/**
 	@brief Terminal::fromXml
 	Permet de savoir si un element XML represente cette borne. Attention,
 	l'element XML n'est pas verifie
@@ -779,17 +779,16 @@ bool Terminal::valideXml(const QDomElement &terminal) {
 	@return true si la borne "se reconnait"
 	(memes coordonnes, meme orientation), false sinon
 */
-bool Terminal::fromXml(const QDomElement &terminal) {
+bool Terminal::fromXml(QDomElement &terminal) {
-    propertyString(terminal, "number", &number_terminal_);
+	number_terminal_ = terminal.attribute("number");
+	name_terminal_ = terminal.attribute("name");
+	name_terminal_hidden = terminal.attribute("nameHidden").toInt();
 
-    propertyBool(terminal, "nameHidden", &name_terminal_hidden);
+	return (
-
+		qFuzzyCompare(terminal.attribute("x").toDouble(), dock_elmt_.x()) &&
-    if(!d->fromXml(terminal))
+		qFuzzyCompare(terminal.attribute("y").toDouble(), dock_elmt_.y()) &&
-        return false;
+		(terminal.attribute("orientation").toInt() == d->m_orientation)
-
+	);
-
-    init(number_terminal_, d->m_name, name_terminal_hidden); // initialize dock_elmt_. This must be done after Terminal data is initialized
-    return true;
 }
 
 /**
@@ -822,18 +821,6 @@ QUuid Terminal::uuid() const {
 	return d->m_uuid;
 }
 
-int Terminal::ID() const {
-    return m_id;
-}
-
-QPointF Terminal::dockPos() {
-    return dock_elmt_;
-}
-
-QPointF Terminal::originPos() {
-    return d->m_pos;
-}
-
 /**
 	@brief Conductor::relatedPotentialTerminal
 	Return terminal at the same potential from the same

sources/qetgraphicsitem/terminal.h

@@ -20,8 +20,6 @@
 #include <QtWidgets>
 #include <QtXml>
 #include "qet.h"
-#include "propertiesinterface.h"
-
 class Conductor;
 class Diagram;
 class Element;
@@ -33,7 +31,7 @@ class TerminalData;
 	plug point for conductors.
 	This class handles all mouse events for connecting conductors
 */
-class Terminal : public QGraphicsObject, public PropertiesInterface
+class Terminal : public QGraphicsObject
 {
 	Q_OBJECT
 
@@ -77,9 +75,6 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
 		Diagram  *diagram             () const;
 		Element  *parentElement       () const;
 		QUuid uuid                    () const;
-        int ID() const;
-        QPointF dockPos();
-        QPointF originPos();
 	
 		QList<Conductor *> conductors() const;
 		Qet::Orientation orientation() const;
@@ -91,12 +86,11 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
 		void updateConductor();
 		bool isLinkedTo(Terminal *);
 		bool canBeLinkedTo(Terminal *);
-        void setID(int id);
 	
 		// methods related to XML import/export
-        static bool valideXml(const QDomElement  &);
+		static bool valideXml(QDomElement  &);
-        bool fromXml (const QDomElement &) override;
+		bool fromXml (QDomElement &);
-        QDomElement toXml (QDomDocument &) const override;
+		QDomElement toXml (QDomDocument &) const;
 	
 	protected:
 		// methods related to events management
@@ -113,10 +107,9 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
 
 		static const qreal terminalSize;
 		static const qreal Z;
-        // Various static colors used for hover effects.
+		// Various static colors used for hover effects
-        // The assignement is in the cpp file
 		/// default color
-        static QColor neutralColor;
+		static QColor neutralColor;
 		/// color for legal actions
 		static QColor allowedColor;
 		/// color for allowed but fuzzy or not recommended  actions
@@ -145,17 +138,16 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
 		*/
 		QRectF *br_{nullptr};
 		/// Last terminal seen through an attached conductor
-        Terminal *previous_terminal_{nullptr};
+		Terminal *previous_terminal_;
 		/// Whether the mouse pointer is hovering the terminal
-        bool hovered_{false};
+		bool hovered_;
 		/// Color used for the hover effect
-        QColor hovered_color_{Terminal::hovered_color_};
+		QColor hovered_color_;
 		/// Number of Terminal
 		QString number_terminal_;
-        bool name_terminal_hidden{true};
+		/// Name of Terminal
-
+		QString name_terminal_;
-        /// legacy id used by the conductor to find the terminal. From 0.8x on the uuid is used instead.
+		bool name_terminal_hidden;
-        int m_id{-1};
 	
 	private:
 		void init(QString number, QString name, bool hiddenName);
@@ -179,6 +171,14 @@ inline QString Terminal::number() const {
 	return(number_terminal_);
 }
 
+/**
+	@brief Terminal::name
+	@return the name of terminal.
+*/
+inline QString Terminal::name() const {
+	return(name_terminal_);
+}
+
 QList<Terminal *> relatedPotentialTerminal (const Terminal *terminal,
 					    const bool all_diagram = true);
 

sources/qetproject.cpp

@@ -1425,11 +1425,7 @@ void QETProject::readDefaultPropertiesXml(QDomDocument &xml_project)
 		{
 			XRefProperties xrp;
 			xrp.fromXml(elmt);
-            QString type;
+			m_default_xref_properties.insert(elmt.attribute("type"), xrp);
-            if (PropertiesInterface::propertyString(elmt, "type", &type) == PropertiesInterface::PropertyFlags::Success)
-                m_default_xref_properties.insert(type, xrp);
-            else
-                qDebug() << "xref Property was not added to m_default_xref_properties.";
 		}
 	}
 	if (!conds_autonums.isNull())
@@ -1487,13 +1483,19 @@ void QETProject::writeDefaultPropertiesXml(QDomElement &xml_element)
 	QDomDocument xml_document = xml_element.ownerDocument();
 	
 	// export size of border
-    xml_element.appendChild(default_border_properties_.toXml(xml_document));
+	QDomElement border_elmt = xml_document.createElement("border");
+	default_border_properties_.toXml(border_elmt);
+	xml_element.appendChild(border_elmt);
 	
 	// export content of titleblock
-    xml_element.appendChild(default_titleblock_properties_.toXml(xml_document));
+	QDomElement titleblock_elmt = xml_document.createElement("inset");
+	default_titleblock_properties_.toXml(titleblock_elmt);
+	xml_element.appendChild(titleblock_elmt);
 	
 	// exporte default conductor
-    xml_element.appendChild(default_conductor_properties_.toXml(xml_document));
+	QDomElement conductor_elmt = xml_document.createElement("conductors");
+	default_conductor_properties_.toXml(conductor_elmt);
+	xml_element.appendChild(conductor_elmt);
 
 	// export default report properties
 	QDomElement report_elmt = xml_document.createElement("report");

sources/titleblock/helpercell.cpp

@@ -23,7 +23,12 @@
 */
 HelperCell::HelperCell(QGraphicsItem *parent) :
 	QGraphicsObject(parent),
-    QGraphicsLayoutItem()
+	QGraphicsLayoutItem(),
+	background_color(Qt::white),
+	foreground_color(Qt::black),
+	label(),
+	orientation(Qt::Horizontal),
+	index(-1)
 {
 	setGraphicsItem(this);
 	setFlag(QGraphicsItem::ItemIsSelectable, false);

sources/titleblock/helpercell.h

@@ -37,11 +37,11 @@ class HelperCell : public QGraphicsObject, public QGraphicsLayoutItem {
 	
 	// attributes
 	public:
-    QColor background_color{Qt::white};     ///< Background color when rendering this cell
+	QColor background_color;     ///< Background color when rendering this cell
-    QColor foreground_color{Qt::black};     ///< Text color when rendering this cell
+	QColor foreground_color;     ///< Text color when rendering this cell
 	QString label;               ///< Label displayed in this cell
-    Qt::Orientation orientation{Qt::Horizontal}; ///< Orientation of this cell
+	Qt::Orientation orientation; ///< Orientation of this cell
-    int index{-1};                   ///< Index of this cell
+	int index;                   ///< Index of this cell
 	
 	// methods
 	public:

sources/titleblock/splittedhelpercell.h

@@ -36,7 +36,6 @@ class SplittedHelperCell : public HelperCell {
 	void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget * = nullptr) override;
 	
 	// attributes
-    // colors are set in the constructor
 	QColor split_background_color; ///< Background color on the split side
 	QColor split_foreground_color; ///< Text color on the split side
 	QString split_label;           ///< Text displayed on the split side

sources/titleblockproperties.cpp

@@ -23,7 +23,11 @@
 	Constructeur. Initialise un objet TitleBlockProperties avec tous les champs
 	vides (date vide + useDate a UseDateValue).
 */
-TitleBlockProperties::TitleBlockProperties()
+TitleBlockProperties::TitleBlockProperties() :
+	date(),
+	useDate(UseDateValue),
+	display_at(Qt::BottomEdge),
+	collection (QET::QetCollection::Common)
 {
 }
 
@@ -70,67 +74,53 @@ bool TitleBlockProperties::operator!=(const TitleBlockProperties &ip) {
 	@param e Element XML auquel seront ajoutes des attributs
 */
 void TitleBlockProperties::toXml(QDomElement &e) const {
+	e.setAttribute("author",   author);
+	e.setAttribute("title",    title);
+	e.setAttribute("filename", filename);
+	e.setAttribute("plant", plant);
+	e.setAttribute("locmach", locmach);
+	e.setAttribute("indexrev",indexrev);
+	e.setAttribute("version", version);
+	e.setAttribute("folio",    folio);
+	e.setAttribute("auto_page_num", auto_page_num);
+	e.setAttribute("date",     exportDate());
+	e.setAttribute("displayAt", (display_at == Qt::BottomEdge? "bottom" : "right"));
+	if (!template_name.isEmpty())
+	{
+		e.setAttribute("titleblocktemplate", template_name);
+		e.setAttribute("titleblocktemplateCollection", QET::qetCollectionToString(collection));
+	}
 	
-    e.setAttribute("author",   author);
+	if (context.keys().count()) {
-    e.setAttribute("title",    title);
+		QDomElement properties = e.ownerDocument().createElement("properties");
-    e.setAttribute("filename", filename);
+		context.toXml(properties);
-    e.setAttribute("plant", plant);
+		e.appendChild(properties);
-    e.setAttribute("locmach", locmach);
+	}
-    e.setAttribute("indexrev",indexrev);
-    e.setAttribute("version", version);
-    e.setAttribute("folio",    folio);
-    e.setAttribute("auto_page_num", auto_page_num);
-    e.setAttribute("date",     exportDate());
-    e.setAttribute("displayAt", (display_at == Qt::BottomEdge? "bottom" : "right"));
-    if (!template_name.isEmpty())
-    {
-        e.setAttribute("titleblocktemplate", template_name);
-        e.setAttribute("titleblocktemplateCollection", QET::qetCollectionToString(collection));
-    }
-
-    if (context.keys().count()) {
-        QDomElement properties = e.ownerDocument().createElement("properties");
-        context.toXml(properties);
-        e.appendChild(properties);
-    }
 }
 
-QDomElement TitleBlockProperties::toXml(QDomDocument &d) const {
+/**
-    Q_UNUSED(d)
-    qDebug() << "NOT IMPLEMENTED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!";
-    return QDomElement();
-}
-
-/** RETURNS True
 	Importe le cartouche a partir des attributs XML de l'element e
 	@param e Element XML dont les attributs seront lus
 */
-bool TitleBlockProperties::fromXml(const QDomElement &e) {
+void TitleBlockProperties::fromXml(const QDomElement &e) {
+	// reads the historical fields
+	if (e.hasAttribute("author"))      author   = e.attribute("author");
+	if (e.hasAttribute("title"))       title    = e.attribute("title");
+	if (e.hasAttribute("filename"))    filename = e.attribute("filename");
+	if (e.hasAttribute("plant"))       plant   = e.attribute("plant");
+	if (e.hasAttribute("locmach"))     locmach  = e.attribute("locmach");
+	if (e.hasAttribute("indexrev"))    indexrev  = e.attribute("indexrev");
+	if (e.hasAttribute("version"))     version   = e.attribute("version");
+	if (e.hasAttribute("folio"))       folio    = e.attribute("folio");
+	if (e.hasAttribute("auto_page_num")) auto_page_num = e.attribute("auto_page_num");
+	if (e.hasAttribute("date"))        setDateFromString(e.attribute("date"));
+	if (e.hasAttribute("displayAt")) display_at = (e.attribute("displayAt") == "bottom" ? Qt::BottomEdge : Qt::RightEdge);
 	
-
+		// reads the template used to render the title block
-    // reads the historical fields
+	if (e.hasAttribute("titleblocktemplate"))
-    propertyString(e, "author", &author);
+	{
-    propertyString(e, "title", &title);
+		template_name = e.attribute("titleblocktemplate");
-    propertyString(e, "filename", &filename);
+		collection = QET::qetCollectionFromString(e.attribute("titleblocktemplateCollection"));
-    propertyString(e, "plant", &plant);
-    propertyString(e, "locmach", &locmach);
-    propertyString(e, "indexrev", &indexrev);
-    propertyString(e, "version", &version);
-    propertyString(e, "folio", &folio);
-    propertyString(e, "auto_page_num", &auto_page_num);
-    QString date;
-    propertyString(e, "date", &date);
-    setDateFromString(date);
-
-    QString display_at_temp;
-    if (propertyString(e, "displayAt", &display_at_temp) == PropertyFlags::Success)
-        display_at = (display_at_temp == "bottom" ? Qt::BottomEdge : Qt::RightEdge); // otherwise it gets default in header file
-
-    // reads the template used to render the title block
-    if (propertyString(e, "titleblocktemplate", &template_name) == PropertyFlags::Success) {
-        QString tbc;
-        if (propertyString(e, "titleblocktemplateCollection", &tbc) == PropertyFlags::Success)
-            collection = QET::qetCollectionFromString(tbc);
 	}
 	
 	// reads the additional fields used to fill the title block
@@ -138,7 +128,6 @@ bool TitleBlockProperties::fromXml(const QDomElement &e) {
 	foreach (QDomElement e, QET::findInDomElement(e, "properties")) {
 		context.fromXml(e);
 	}
-    return true;
 }
 
 /**
@@ -169,7 +158,7 @@ void TitleBlockProperties::toSettings(QSettings &settings, const QString &prefix
 	@param settings Parametres a lire
 	@param prefix prefixe a ajouter devant les noms des parametres
 */
-void TitleBlockProperties::fromSettings(const QSettings &settings, const QString &prefix) {
+void TitleBlockProperties::fromSettings(QSettings &settings, const QString &prefix) {
 	title    = settings.value(prefix + "title").toString();
 	author   = settings.value(prefix + "author").toString();
 	filename = settings.value(prefix + "filename").toString();

sources/titleblockproperties.h

@@ -21,14 +21,12 @@
 #include "diagramcontext.h"
 #include "qet.h"
 
-#include "propertiesinterface.h"
-
 /**
 	This class provides a container for the properties of a particular title
 	block, i.e. title, author, date, filename, folio, template, custom
 	properties, ...
 */
-class TitleBlockProperties: public PropertiesInterface {
+class TitleBlockProperties {
 	public:
 	TitleBlockProperties();
 	virtual ~TitleBlockProperties();
@@ -41,11 +39,10 @@ class TitleBlockProperties: public PropertiesInterface {
 	bool operator==(const TitleBlockProperties &);
 	bool operator!=(const TitleBlockProperties &);
 	
-    QDomElement toXml(QDomDocument &e) const override;
+	void toXml(QDomElement &) const;
-    void toXml(QDomElement &e) const;
+	void fromXml(const QDomElement &);
-    bool fromXml(const QDomElement &) override;
+	void toSettings(QSettings &, const QString & = QString()) const;
-    void toSettings(QSettings &, const QString & = QString()) const override;
+	void fromSettings(QSettings &, const QString & = QString());
-    void fromSettings(const QSettings &, const QString & = QString()) override;
 
 	void setAutoPageNum(QString autonum) {auto_page_num = autonum;}
 
@@ -64,11 +61,11 @@ class TitleBlockProperties: public PropertiesInterface {
 	QString version;          ///< Version (displayed by the default template)
 	QString folio;            ///< Folio information (displayed by the default template)
 	QString auto_page_num;
-    DateManagement useDate{UseDateValue};   ///< Wheter to use the date attribute
+	DateManagement useDate;   ///< Wheter to use the date attribute
 	QString template_name;    ///< Name of the template used to render the title block - an empty string means "the default template provided by the application"
 	DiagramContext context;   ///< Container for the additional, user-defined fields
-    Qt::Edge display_at{Qt::Edge::BottomEdge};       ///< Edge to display the titleblock
+	Qt::Edge display_at;       ///< Edge to display the titleblock
-    QET::QetCollection collection{QET::QetCollection::Common}; ///<Specify the location of the title block
+	QET::QetCollection collection; ///<Specify the location of the title block
 
 	private:
 	QString exportDate() const;

sources/ui/dynamicelementtextitemeditor.cpp

@@ -186,6 +186,10 @@ QUndoCommand *DynamicElementTextItemEditor::associatedUndo() const
 		return nullptr;
 }
 
+/*!
+ * \brief DynamicElementTextItemEditor::dataEdited
+ * Apply changes to the text item. It is called when dataChanged() signal is called
+ */
 void DynamicElementTextItemEditor::dataEdited()
 {
 	if (m_live_edit)

sources/ui/dynamicelementtextitemeditor.h

@@ -29,6 +29,10 @@ namespace Ui {
 	class DynamicElementTextItemEditor;
 }
 
+/*!
+ * \brief The DynamicElementTextItemEditor class
+ * Widget used to modify the properties of DynamicElementTextItem.
+ */
 class DynamicElementTextItemEditor : public AbstractElementPropertiesEditorWidget
 {
     Q_OBJECT

sources/ui/dynamicelementtextmodel.cpp

@@ -57,6 +57,10 @@ static int adjust_grp_row         = 4;
 static int frame_grp_row          = 5;
 static int hold_to_bottom_grp_row = 6;
 
+const char* user_text = "Texte utilisateur";
+const char* element_information = "Information de l'élément";
+const char* composite_text = "Texte composé";
+
 DynamicElementTextModel::DynamicElementTextModel(Element *element, QObject *parent) :
 	QStandardItemModel(parent),
 	m_element(element)
@@ -136,9 +140,9 @@ QList<QStandardItem *> DynamicElementTextModel::itemsForText(DynamicElementTextI
     src->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     
 	QString title;
-	if (deti->textFrom() == DynamicElementTextItem::UserText) title = tr("Texte utilisateur");
+    if (deti->textFrom() == DynamicElementTextItem::UserText) title = tr(user_text);
-	else if (deti->textFrom() == DynamicElementTextItem::ElementInfo) title = tr("Information de l'élément");
+    else if (deti->textFrom() == DynamicElementTextItem::ElementInfo) title = tr(element_information);
-	else title =  tr("Texte composé");
+    else title =  tr(composite_text);
     QStandardItem *srca = new QStandardItem(title);
     srca->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
     srca->setData(textFrom, Qt::UserRole+1);
@@ -172,7 +176,7 @@ QList<QStandardItem *> DynamicElementTextModel::itemsForText(DynamicElementTextI
     qsi->appendRow(qsi_list);
 	
 		//Composite text
-	QStandardItem *composite = new QStandardItem(tr("Texte composé"));
+    QStandardItem *composite = new QStandardItem(tr(composite_text));
 	composite->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	
 	DiagramContext dc;
@@ -397,7 +401,7 @@ DynamicElementTextItem *DynamicElementTextModel::textFromItem(QStandardItem *ite
 	
 	
 	QStandardItem *text_item = item;
-	while (text_item->parent())
+    while (text_item->parent()) // recursive search for the highest parent
 		text_item = text_item->parent();
 	
 	if (m_texts_list.values().contains(text_item)) //The item is a text
@@ -458,26 +462,26 @@ QUndoCommand *DynamicElementTextModel::undoForEditedText(DynamicElementTextItem
 	QStandardItem *text_qsi = m_texts_list.value(deti);
 	
 	QString from = text_qsi->child(src_txt_row,1)->data(Qt::DisplayRole).toString();
-	if ((from == tr("Texte utilisateur")) && (deti->textFrom() != DynamicElementTextItem::UserText))
+    if ((from == tr(user_text)) && (deti->textFrom() != DynamicElementTextItem::UserText))
 		new QPropertyUndoCommand(deti, "textFrom", QVariant(deti->textFrom()), QVariant(DynamicElementTextItem::UserText), undo);
-	else if ((from == tr("Information de l'élément")) && (deti->textFrom() != DynamicElementTextItem::ElementInfo))
+    else if ((from == tr(element_information)) && (deti->textFrom() != DynamicElementTextItem::ElementInfo))
 		new QPropertyUndoCommand(deti, "textFrom", QVariant(deti->textFrom()), QVariant(DynamicElementTextItem::ElementInfo), undo);
-	else if ((from == tr("Texte composé")) && (deti->textFrom() != DynamicElementTextItem::CompositeText))
+    else if ((from == tr(composite_text)) && (deti->textFrom() != DynamicElementTextItem::CompositeText))
 		new QPropertyUndoCommand(deti, "textFrom", QVariant(deti->textFrom()), QVariant(DynamicElementTextItem::CompositeText), undo);
 	
-	if(from == tr("Texte utilisateur"))
+    if(from == tr(user_text))
 	{
 		QString text = text_qsi->child(usr_txt_row,1)->data(Qt::DisplayRole).toString();
 		if (text != deti->text())
 			new QPropertyUndoCommand(deti, "text", QVariant(deti->text()), QVariant(text), undo);
 	}
-	else if (from == tr("Information de l'élément"))
+    else if (from == tr(element_information))
 	{
 		QString info_name = text_qsi->child(info_txt_row,1)->data(Qt::UserRole+2).toString();
 		if(info_name != deti->infoName())
 			new QPropertyUndoCommand(deti, "infoName", QVariant(deti->infoName()), QVariant(info_name), undo);
 	}
-	else if (from == tr("Texte composé"))
+    else if (from == tr(composite_text))
 	{
 		QString composite_text = text_qsi->child(compo_txt_row,1)->data(Qt::UserRole+2).toString();
 		if(composite_text != deti->compositeText())
@@ -1112,6 +1116,7 @@ void DynamicElementTextModel::enableSourceText(DynamicElementTextItem *deti, Dyn
 		case DynamicElementTextItem::CompositeText: compo = true;break;
 	}
 
+    m_ignore_item_change = true;
 		//User text
 	qsi->child(usr_txt_row,0)->setEnabled(usr);
 	qsi->child(usr_txt_row,1)->setEnabled(usr);
@@ -1120,6 +1125,7 @@ void DynamicElementTextModel::enableSourceText(DynamicElementTextItem *deti, Dyn
 	qsi->child(info_txt_row,1)->setEnabled(info);
 		//Composite text
 	qsi->child(compo_txt_row,0)->setEnabled(compo);
+    m_ignore_item_change = false;
 	qsi->child(compo_txt_row,1)->setEnabled(compo);
 }
 
@@ -1157,6 +1163,10 @@ void DynamicElementTextModel::enableGroupRotationAndPos(ElementTextItemGroup *gr
 
 void DynamicElementTextModel::itemDataChanged(QStandardItem *qsi)
 {
+
+    if (m_ignore_item_change)
+        return;
+
 	DynamicElementTextItem *deti = textFromItem(qsi);
 	ElementTextItemGroup *etig = groupFromItem(qsi);
 	if (!deti && !etig)
@@ -1170,15 +1180,15 @@ void DynamicElementTextModel::itemDataChanged(QStandardItem *qsi)
 			dc = deti->elementUseForInfo()->elementInformations();
 		
 		if (qsi->data().toInt() == textFrom)
-		{
+        { // change textFrom
 			QString from = qsi->data(Qt::DisplayRole).toString();
 			
-			if (from == tr("Texte utilisateur"))
+            if (from == tr(user_text))
 			{
 				enableSourceText(deti, DynamicElementTextItem::UserText);
 				text_qsi->setData(text_qsi->child(usr_txt_row,1)->data(Qt::DisplayRole).toString());
 			}
-			else if (from == tr("Information de l'élément"))
+            else if (from == tr(element_information))
 			{
 				enableSourceText(deti, DynamicElementTextItem::ElementInfo);
 				QString info = text_qsi->child(info_txt_row,1)->data(Qt::UserRole+2).toString();
@@ -1213,7 +1223,7 @@ void DynamicElementTextModel::itemDataChanged(QStandardItem *qsi)
 		//We emit the signal only if @qsi is in the second column, because the data are stored on this column
 		//the first column is use only for display the title of the property, except for the name of texts group
 	if((m_groups_list.values().contains(qsi) || qsi->column() == 1) && !m_block_dataChanged)
-		emit dataChanged();
+        emit dataChanged(); // TODO: where it goes?
     if(deti) deti->updateXref();
 }
 
@@ -1309,9 +1319,9 @@ void DynamicElementTextModel::updateDataFromText(DynamicElementTextItem *deti, V
 		{
 			switch (deti->textFrom())
 			{
-				case DynamicElementTextItem::UserText: qsi->child(0,1)->setData(tr("Texte utilisateur"), Qt::DisplayRole); break;
+                case DynamicElementTextItem::UserText: qsi->child(0,1)->setData(tr(user_text), Qt::DisplayRole); break;
-				case DynamicElementTextItem::ElementInfo : qsi->child(0,1)->setData(tr("Information de l'élément"), Qt::DisplayRole); break;
+                case DynamicElementTextItem::ElementInfo : qsi->child(0,1)->setData(tr(element_information), Qt::DisplayRole); break;
-				case DynamicElementTextItem::CompositeText : qsi->child(0,1)->setData(tr("Texte composé"), Qt::DisplayRole); break;
+                case DynamicElementTextItem::CompositeText : qsi->child(0,1)->setData(tr(composite_text), Qt::DisplayRole); break;
 			}
 			enableSourceText(deti, deti->textFrom());
 			qsi->setData(deti->toPlainText(), Qt::DisplayRole);
@@ -1448,6 +1458,15 @@ DynamicTextItemDelegate::DynamicTextItemDelegate(QObject *parent) :
     QStyledItemDelegate(parent)
 {}
 
+/*!
+ * \brief DynamicTextItemDelegate::createEditor
+ * Different widgets are used depending of the data which should be shown in the view.
+ * For example for choosing color, a color chooser is used.
+ * \param parent
+ * \param option
+ * \param index
+ * \return
+ */
 QWidget *DynamicTextItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
 	switch (index.data(Qt::UserRole+1).toInt())
@@ -1456,9 +1475,9 @@ QWidget *DynamicTextItemDelegate::createEditor(QWidget *parent, const QStyleOpti
 		{
 			QComboBox *qcb = new QComboBox(parent);
 			qcb->setObjectName("text_from");
-			qcb->addItem(tr("Texte utilisateur"));
+            qcb->addItem(tr(user_text));
-			qcb->addItem(tr("Information de l'élément"));
+            qcb->addItem(tr(element_information));
-			qcb->addItem(tr("Texte composé"));
+            qcb->addItem(tr(composite_text));
 			return qcb;
 		}
 		case DynamicElementTextModel::infoText:

sources/ui/dynamicelementtextmodel.h

@@ -106,6 +106,7 @@ class DynamicElementTextModel : public QStandardItemModel
 	QHash <DynamicElementTextItem *, QList<QMetaObject::Connection>> m_hash_text_connect;
 	QHash <ElementTextItemGroup *, QList<QMetaObject::Connection>> m_hash_group_connect;
 	bool m_block_dataChanged = false;
+    bool m_ignore_item_change{false};
 };
 
 class DynamicTextItemDelegate : public QStyledItemDelegate