Make code less spaghetti

Not finished yet.

sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp

@@ -16,14 +16,13 @@
 		along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "bridgeterminalscommand.h"
-#include "../terminalstrip.h"
 
 BridgeTerminalsCommand::BridgeTerminalsCommand(TerminalStrip *strip,
-											   QVector<QUuid> real_terminal_uuid,
+											   QVector<QWeakPointer<RealTerminal>> real_terminal,
 											   QUndoCommand *parent):
 	QUndoCommand(parent),
 	m_strip(strip),
-	m_uuid_vector(real_terminal_uuid)
+	m_real_terminal_vector(real_terminal)
 {
 	setText(QObject::tr("Ponter des bornes entre-elles"));
 }
@@ -31,40 +30,44 @@ BridgeTerminalsCommand::BridgeTerminalsCommand(TerminalStrip *strip,
 void BridgeTerminalsCommand::undo()
 {
 	if (m_strip) {
-		m_strip->unBridge(m_uuid_vector);
+		m_strip->unBridge(m_real_terminal_vector);
 	}
 }
 
 void BridgeTerminalsCommand::redo()
 {
 	if (m_strip) {
-		m_strip->setBridge(m_uuid_vector);
+		m_strip->setBridge(m_real_terminal_vector);
 	}
 }
 
 UnBridgeTerminalsCommand::UnBridgeTerminalsCommand(TerminalStrip *strip,
-												   QVector<QUuid> real_terminal_uuid,
+												   QVector<QWeakPointer<RealTerminal>> real_terminal,
 												   QUndoCommand *parent):
 	QUndoCommand(parent),
 	m_strip(strip)
 {
 	setText(QObject::tr("Supprimer des ponts de bornes"));
 
-	for (const auto &t_uuid : real_terminal_uuid)
+	for (const auto &real_t : real_terminal)
 	{
-		auto bridge = m_strip->bridgeFor(t_uuid);
-		if (bridge) {
-			m_bridge_terminal_map.insert(bridge->uuid_, t_uuid);
+		auto bridge_ = strip->bridgeFor(real_t);
+		if (bridge_) {
+			m_bridge_terminal_hash.insert(bridge_.toWeakRef(), real_t);
 		}
 	}
 }
 
 void UnBridgeTerminalsCommand::undo()
 {
-	if (m_strip) {
-		for (const auto &bridge_uuid : m_bridge_terminal_map.uniqueKeys()) {
-			auto terminal_list = m_bridge_terminal_map.values(bridge_uuid);
-			m_strip->setBridge(bridge_uuid, terminal_list.toVector());
+	if (m_strip)
+	{
+		for (const auto &bridge_ : m_bridge_terminal_hash.uniqueKeys())
+		{
+			if (!bridge_.isNull()) {
+				auto terminal_list = m_bridge_terminal_hash.values(bridge_);
+				m_strip->setBridge(bridge_.toStrongRef() , terminal_list.toVector());
+			}
 		}
 	}
 }
@@ -72,6 +75,6 @@ void UnBridgeTerminalsCommand::undo()
 void UnBridgeTerminalsCommand::redo()
 {
 	if (m_strip) {
-		m_strip->unBridge(m_bridge_terminal_map.values().toVector());
+		m_strip->unBridge(m_bridge_terminal_hash.values().toVector());
 	}
 }

sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h

@@ -20,11 +20,10 @@
 
 #include <QUndoCommand>
 #include <QVector>
-#include <QUuid>
 #include <QPointer>
 #include <QMultiMap>
 
-class TerminalStrip;
+#include "../terminalstrip.h"
 
 /**
  * @brief The BridgeTerminalsCommand class
@@ -34,7 +33,7 @@ class TerminalStrip;
 class BridgeTerminalsCommand : public QUndoCommand
 {
 	public:
-		BridgeTerminalsCommand(TerminalStrip *strip, QVector<QUuid> real_terminal_uuid, QUndoCommand *parent = nullptr);
+		BridgeTerminalsCommand(TerminalStrip *strip, QVector<QWeakPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
 		~BridgeTerminalsCommand() override {}
 
 		void undo() override;
@@ -42,7 +41,7 @@ class BridgeTerminalsCommand : public QUndoCommand
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		QVector<QUuid> m_uuid_vector;
+		QVector<QWeakPointer<RealTerminal>> m_real_terminal_vector;
 };
 
 
@@ -54,7 +53,7 @@ class BridgeTerminalsCommand : public QUndoCommand
 class UnBridgeTerminalsCommand : public QUndoCommand
 {
 	public:
-		UnBridgeTerminalsCommand(TerminalStrip *strip, QVector<QUuid> real_terminal_uuid, QUndoCommand *parent = nullptr);
+		UnBridgeTerminalsCommand(TerminalStrip *strip, QVector<QWeakPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
 		~UnBridgeTerminalsCommand() override{}
 
 		void undo() override;
@@ -62,7 +61,7 @@ class UnBridgeTerminalsCommand : public QUndoCommand
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		QMultiMap<QUuid, QUuid> m_bridge_terminal_map; ///Key is bridge uuid, value is real terminal uuid
+		QMultiHash<QWeakPointer<TerminalStripBridge>, QWeakPointer<RealTerminal>> m_bridge_terminal_hash; ///Key a is bridge, value is real terminal
 
 };
 

sources/TerminalStrip/UndoCommand/changeterminallevel.cpp

@@ -18,14 +18,14 @@
 #include "changeterminallevel.h"
 
 ChangeTerminalLevel::ChangeTerminalLevel(TerminalStrip *strip,
-										 const RealTerminalData &real_terminal,
+										 const QWeakPointer<RealTerminal> &real_terminal,
 										 int level,
 										 QUndoCommand *parent) :
 	QUndoCommand(parent),
 	m_strip(strip),
 	m_real_terminal(real_terminal),
 	m_new_level(level),
-	m_old_level(real_terminal.level_)
+	m_old_level(m_strip->realTerminalDataFor(real_terminal).level())
 {}
 
 void ChangeTerminalLevel::undo()

sources/TerminalStrip/UndoCommand/changeterminallevel.h

@@ -26,7 +26,7 @@ class ChangeTerminalLevel : public QUndoCommand
 {
 	public:
 		ChangeTerminalLevel(TerminalStrip *strip,
-							const RealTerminalData &real_terminal,
+							const QWeakPointer<RealTerminal> &real_terminal,
 							int level,
 							QUndoCommand *parent = nullptr);
 
@@ -35,7 +35,7 @@ class ChangeTerminalLevel : public QUndoCommand
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		RealTerminalData m_real_terminal;
+		QWeakPointer<RealTerminal> m_real_terminal;
 		int m_new_level, m_old_level;
 };
 

sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp

@@ -25,7 +25,7 @@
  */
 GroupTerminalsCommand::GroupTerminalsCommand(TerminalStrip *strip,
 											 const PhysicalTerminalData &receiver_,
-											 const QVector<RealTerminalData> &to_group,
+											 const QVector<QWeakPointer<RealTerminal>> &to_group,
 											 QUndoCommand *parent):
 	QUndoCommand(parent),
 	m_terminal_strip(strip),
@@ -48,7 +48,7 @@ void GroupTerminalsCommand::redo() {
 }
 
 UnGroupTerminalsCommand::UnGroupTerminalsCommand(TerminalStrip *strip,
-												 const QVector<RealTerminalData> &to_ungroup,
+												 const QVector<QWeakPointer<RealTerminal>> &to_ungroup,
 												 QUndoCommand *parent) :
 	QUndoCommand(parent),
 	m_terminal_strip(strip)
@@ -77,11 +77,11 @@ void UnGroupTerminalsCommand::redo()
 	}
 }
 
-void UnGroupTerminalsCommand::setUp(const QVector<RealTerminalData> &to_ungroup)
+void UnGroupTerminalsCommand::setUp(const QVector<QWeakPointer<RealTerminal>> &to_ungroup)
 {
-	for (auto rtd_ : to_ungroup)
+	for (const auto &rt_ : to_ungroup)
 	{
-		auto ptd_ = m_terminal_strip->physicalTerminalData(rtd_);
+		auto ptd_ = m_terminal_strip->physicalTerminalData(rt_);
 
 			//Physical have only one real terminal, no need to ungroup it
 		if (ptd_.real_terminals_vector.size() <= 1) {
@@ -89,7 +89,7 @@ void UnGroupTerminalsCommand::setUp(const QVector<RealTerminalData> &to_ungroup)
 		}
 
 		auto vector_ = m_physical_real_H.value(ptd_);
-		vector_.append(rtd_);
+		vector_.append(rt_);
 		m_physical_real_H.insert(ptd_, vector_);
 	}
 }

sources/TerminalStrip/UndoCommand/groupterminalscommand.h

@@ -32,7 +32,7 @@ class GroupTerminalsCommand : public QUndoCommand
 	public:
 		GroupTerminalsCommand(TerminalStrip *strip,
 							  const PhysicalTerminalData &receiver_,
-							  const QVector<RealTerminalData> &to_group,
+							  const QVector<QWeakPointer<RealTerminal>> &to_group,
 							  QUndoCommand *parent = nullptr);
 
 		void undo() override;
@@ -41,7 +41,7 @@ class GroupTerminalsCommand : public QUndoCommand
 	private:
 		QPointer<TerminalStrip> m_terminal_strip;
 		PhysicalTerminalData m_receiver;
-		QVector <RealTerminalData> m_to_group;
+		QVector<QWeakPointer<RealTerminal>> m_to_group;
 };
 
 /**
@@ -52,18 +52,18 @@ class UnGroupTerminalsCommand : public QUndoCommand
 {
 	public:
 		UnGroupTerminalsCommand(TerminalStrip *strip,
-								const QVector<RealTerminalData> &to_ungroup,
+								const QVector<QWeakPointer<RealTerminal>> &to_ungroup,
 								QUndoCommand *parent = nullptr);
 
 		void undo() override;
 		void redo() override;
 
 	private:
-		void setUp(const QVector<RealTerminalData> &to_ungroup);
+		void setUp(const QVector<QWeakPointer<RealTerminal>> &to_ungroup);
 
 	private:
 		QPointer<TerminalStrip> m_terminal_strip;
-		QHash <PhysicalTerminalData, QVector<RealTerminalData>> m_physical_real_H;
+		QHash <PhysicalTerminalData, QVector<QWeakPointer<RealTerminal>>> m_physical_real_H;
 };
 
 #endif // GROUPTERMINALSCOMMAND_H

sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp

@@ -54,7 +54,7 @@ void SortTerminalStripCommand::sort()
 
 		if (arg1.real_terminals_vector.count())
 		{
-			str1 = arg1.real_terminals_vector.constLast().label_;
+			str1 = arg1.real_terminals_vector.constLast().label();
 
 			auto match = rx.match(str1);
 			if (match.hasMatch()) {
@@ -64,7 +64,7 @@ void SortTerminalStripCommand::sort()
 
 		if (arg2.real_terminals_vector.count())
 		{
-			str2 = arg2.real_terminals_vector.constLast().label_;
+			str2 = arg2.real_terminals_vector.constLast().label();
 
 			auto match = rx.match(str2);
 			if (match.hasMatch()) {

sources/TerminalStrip/terminalstrip.cpp

@@ -55,6 +55,13 @@ class RealTerminal
 			m_parent_terminal_strip(parent_strip)
 		{}
 
+		/**
+		 * @brief parentStrip
+		 * @return parent terminal strip
+		 */
+		TerminalStrip *parentStrip() const {
+			return m_parent_terminal_strip.data();
+		}
 		/**
 		 * @brief isElement
 		 * @return true if this real terminal is linked to a terminal element
@@ -528,7 +535,7 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const
 		auto physical_terminal = m_physical_terminals.at(index);
 		ptd.pos_ = index;
 		for (auto real_terminal : physical_terminal->terminals()) {
-			auto rtd = realTerminalData(real_terminal);
+			auto rtd = RealTerminalData(real_terminal);
 			ptd.real_terminals_vector.append(rtd);
 		}
 		ptd.uuid_ = physical_terminal->uuid();
@@ -539,15 +546,15 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const
 
 /**
  * @brief TerminalStrip::physicalTerminalData
- * @param real_data
- * @return the parent PhysicalTerminalData of \p real_data.
- * the PhysicalTerminalData can be invalid if \p real_data don't belong to this strip
+ * @param real_terminal
+ * @return the parent PhysicalTerminalData of \p real_terminal.
+ * the PhysicalTerminalData can be invalid if \p real_terminal don't belong to this strip
  */
-PhysicalTerminalData TerminalStrip::physicalTerminalData(const RealTerminalData &real_data) const
+PhysicalTerminalData TerminalStrip::physicalTerminalData (QWeakPointer<RealTerminal> real_terminal) const
 {
 	PhysicalTerminalData ptd_;
 
-	const auto real_t = realTerminalForUuid(real_data.real_terminal_uuid);
+	const auto real_t = real_terminal.toStrongRef();
 	if (real_t.isNull()) {
 		return ptd_;
 	}
@@ -559,7 +566,7 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(const RealTerminalData
 
 	ptd_.pos_ = m_physical_terminals.indexOf(phy_t);
 	for (auto real_terminal : phy_t->terminals()) {
-		auto rtd = realTerminalData(real_terminal);
+		auto rtd = RealTerminalData(real_terminal);
 		ptd_.real_terminals_vector.append(rtd);
 	}
 	ptd_.uuid_ = phy_t->uuid();
@@ -634,7 +641,7 @@ bool TerminalStrip::setOrderTo(const QVector<PhysicalTerminalData> &sorted_vecto
  * @param receiver_terminal
  * @return true if success
  */
-bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<RealTerminalData> &added_terminals)
+bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals)
 {
 	const auto receiver_ = physicalTerminalForUuid(receiver_terminal.uuid_);
 	if (receiver_.isNull()) {
@@ -645,7 +652,7 @@ bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal
 	bool have_grouped = false;
 	for (const auto &added : added_terminals)
 	{
-		const auto added_terminal = realTerminalForUuid(added.real_terminal_uuid);
+		const auto added_terminal = added.toStrongRef();
 
 		if (added_terminal.isNull()) {
 			continue;
@@ -677,12 +684,12 @@ bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal
  * Ungroup all real terminals of \p terminals_to_ungroup
  * @param terminals_to_ungroup
  */
-void TerminalStrip::unGroupTerminals(const QVector<RealTerminalData> &terminals_to_ungroup)
+void TerminalStrip::unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &terminals_to_ungroup)
 {
 	bool ungrouped = false;
-	for (const auto &rtd_ : terminals_to_ungroup)
+	for (const auto &rt_ : terminals_to_ungroup)
 	{
-		if (auto real_terminal = realTerminalForUuid(rtd_.real_terminal_uuid)) //Get the shared real terminal
+		if (auto real_terminal = rt_.toStrongRef()) //Get the shared real terminal
 		{
 			if (auto physical_terminal = physicalTerminal(real_terminal)) //Get the physical terminal
 			{
@@ -710,16 +717,16 @@ void TerminalStrip::unGroupTerminals(const QVector<RealTerminalData> &terminals_
  * @param level
  * @return
  */
-bool TerminalStrip::setLevel(const RealTerminalData &real_terminal_data, int level)
+bool TerminalStrip::setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level)
 {
-	auto real_terminal = realTerminalForUuid(real_terminal_data.real_terminal_uuid);
-	if (real_terminal)
+	auto real_t = real_terminal.toStrongRef();
+	if (real_t)
 	{
-		auto physical_terminal = physicalTerminal(real_terminal);
+		auto physical_terminal = physicalTerminal(real_t);
 		if (physical_terminal)
 		{
 			if (physical_terminal->terminals().size() > 1 &&
-				physical_terminal->setLevelOf(real_terminal, level))
+				physical_terminal->setLevelOf(real_t, level))
 			{
 				emit orderChanged();
 				return true;
@@ -732,27 +739,26 @@ bool TerminalStrip::setLevel(const RealTerminalData &real_terminal_data, int lev
 
 /**
  * @brief TerminalStrip::isBridgeable
- * Check if all realTerminal represented by the uuid of @a real_terminals_uuid are bridgeable together.
+ * Check if all realTerminal in @a real_terminals_data are bridgeable together.
  * To be bridgeable, each real terminal must belong to this terminal strip
  * be at the same level, be consecutive and not belong to the same physicalTerminal
  * and at least one terminal must be not bridged
- * @param real_terminals_uuid : a vector of RealTerminal uuid
- * @sa member real_terminal_uuid of struct RealTerminalData
+ * @param real_terminals_data : a vector of RealTerminalData
  * @return
  */
-bool TerminalStrip::isBridgeable(const QVector<QUuid> &real_terminals_uuid) const
+bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals_data) const
 {
-	if (real_terminals_uuid.size() < 2) {
+	if (real_terminals_data.size() < 2) {
 		return false;
 	}
 
 		// Check if first terminal belong to this strip
-	auto first_real_terminal = realTerminalForUuid(real_terminals_uuid.first());
+	auto first_real_terminal = real_terminals_data.first().m_real_terminal.toStrongRef();
 	if (!first_real_terminal) {
 		return false;
 	}
 		// Get the level of the first terminal
-	int level_ = realTerminalData(first_real_terminal).level_;
+	int level_ = real_terminals_data.first().level();
 		// Get the physical terminal and pos
 	auto first_physical_terminal = physicalTerminal(first_real_terminal);
 	QVector<shared_physical_terminal> physical_vector{first_physical_terminal};
@@ -763,16 +769,16 @@ bool TerminalStrip::isBridgeable(const QVector<QUuid> &real_terminals_uuid) cons
 	bool no_bridged = bridge_ ? false : true;
 
 		// Check for each terminals
-	for (int i=1 ; i<real_terminals_uuid.size() ; ++i)
+	for (int i=1 ; i<real_terminals_data.size() ; ++i)
 	{
 			// If belong to this strip
-		auto real_terminal = realTerminalForUuid(real_terminals_uuid.at(i));
+		auto real_terminal = real_terminals_data.at(i).m_real_terminal.toStrongRef();
 		if (!real_terminal) {
 			return false;
 		}
 
 			// at the same level
-		if (level_ != realTerminalData(real_terminal).level_) {
+		if (level_ != real_terminals_data.at(i).level()) {
 			return false;
 		}
 
@@ -810,24 +816,36 @@ bool TerminalStrip::isBridgeable(const QVector<QUuid> &real_terminals_uuid) cons
 	return no_bridged;
 }
 
+bool TerminalStrip::isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const
+{
+	QVector<RealTerminalData> data;
+
+	for (const auto &wrt : real_terminals)
+	{
+		data.append(RealTerminalData(wrt.toStrongRef()));
+	}
+	return isBridgeable(data);
+}
+
 /**
  * @brief TerminalStrip::setBridge
- * Set a bridge betwen all real terminal represented by they uuid
- * @param real_terminals_uuid
+ * Set a bridge betwen all real terminal of @a real_terminals
  * @sa TerminalStrip::isBridgeable
  * @return true if bridge was successfully created
  */
-bool TerminalStrip::setBridge(const QVector<QUuid> &real_terminals_uuid)
+bool TerminalStrip::setBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals)
 {
-	if (!isBridgeable(real_terminals_uuid)) {
+	if (!isBridgeable(real_terminals)) {
 		return false;
 	}
 	QVector<shared_real_terminal> real_terminals_vector;
 
-	for (const auto & uuid_ : real_terminals_uuid) {
-		auto real_t = realTerminalForUuid(uuid_);
-		if (real_t)
-			real_terminals_vector << real_t;
+	for (const auto &real_terminal : real_terminals)
+	{
+		auto real_t = real_terminal.toStrongRef();
+		if (real_t) {
+			real_terminals_vector.append(real_t);
+		}
 	}
 
 	auto bridge = bridgeFor(real_terminals_vector);
@@ -848,29 +866,27 @@ bool TerminalStrip::setBridge(const QVector<QUuid> &real_terminals_uuid)
 
 /**
  * @brief TerminalStrip::setBridge
- * Bridge the RealTerminal with uuid in @a real_terminals_uuid to
- * the bridge with uuid @a bridge_uuid.
- * @param bridge_uuid
- * @param real_terminals_uuid
+ * Bridge the RealTerminal of @a real_terminals_data to @a bridge
+ * @param bridge
+ * @param real_terminals_data
  * @return true if all RealTerminal was successfully bridged
  */
-bool TerminalStrip::setBridge(const QUuid &bridge_uuid, const QVector<QUuid> &real_terminals_uuid)
+bool TerminalStrip::setBridge(QSharedPointer<TerminalStripBridge> bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals)
 {
-	auto bridge_ = bridgeForUuid(bridge_uuid);
-	if (bridge_)
+	if (bridge)
 	{
-		if (!isBridgeable(real_terminals_uuid)) {
+		if (!isBridgeable(real_terminals)) {
 			return false;
 		}
 
 		bool b_ = false;
-		for (const auto & uuid_ : real_terminals_uuid)
+		for (const auto & rt_ : real_terminals)
 		{
-			auto real_t = realTerminalForUuid(uuid_);
+			auto real_t = rt_.toStrongRef();
 			if (real_t &&
-				!bridge_->real_terminals.contains(real_t))
+				!bridge->real_terminals.contains(real_t))
 			{
-				bridge_->real_terminals.append(real_t);
+				bridge->real_terminals.append(real_t);
 				b_ = true;
 			}
 		}
@@ -886,46 +902,36 @@ bool TerminalStrip::setBridge(const QUuid &bridge_uuid, const QVector<QUuid> &re
 
 /**
  * @brief TerminalStrip::unBridge
- * Unbridge all real terminal represented by they uuid
+ * Unbridge all real terminal of @a real_terminals
  * @param real_terminals_uuid
  */
-void TerminalStrip::unBridge(const QVector<QUuid> &real_terminals_uuid)
+void TerminalStrip::unBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals)
 {
-	for (const auto & uuid_ : real_terminals_uuid)
+	for (const auto &real_t : qAsConst(real_terminals))
 	{
-		auto real_t = realTerminalForUuid(uuid_);
-		if (real_t)
-		{
-			auto bridge_ = isBridged(real_t);
-			if (bridge_)
-				bridge_->real_terminals.removeOne(real_t);
+		auto bridge_ = bridgeFor(real_t);
+		if (bridge_) {
+			bridge_->real_terminals.removeOne(real_t.toStrongRef());
 		}
 	}
 
 	emit bridgeChanged();
 }
 
-/**
- * @brief TerminalStrip::bridgeFor
- * @param real_terminal_uuid
- * @return
- */
-const QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QUuid &real_terminal_uuid) const
+QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(QWeakPointer<RealTerminal> real_terminal) const
 {
-	auto rt = realTerminalForUuid(real_terminal_uuid);
-	return bridgeFor(QVector{rt});
+	return this->isBridged(real_terminal.toStrongRef());
 }
 
 /**
  * @brief TerminalStrip::previousTerminalInLevel
- * @param real_terminal_uuid
- * @return The previous real terminal at the samne level
- * as the real terminal with uuid @a real_terminal_uuid
- * If there is not a previous terminal, return a null RealTerminalData
+ * @param real_terminal
+ * @return The previous real terminal at the samne level of @a real_t
+ * or a null RealTerminalData if there not a previous real terminal
  */
-RealTerminalData TerminalStrip::previousTerminalInLevel(const QUuid &real_terminal_uuid) const
+RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
 {
-	auto real_t = realTerminalForUuid(real_terminal_uuid);
+	auto real_t = real_terminal.toStrongRef();
 	if (real_t)
 	{
 		auto phy_t = physicalTerminal(real_t);
@@ -938,7 +944,7 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QUuid &real_termin
 				auto t_vector = m_physical_terminals.at(index-1)->terminals();
 				if (t_vector.size() > level_)
 				{
-					return realTerminalData(t_vector.at(level_));
+					return RealTerminalData(t_vector.at(level_));
 				}
 			}
 		}
@@ -949,14 +955,13 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QUuid &real_termin
 
 /**
  * @brief TerminalStrip::nextTerminalInLevel
- * @param real_terminal_uuid
- * @return The next real terminal at the samne level
- * as the real terminal with uuid @a real_terminal_uuid
- * If there is not a next terminal, return a null RealTerminalData
+ * @param real_terminal
+ * @return The next real terminal at the same level of @a real_t
+ * or a null RealTerminalData if there not a next real terminal
  */
-RealTerminalData TerminalStrip::nextTerminalInLevel(const QUuid &real_terminal_uuid) const
+RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
 {
-	auto real_t = realTerminalForUuid(real_terminal_uuid);
+	auto real_t = real_terminal.toStrongRef();
 	if (real_t)
 	{
 		auto phy_t = physicalTerminal(real_t);
@@ -969,7 +974,7 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QUuid &real_terminal_u
 				auto t_vector = m_physical_terminals.at(index+1)->terminals();
 				if (t_vector.size() > level_)
 				{
-					return realTerminalData(t_vector.at(level_));
+					return RealTerminalData(t_vector.at(level_));
 				}
 			}
 		}
@@ -978,26 +983,35 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QUuid &real_terminal_u
 	return RealTerminalData();
 }
 
-RealTerminalData TerminalStrip::previousRealTerminal(const QUuid &real_terminal_uuid) const
+RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
 {
-	auto real = realTerminalForUuid(real_terminal_uuid);
+	auto real = real_terminal.toStrongRef();
 	auto index = m_real_terminals.indexOf(real);
 	if (index) {
-		return realTerminalData(m_real_terminals.at(index-1));
+		return RealTerminalData(m_real_terminals.at(index-1));
 	}
 	return RealTerminalData();
 }
 
-RealTerminalData TerminalStrip::nextRealTerminal(const QUuid &real_terminal_uuid) const
+RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
 {
-	auto real = realTerminalForUuid(real_terminal_uuid);
+	auto real = real_terminal.toStrongRef();
 	auto index = m_real_terminals.indexOf(real);
 	if (index != m_real_terminals.size()-1) {
-		return realTerminalData(m_real_terminals.at(index+1));
+		return RealTerminalData(m_real_terminals.at(index+1));
 	}
 	return RealTerminalData();
 }
 
+RealTerminalData TerminalStrip::realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const
+{
+	auto rt = real_terminal.toStrongRef();
+	if (rt && m_real_terminals.contains(rt))
+		return RealTerminalData(rt);
+	else
+		return RealTerminalData();
+}
+
 /**
  * @brief TerminalStrip::terminalElement
  * @return A vector of all terminal element owned by this strip
@@ -1121,38 +1135,6 @@ QSharedPointer<PhysicalTerminal> TerminalStrip::physicalTerminal(QSharedPointer<
 	return pt;
 }
 
-RealTerminalData TerminalStrip::realTerminalData(const QSharedPointer<RealTerminal> real_terminal) const
-{
-	RealTerminalData rtd;
-
-	auto physical_terminal = physicalTerminal(real_terminal);
-
-	rtd.real_terminal_uuid = real_terminal->uuid();
-	rtd.level_ = physical_terminal->levelOf(real_terminal);
-	rtd.label_ = real_terminal->label();
-
-	if (real_terminal->isElement()) {
-		rtd.Xref_ = autonum::AssignVariables::genericXref(real_terminal->element());
-		rtd.element_uuid = real_terminal->elementUuid();
-		rtd.element_ = real_terminal->element();
-	}
-	rtd.type_      = real_terminal->type();
-	rtd.function_  = real_terminal->function();
-	rtd.led_       = real_terminal->led();
-	rtd.is_element = real_terminal->isElement();
-	rtd.is_bridged = isBridged(real_terminal);
-	if (rtd.is_bridged) {
-		for (auto bridge : m_bridge) {
-			if (bridge->real_terminals.contains(real_terminal)) {
-				rtd.bridge_uuid = bridge->uuid_;
-				break;
-			}
-		}
-	}
-
-	return rtd;
-}
-
 /**
  * @brief TerminalStrip::physicalTerminalForUuid
  * Return the PhysicalTerminal with uuid \p uuid or a null
@@ -1242,22 +1224,6 @@ QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QVector<QShar
 	return return_bridge;
 }
 
-/**
- * @brief TerminalStrip::bridgeForUuid
- * @param bridge_uuid
- * @return the bridge with uuid @a bridge_uuid or null QSharedPointer if not exist
- */
-QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeForUuid(const QUuid &bridge_uuid)
-{
-	for (const auto &bridge : qAsConst(m_bridge)) {
-		if (bridge->uuid_ == bridge_uuid) {
-			return bridge;
-		}
-	}
-
-	return QSharedPointer<TerminalStripBridge>();
-}
-
 /**
  * @brief TerminalStrip::rebuildRealVector
  * Rebuild the real terminal vector
@@ -1267,7 +1233,169 @@ void TerminalStrip::rebuildRealVector()
 {
 	m_real_terminals.clear();
 	for (const auto phy : m_physical_terminals) {
-		for (const auto &real : phy->terminals())
+		for (const auto real : phy->terminals())
 			m_real_terminals.append(real);
 	}
 }
+
+/************************************************************************************/
+/************************************************************************************/
+/************************************************************************************/
+/************************************************************************************/
+/************************************************************************************/
+
+
+/**
+ * @brief RealTerminalData::RealTerminalData
+ * @param real_terminal
+ */
+RealTerminalData::RealTerminalData(QSharedPointer<RealTerminal> real_terminal)
+{
+	m_real_terminal = real_terminal.toWeakRef();
+}
+
+bool RealTerminalData::isNull() const
+{
+	return m_real_terminal.isNull();
+}
+
+int RealTerminalData::level() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		auto strip = shared_->parentStrip();
+		if (strip) {
+			auto phys = strip->physicalTerminal(shared_);
+			if (phys) {
+				return phys->levelOf(shared_);
+			}
+		}
+	}
+
+	return -1;
+}
+
+QString RealTerminalData::label() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->label();
+	} else {
+		return QString();
+	}
+}
+
+QString RealTerminalData::Xref() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_ && shared_->isElement()) {
+		return autonum::AssignVariables::genericXref(shared_->element());
+	} else {
+		return QString();
+	}
+}
+
+QString RealTerminalData::cable() const {
+	return QString();
+}
+
+QString RealTerminalData::cableWire() const {
+	return QString();
+}
+
+QString RealTerminalData::conductor() const {
+	return QString();
+}
+
+ElementData::TerminalType RealTerminalData::type() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->type();
+	}
+
+	return ElementData::TerminalType::TTGeneric;
+}
+
+ElementData::TerminalFunction RealTerminalData::function() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->function();
+	}
+
+	return ElementData::TerminalFunction::TFGeneric;
+}
+
+bool RealTerminalData::isLed() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->led();
+	}
+
+	return false;
+}
+
+bool RealTerminalData::isElement() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->isElement();
+	}
+
+	return false;
+}
+
+bool RealTerminalData::isBridged() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		auto strip = shared_->parentStrip();
+		if (strip) {
+			return !strip->isBridged(shared_).isNull();
+		}
+	}
+	return false;
+}
+
+/**
+ * @brief RealTerminalData::element
+ * @return The element represented by this real
+ * terminal, or nullptr
+ */
+Element *RealTerminalData::element() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		return shared_->element();
+	}
+
+	return nullptr;
+}
+
+QUuid RealTerminalData::elementUuid() const
+{
+	auto element_ = element();
+	if (element_) {
+		return element_->uuid();
+	}
+	return QUuid();
+}
+
+QSharedPointer<TerminalStripBridge> RealTerminalData::bridge() const
+{
+	auto shared_ = m_real_terminal.toStrongRef();
+	if (shared_) {
+		auto strip = shared_->parentStrip();
+		if (strip) {
+			return strip->isBridged(shared_);
+		}
+	}
+	return QSharedPointer<TerminalStripBridge>();
+}
+
+QWeakPointer<RealTerminal> RealTerminalData::realTerminal() const
+{
+	return m_real_terminal;
+}

sources/TerminalStrip/terminalstrip.h

@@ -32,36 +32,59 @@ class PhysicalTerminal;
 class TerminalStripIndex;
 class TerminalElement;
 
-
-/**
- * @brief The RealTerminalData struct
- * Conveniant struct to quickly get some values
- * of a RealTerminal
- * A RealTerminalData with level_ = -1
- * is considered as a null data
- */
-struct RealTerminalData
+struct TerminalStripBridge
 {
-	int level_ = -1;
+		QVector<QSharedPointer<RealTerminal>> real_terminals;
+		QColor color_ = Qt::darkGray;
+		QUuid uuid_ = QUuid::createUuid();
+};
 
-	QString label_,
-			Xref_,
-			cable_,
-			cable_wire_,
-			conductor_;
+inline bool operator == (const TerminalStripBridge &bridge_1, const TerminalStripBridge &bridge_2) {
+	return (bridge_1.uuid_ == bridge_2.uuid_);
+}
 
-	QUuid element_uuid,
-		  real_terminal_uuid,
-		  bridge_uuid;
+inline uint qHash(const QWeakPointer<TerminalStripBridge> &key, uint seed)
+{
+	const auto bridge = key.toStrongRef();
+	if (bridge) {
+		return qHash(bridge->uuid_, seed);
+	} else {
+		return qHash(QUuid (), seed);
+	}
+}
 
-	ElementData::TerminalType type_;
-	ElementData::TerminalFunction function_;
+class RealTerminalData
+{
+		friend class TerminalStrip;
+	private:
+		RealTerminalData(QSharedPointer<RealTerminal> real_terminal);
 
-	bool led_ = false,
-		 is_element = false,
-		 is_bridged = false;
+	public:
+		RealTerminalData() {}
 
-	QPointer<Element> element_;
+		bool isNull() const;
+		int level() const;
+		QString label() const;
+		QString Xref() const;
+		QString cable() const;
+		QString cableWire() const;
+		QString conductor() const;
+
+		ElementData::TerminalType type() const;
+		ElementData::TerminalFunction function() const;
+
+		bool isLed() const;
+		bool isElement() const;
+		bool isBridged() const;
+
+		Element* element() const;
+		QUuid elementUuid() const;
+
+		QSharedPointer<TerminalStripBridge> bridge() const;
+		QWeakPointer<RealTerminal> realTerminal() const;
+
+	private:
+		QWeakPointer<RealTerminal> m_real_terminal;
 };
 
 /**
@@ -85,13 +108,6 @@ inline uint qHash(const PhysicalTerminalData &key, uint seed) {
 	return qHash(key.uuid_, seed);
 }
 
-struct TerminalStripBridge
-{
-		QVector<QSharedPointer<RealTerminal>> real_terminals;
-		QColor color_ = Qt::darkGray;
-		QUuid uuid_ = QUuid::createUuid();
-};
-
 /**
  * @brief The TerminalStrip class
  * This class hold all the datas and configurations
@@ -102,6 +118,7 @@ struct TerminalStripBridge
 class TerminalStrip : public QObject
 {
 	friend class TerminalStripModel;
+	friend class RealTerminalData;
 
 	Q_OBJECT
 
@@ -140,22 +157,25 @@ class TerminalStrip : public QObject
 
 		int physicalTerminalCount() const;
 		PhysicalTerminalData physicalTerminalData(int index) const;
-		PhysicalTerminalData physicalTerminalData (const RealTerminalData &real_data) const;
+		PhysicalTerminalData physicalTerminalData (QWeakPointer<RealTerminal> real_terminal) const;
 		QVector<PhysicalTerminalData> physicalTerminalData() const;
 		bool setOrderTo(const QVector<PhysicalTerminalData> &sorted_vector);
-		bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<RealTerminalData> &added_terminals);
-		void unGroupTerminals(const QVector<RealTerminalData> &terminals_to_ungroup);
-		bool setLevel(const RealTerminalData &real_terminal_data, int level);
-		bool isBridgeable(const QVector<QUuid> &real_terminals_uuid) const;
-		bool setBridge(const QVector<QUuid> &real_terminals_uuid);
-		bool setBridge(const QUuid &bridge_uuid, const QVector<QUuid> &real_terminals_uuid);
-		void unBridge(const QVector<QUuid> &real_terminals_uuid);
-		const QSharedPointer<TerminalStripBridge> bridgeFor(const QUuid &real_terminal_uuid) const;
+		bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals);
+		void unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &terminals_to_ungroup);
+		bool setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level);
 
-		RealTerminalData previousTerminalInLevel(const QUuid &real_terminal_uuid) const;
-		RealTerminalData nextTerminalInLevel(const QUuid &real_terminal_uuid) const;
-		RealTerminalData previousRealTerminal(const QUuid &real_terminal_uuid) const;
-		RealTerminalData nextRealTerminal(const QUuid &real_terminal_uuid) const;
+		bool isBridgeable(const QVector<RealTerminalData> &real_terminals_data) const;
+		bool isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const;
+		bool setBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
+		bool setBridge(QSharedPointer<TerminalStripBridge> bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals);
+		void unBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
+		QSharedPointer<TerminalStripBridge> bridgeFor(QWeakPointer<RealTerminal> real_terminal) const;
+
+		RealTerminalData previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
+		RealTerminalData nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
+		RealTerminalData previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
+		RealTerminalData nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
+		RealTerminalData realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const;
 
 		QVector<QPointer<Element>> terminalElement() const;
 
@@ -166,12 +186,10 @@ class TerminalStrip : public QObject
 	private:
 		QSharedPointer<RealTerminal> realTerminal(Element *terminal);
 		QSharedPointer<PhysicalTerminal> physicalTerminal(QSharedPointer<RealTerminal> terminal) const;
-		RealTerminalData realTerminalData(const QSharedPointer<RealTerminal> real_terminal) const;
 		QSharedPointer<PhysicalTerminal> physicalTerminalForUuid (const QUuid &uuid) const;
 		QSharedPointer<RealTerminal> realTerminalForUuid(const QUuid &uuid) const;
 		QSharedPointer<TerminalStripBridge> isBridged(const QSharedPointer<RealTerminal> real_terminal) const;
 		QSharedPointer<TerminalStripBridge> bridgeFor (const QVector<QSharedPointer<RealTerminal>> &terminal_vector) const;
-		QSharedPointer<TerminalStripBridge> bridgeForUuid (const QUuid &bridge_uuid);
 		void rebuildRealVector();
 
 	private:

sources/TerminalStrip/ui/terminalstripeditor.cpp

@@ -72,10 +72,10 @@ TerminalStripEditor::TerminalStripEditor(QETProject *project, QWidget *parent) :
 	{
 		if (m_model->columnTypeForIndex(index) == TerminalStripModel::XRef)
 		{
-			auto rtd = m_model->realTerminalDataForIndex(index);
-			if (rtd.element_)
+			auto mrtd = m_model->modelRealTerminalDataForIndex(index);
+			if (mrtd.element_)
 			{
-				auto elmt = rtd.element_;
+				auto elmt = mrtd.element_;
 				auto diagram = elmt->diagram();
 				if (diagram)
 				{
@@ -235,12 +235,12 @@ QTreeWidgetItem* TerminalStripEditor::addTerminalStrip(TerminalStrip *terminal_s
 		if (ptd.real_terminals_vector.size())
 		{
 			auto real_t = ptd.real_terminals_vector.first();
-			auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t.label_), TerminalStripTreeWidget::Terminal);
-			terminal_item->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t.element_uuid.toString());
+			auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t.label()), TerminalStripTreeWidget::Terminal);
+			terminal_item->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t.elementUuid());
 			terminal_item->setIcon(0, QET::Icons::ElementTerminal);
 
-			if (real_t.element_) {
-				m_uuid_terminal_H.insert(real_t.element_uuid, qgraphicsitem_cast<TerminalElement *>(real_t.element_));
+			if (real_t.element()) {
+				m_uuid_terminal_H.insert(real_t.elementUuid(), qgraphicsitem_cast<TerminalElement *>(real_t.element()));
 			}
 		}
 	}
@@ -395,28 +395,28 @@ void TerminalStripEditor::selectionChanged()
 		ui->m_led_cb      ->setEnabled(true);
 	}
 
-	const auto physical_terminal_vector = m_model->physicalTerminalDataForIndex(index_list);
-	const auto real_terminal_vector = m_model->realTerminalDataForIndex(index_list);
+	const auto model_physical_terminal_vector = m_model->modelPhysicalTerminalDataForIndex(index_list);
+	const auto model_real_terminal_vector = m_model->modelRealTerminalDataForIndex(index_list);
 
 		//Enable/disable group button
-	ui->m_group_terminals_pb->setEnabled(physical_terminal_vector.size() > 1 ? true : false);
+	ui->m_group_terminals_pb->setEnabled(model_physical_terminal_vector.size() > 1 ? true : false);
 
 		//Enable/disable ungroup button
-	auto it_= std::find_if(physical_terminal_vector.constBegin(), physical_terminal_vector.constEnd(), [](const PhysicalTerminalData &data)
+	auto it_= std::find_if(model_physical_terminal_vector.constBegin(), model_physical_terminal_vector.constEnd(), [](const modelPhysicalTerminalData &data)
 	{
-		if (data.real_terminals_vector.size() >= 2) {
+		if (data.real_data.size() >= 2) {
 			return true;
 		} else {
 			return false;
 		}
 	});
-	ui->m_ungroup_pb->setDisabled(it_ == physical_terminal_vector.constEnd());
+	ui->m_ungroup_pb->setDisabled(it_ == model_physical_terminal_vector.constEnd());
 
 		//Enable/disable level spinbox
 	bool enable_ = false;
-	for (const auto &physical : physical_terminal_vector)
+	for (const auto &physical : model_physical_terminal_vector)
 	{
-		if (physical.real_terminals_vector.size() > 1) {
+		if (physical.real_data.size() > 1) {
 			enable_ = true;
 			break;
 		}
@@ -432,25 +432,30 @@ void TerminalStripEditor::selectionChanged()
 	if (level_ >= 0)
 	{
 			//Select only terminals of corresponding level cell selection
-		QVector<RealTerminalData> real_terminal_level_vector;
-		for (const auto &rtd : real_terminal_vector) {
-			if (rtd.level_ == level_) {
-				real_terminal_level_vector.append(rtd);
+		QVector<modelRealTerminalData> model_real_terminal_level_vector;
+		for (const auto &mrtd : model_real_terminal_vector) {
+			if (mrtd.level_ == level_) {
+				model_real_terminal_level_vector.append(mrtd);
 			}
 		}
 
-		QVector<QUuid> uuid_v;
-		for (const auto &rtd : real_terminal_level_vector) {
-			uuid_v << rtd.real_terminal_uuid;
+		QVector<modelRealTerminalData> model_rtd_vector;
+		for (const auto &mrtd : model_real_terminal_level_vector) {
+			model_rtd_vector << mrtd;
 		}
-		if (m_current_strip) {
-			enable_bridge = m_current_strip->isBridgeable(uuid_v);
+		if (m_current_strip)
+		{
+			QVector<QWeakPointer<RealTerminal>> vector_;
+			for (const auto &mrtd : model_rtd_vector) {
+				vector_.append(mrtd.real_terminal);
+			}
+			enable_bridge = m_current_strip->isBridgeable(vector_);
 		}
 
-		for (const auto &rtd : real_terminal_level_vector)
+		for (const auto &mrtd : model_real_terminal_level_vector)
 		{
-			if (rtd.is_bridged &&
-				rtd.level_ == level_) {
+			if (mrtd.bridged_ &&
+				mrtd.level_ == level_) {
 				enable_unbridge = true;
 				break;
 			}
@@ -643,22 +648,21 @@ void TerminalStripEditor::on_m_dialog_button_box_clicked(QAbstractButton *button
 
 			if (m_model)
 			{
-				for (const auto &data_ : m_model->modifiedRealTerminalData())
+				for (const auto &data_ : m_model->modifiedmodelRealTerminalData())
 				{
-					auto original_ = data_.first;
-					auto edited_   = data_.second;
-					auto element   = original_.element_;
-					if (element) {
+					auto element   = data_.element_;
+					if (element)
+					{
 						auto current_data = element->elementData();
-						current_data.setTerminalType(edited_.type_);
-						current_data.setTerminalFunction(edited_.function_);
-						current_data.setTerminalLED(edited_.led_);
-						current_data.m_informations.addValue(QStringLiteral("label"), edited_.label_);
+						current_data.setTerminalType(data_.type_);
+						current_data.setTerminalFunction(data_.function_);
+						current_data.setTerminalLED(data_.led_);
+						current_data.m_informations.addValue(QStringLiteral("label"), data_.label_);
 
 						if (element->elementData() != current_data)
 							m_project->undoStack()->push(new ChangeElementDataCommand(element, current_data));
-						if (edited_.level_)
-							m_project->undoStack()->push(new ChangeTerminalLevel(m_current_strip, original_, edited_.level_));
+						if (data_.level_ != m_current_strip->realTerminalDataFor(data_.real_terminal).level())
+							m_project->undoStack()->push(new ChangeTerminalLevel(m_current_strip, data_.real_terminal, data_.level_));
 					}
 				}
 			}
@@ -687,11 +691,16 @@ void TerminalStripEditor::on_m_group_terminals_pb_clicked()
 {
 	if (m_model && m_current_strip && m_project)
 	{
-		auto rtd_vector = m_model->realTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes());
-		if (rtd_vector.size() >= 2)
+		auto mrtd_vector = m_model->modelRealTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes());
+		if (mrtd_vector.size() >= 2)
 		{
-			auto receiver_ = m_current_strip->physicalTerminalData(rtd_vector.takeFirst());
-			m_project->undoStack()->push(new GroupTerminalsCommand(m_current_strip, receiver_, rtd_vector));
+			auto receiver_ = m_current_strip->physicalTerminalData(mrtd_vector.takeFirst().real_terminal);
+
+			QVector<QWeakPointer<RealTerminal>> vector_;
+			for (const auto & mrtd : mrtd_vector) {
+				vector_.append(mrtd.real_terminal);
+			}
+			m_project->undoStack()->push(new GroupTerminalsCommand(m_current_strip, receiver_, vector_));
 		}
 	}
 }
@@ -703,8 +712,13 @@ void TerminalStripEditor::on_m_ungroup_pb_clicked()
 {
 	if (m_model && m_current_strip)
 	{
-		const auto rtd_vector = m_model->realTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes());
-		m_project->undoStack()->push(new UnGroupTerminalsCommand(m_current_strip, rtd_vector));
+		const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes());
+
+		QVector<QWeakPointer<RealTerminal>> vector_;
+		for (const auto &mrtd : mrtd_vector) {
+			vector_.append(mrtd.real_terminal);
+		}
+		m_project->undoStack()->push(new UnGroupTerminalsCommand(m_current_strip, vector_));
 	}
 }
 
@@ -826,16 +840,18 @@ void TerminalStripEditor::on_m_bridge_terminals_pb_clicked()
 			else if(level_ == TerminalStripModel::Level3){level_ = 3;}
 
 			const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes();
-			const auto rtd_vector = m_model->realTerminalDataForIndex(index_list);
-			QVector <QUuid> uuid_vector;
-			for (const auto &rtd : rtd_vector)
+			const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list);
+
+			QVector <QWeakPointer<RealTerminal>> match_vector;
+			for (const auto &mrtd : mrtd_vector)
 			{
-				if (rtd.level_ == level_) {
-					uuid_vector.append(rtd.real_terminal_uuid);
+				if (mrtd.level_ == level_) {
+					match_vector.append(mrtd.real_terminal);
 				}
 			}
-			if (m_current_strip->isBridgeable(uuid_vector)) {
-				m_project->undoStack()->push(new BridgeTerminalsCommand(m_current_strip, uuid_vector));
+
+			if (m_current_strip->isBridgeable(match_vector)) {
+				m_project->undoStack()->push(new BridgeTerminalsCommand(m_current_strip, match_vector));
 			}
 		}
 	}
@@ -858,16 +874,16 @@ void TerminalStripEditor::on_m_unbridge_terminals_pb_clicked()
 			else if(level_ == TerminalStripModel::Level3){level_ = 3;}
 
 			const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes();
-			const auto rtd_vector = m_model->realTerminalDataForIndex(index_list);
-			QVector <QUuid> uuid_vector;
-			for (const auto &rtd : rtd_vector)
+			const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list);
+			QVector<QWeakPointer<RealTerminal>> match_vector;
+			for (const auto &mrtd : mrtd_vector)
 			{
-				if (rtd.level_ == level_
-					&& rtd.is_bridged) {
-					uuid_vector.append(rtd.real_terminal_uuid);
+				if (mrtd.level_ == level_
+					&& mrtd.bridged_) {
+					match_vector.append(mrtd.real_terminal);
 				}
 			}
-			m_project->undoStack()->push(new UnBridgeTerminalsCommand(m_current_strip, uuid_vector));
+			m_project->undoStack()->push(new UnBridgeTerminalsCommand(m_current_strip, match_vector));
 		}
 	}
 }

sources/TerminalStrip/ui/terminalstripmodel.cpp

@@ -117,8 +117,8 @@ int TerminalStripModel::rowCount(const QModelIndex &parent) const
     }
 
 	auto count = 0;
-	for (const auto &ptd : m_edited_terminal_data) {
-		count += ptd.real_terminals_vector.size();
+	for (const auto &mptd : m_physical_data) {
+		count += mptd.real_data.size();
 	}
 
 	return count;
@@ -136,28 +136,28 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const
 		return QVariant();
 	}
 
-	const auto rtd = dataAtRow(index.row());
+	const auto mrtd = dataAtRow(index.row());
 
 
 	if (role == Qt::DisplayRole)
 	{
 		switch (index.column()) {
 			case POS_CELL :        return physicalDataAtIndex(index.row()).pos_;
-			case LEVEL_CELL :      return rtd.level_;
-			case LABEL_CELL :      return rtd.label_;
-			case XREF_CELL :       return rtd.Xref_;
-			case CABLE_CELL :      return rtd.cable_;
-			case CABLE_WIRE_CELL : return rtd.cable_wire_;
-			case TYPE_CELL :       return ElementData::translatedTerminalType(rtd.type_);
-			case FUNCTION_CELL :   return ElementData::translatedTerminalFunction(rtd.function_);
-			case CONDUCTOR_CELL :  return rtd.conductor_;
+			case LEVEL_CELL :      return mrtd.level_;
+			case LABEL_CELL :      return mrtd.label_;
+			case XREF_CELL :       return mrtd.Xref_;
+			case CABLE_CELL :      return mrtd.cable_;
+			case CABLE_WIRE_CELL : return mrtd.cable_wire;
+			case TYPE_CELL :       return ElementData::translatedTerminalType(mrtd.type_);
+			case FUNCTION_CELL :   return ElementData::translatedTerminalFunction(mrtd.function_);
+			case CONDUCTOR_CELL :  return mrtd.conductor_;
 			default :              return QVariant();
 		}
 	}
 	else if (role == Qt::EditRole)
 	{
 		switch (index.column()) {
-			case LABEL_CELL : return rtd.label_;
+			case LABEL_CELL : return mrtd.label_;
 			default: return QVariant();
 
 		}
@@ -165,12 +165,12 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const
 	else if (role == Qt::CheckStateRole &&
 			   index.column() == LED_CELL)
 	{
-		return rtd.led_ ? Qt::Checked : Qt::Unchecked;
+		return mrtd.led_ ? Qt::Checked : Qt::Unchecked;
 	}
 	else if (role == Qt::BackgroundRole && index.column() <= CONDUCTOR_CELL )
 	{
-		if (m_modified_cell.contains(rtd.element_) &&
-			m_modified_cell.value(rtd.element_).at(index.column()))
+		if (m_modified_cell.contains(mrtd.element_) &&
+			m_modified_cell.value(mrtd.element_).at(index.column()))
 		{
 			return QBrush(Qt::yellow);
 		}
@@ -193,7 +193,7 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const
 
 bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
-	auto rtd = dataAtRow(index.row());
+	auto mrtd = dataAtRow(index.row());
 	bool modified_ = false;
 	int modified_cell = -1;
 	auto column_ = index.column();
@@ -201,35 +201,35 @@ bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value
 	if (column_ == LEVEL_CELL &&
 		role == Qt::EditRole)
 	{
-		rtd.level_ = value.toInt();
+		mrtd.level_ = value.toInt();
 		modified_ = true;
 		modified_cell = LEVEL_CELL;
 	}
 	else if (column_ == LED_CELL)
 	{
-			rtd.led_ = value.toBool();
+			mrtd.led_ = value.toBool();
 			modified_ = true;
 			modified_cell = LED_CELL;
 	}
 	else if (column_ == TYPE_CELL &&
 			 role == Qt::EditRole)
 	{
-		rtd.type_ = value.value<ElementData::TerminalType>();
+		mrtd.type_ = value.value<ElementData::TerminalType>();
 		modified_ = true;
 		modified_cell = TYPE_CELL;
 	}
 	else if (column_ == FUNCTION_CELL &&
 			 role == Qt::EditRole)
 	{
-		rtd.function_ = value.value<ElementData::TerminalFunction>();
+		mrtd.function_ = value.value<ElementData::TerminalFunction>();
 		modified_ = true;
 		modified_cell = FUNCTION_CELL;
 	}
 	else if (column_ == LABEL_CELL &&
 			 role == Qt::EditRole &&
-			 rtd.label_ != value.toString())
+			 mrtd.label_ != value.toString())
 	{
-		rtd.label_ = value.toString();
+		mrtd.label_ = value.toString();
 		modified_ = true;
 		modified_cell = LABEL_CELL;
 	}
@@ -237,19 +237,19 @@ bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value
 		//Set the modification to the terminal data
 	if (modified_)
 	{
-		replaceDataAtRow(rtd, index.row());
+		replaceDataAtRow(mrtd, index.row());
 
-		if (rtd.element_)
+		if (mrtd.element_)
 		{
 			QVector<bool> vector_;
-			if (m_modified_cell.contains(rtd.element_)) {
-				vector_ = m_modified_cell.value(rtd.element_);
+			if (m_modified_cell.contains(mrtd.element_)) {
+				vector_ = m_modified_cell.value(mrtd.element_);
 			} else {
 				vector_ = UNMODIFIED_CELL_VECTOR;
 			}
 
 			vector_.replace(modified_cell, true);
-			m_modified_cell.insert(rtd.element_, vector_);
+			m_modified_cell.insert(mrtd.element_, vector_);
 		}
 		emit dataChanged(index, index);
 		return true;
@@ -305,22 +305,21 @@ Qt::ItemFlags TerminalStripModel::flags(const QModelIndex &index) const
  * @return a vector of QPair of modified terminal.
  * the first value of the QPair is the original data, the second value is the edited data
  */
-QVector<QPair<RealTerminalData, RealTerminalData>> TerminalStripModel::modifiedRealTerminalData() const
+QVector<modelRealTerminalData> TerminalStripModel::modifiedmodelRealTerminalData() const
 {
-	QVector<QPair<RealTerminalData, RealTerminalData>> returned_vector;
+	QVector<modelRealTerminalData> returned_vector;
 
 	const auto modified_real_terminal = m_modified_cell.keys();
 
-	for (auto i = 0 ; i<m_edited_terminal_data.size() ; ++i)
+	for (auto i = 0 ; i<m_physical_data.size() ; ++i)
 	{
-		auto ptd_ = m_edited_terminal_data.at(i);
-		for (auto j = 0 ; j < ptd_.real_terminals_vector.size() ; ++j)
+		auto ptd_ = m_physical_data.at(i);
+		for (auto j = 0 ; j < ptd_.real_data.size() ; ++j)
 		{
-			auto rtd_ = ptd_.real_terminals_vector.at(j);
-			if (modified_real_terminal.contains(rtd_.element_))
+			auto mrtd_ = ptd_.real_data.at(j);
+			if (modified_real_terminal.contains(mrtd_.element_))
 			{
-				returned_vector.append(qMakePair(m_original_terminal_data.at(i).real_terminals_vector.at(j),
-												 m_edited_terminal_data.at(i).real_terminals_vector.at(j)));
+				returned_vector.append(m_physical_data.at(i).real_data.at(j));
 			}
 		}
 	}
@@ -334,9 +333,9 @@ QVector<QPair<RealTerminalData, RealTerminalData>> TerminalStripModel::modifiedR
  * @return A vector of PhysicalTerminalData represented by index_list.
  * If sereval index point to the same terminal the vector have only one PhysicalTerminalData
  */
-QVector<PhysicalTerminalData> TerminalStripModel::physicalTerminalDataForIndex(QModelIndexList index_list) const
+QVector<modelPhysicalTerminalData> TerminalStripModel::modelPhysicalTerminalDataForIndex(QModelIndexList index_list) const
 {
-	QVector<PhysicalTerminalData> vector_;
+	QVector<modelPhysicalTerminalData> vector_;
 	if (index_list.isEmpty()) {
 		return vector_;
 	}
@@ -350,7 +349,8 @@ QVector<PhysicalTerminalData> TerminalStripModel::physicalTerminalDataForIndex(Q
 		}
 	}
 
-	for (auto i : set_) {
+	for (const auto i : set_)
+	{
 		const auto phy = physicalDataAtIndex(i);
 		if (!vector_.contains(phy)) {
 			vector_.append(phy);
@@ -365,9 +365,9 @@ QVector<PhysicalTerminalData> TerminalStripModel::physicalTerminalDataForIndex(Q
  * @param index_list
  * @return
  */
-QVector<RealTerminalData> TerminalStripModel::realTerminalDataForIndex(QModelIndexList index_list) const
+QVector<modelRealTerminalData> TerminalStripModel::modelRealTerminalDataForIndex(QModelIndexList index_list) const
 {
-	QVector<RealTerminalData> vector_;
+	QVector<modelRealTerminalData> vector_;
 	if (index_list.isEmpty()) {
 		return vector_;
 	}
@@ -393,14 +393,14 @@ QVector<RealTerminalData> TerminalStripModel::realTerminalDataForIndex(QModelInd
 /**
  * @brief TerminalStripModel::realTerminalDataForIndex
  * @param index
- * @return RealTerminalData at index @a index or null RealTerminalData if invalid
+ * @return modelRealTerminalData at index @a index or null modelRealTerminalData if invalid
  */
-RealTerminalData TerminalStripModel::realTerminalDataForIndex(const QModelIndex &index) const
+modelRealTerminalData TerminalStripModel::modelRealTerminalDataForIndex(const QModelIndex &index) const
 {
 	if (index.isValid()) {
 		return realDataAtIndex(index.row());
 	} else {
-		return RealTerminalData();
+		return modelRealTerminalData();
 	}
 }
 
@@ -479,25 +479,38 @@ void TerminalStripModel::buildBridgePixmap(const QSize &pixmap_size)
 void TerminalStripModel::fillPhysicalTerminalData()
 {
 		//Get all physical terminal
-	if (m_terminal_strip) {
-		for (auto i=0 ; i < m_terminal_strip->physicalTerminalCount() ; ++i) {
-			m_original_terminal_data.append(m_terminal_strip->physicalTerminalData(i));
+	if (m_terminal_strip)
+	{
+		for (const auto &ptd : m_terminal_strip->physicalTerminalData())
+		{
+			modelPhysicalTerminalData mptd;
+			mptd.pos_ = ptd.pos_;
+			mptd.uuid_ = ptd.uuid_;
+
+			for (const auto &rtd : ptd.real_terminals_vector)
+			{
+				if (!rtd.isNull())
+				{
+					mptd.real_data.append(modelRealData(rtd));
+				}
+			}
+
+			m_physical_data.append(mptd);
 		}
-		m_edited_terminal_data = m_original_terminal_data;
 	}
 }
 
-RealTerminalData TerminalStripModel::dataAtRow(int row) const
+modelRealTerminalData TerminalStripModel::dataAtRow(int row) const
 {
 	if (row > rowCount(QModelIndex())) {
-		return RealTerminalData();
+		return modelRealTerminalData();
 	}
 	else
 	{
 		auto current_row = 0;
-		for (const auto &physical_data : m_edited_terminal_data)
+		for (const auto &physical_data : qAsConst(m_physical_data))
 		{
-			for (const auto &real_data : physical_data.real_terminals_vector)
+			for (const auto &real_data : physical_data.real_data)
 			{
 				if (current_row == row) {
 					return real_data;
@@ -508,7 +521,7 @@ RealTerminalData TerminalStripModel::dataAtRow(int row) const
 		}
 	}
 
-	return RealTerminalData();
+	return modelRealTerminalData();
 }
 
 /**
@@ -517,7 +530,7 @@ RealTerminalData TerminalStripModel::dataAtRow(int row) const
  * @param data
  * @param row
  */
-void TerminalStripModel::replaceDataAtRow(RealTerminalData data, int row)
+void TerminalStripModel::replaceDataAtRow(modelRealTerminalData data, int row)
 {
 	if (row > rowCount(QModelIndex())) {
 		return;
@@ -527,15 +540,15 @@ void TerminalStripModel::replaceDataAtRow(RealTerminalData data, int row)
 		auto current_row = 0;
 		auto current_physical = 0;
 
-		for (const auto &physical_data : qAsConst(m_edited_terminal_data))
+		for (const auto &physical_data : qAsConst(m_physical_data))
 		{
 			auto current_real = 0;
-			for (int i=0 ; i<physical_data.real_terminals_vector.count() ; ++i)
+			for (int i=0 ; i<physical_data.real_data.count() ; ++i)
 			{
 				if (current_row == row) {
-					auto physical_data = m_edited_terminal_data.at(current_physical);
-					physical_data.real_terminals_vector.replace(current_real, data);
-					m_edited_terminal_data.replace(current_physical, physical_data);
+					auto physical_data = m_physical_data.at(current_physical);
+					physical_data.real_data.replace(current_real, data);
+					m_physical_data.replace(current_physical, physical_data);
 					return;
 				} else {
 					++current_real;
@@ -556,19 +569,19 @@ void TerminalStripModel::replaceDataAtRow(RealTerminalData data, int row)
  * have is own row.
  * If \p index is out of range, return a default PhysicalTerminalData (pos_ is set to -1 by default)
  */
-PhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const
+modelPhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const
 {
-	if (m_edited_terminal_data.isEmpty()) {
-		return PhysicalTerminalData();
+	if (m_physical_data.isEmpty()) {
+		return modelPhysicalTerminalData();
 	}
 
 	int current_checked_index = -1;
 	int current_phy = -1;
 	bool match_ = false;
 
-	for (const auto &ptd_ : qAsConst(m_edited_terminal_data))
+	for (const auto &ptd_ : qAsConst(m_physical_data))
 	{
-		current_checked_index += ptd_.real_terminals_vector.size();
+		current_checked_index += ptd_.real_data.size();
 		++current_phy;
 
 		if (current_checked_index >= index) {
@@ -578,9 +591,9 @@ PhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const
 	}
 
 	if (match_) {
-		return  m_edited_terminal_data.at(current_phy);
+		return  m_physical_data.at(current_phy);
 	} else {
-		return PhysicalTerminalData();
+		return modelPhysicalTerminalData();
 	}
 }
 
@@ -589,17 +602,17 @@ PhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const
  * @param index
  * @return the realTerminalData at index \p index.
  */
-RealTerminalData TerminalStripModel::realDataAtIndex(int index) const
+modelRealTerminalData TerminalStripModel::realDataAtIndex(int index) const
 {
-	if (m_edited_terminal_data.isEmpty()) {
-		return RealTerminalData();
+	if (m_physical_data.isEmpty()) {
+		return modelRealTerminalData();
 	}
 
 	int current_checked_index = -1;
 
-	for (const auto & ptd_ : qAsConst(m_edited_terminal_data))
+	for (const auto & ptd_ : qAsConst(m_physical_data))
 	{
-		for (const auto & rtd_ : qAsConst(ptd_.real_terminals_vector)) {
+		for (const auto & rtd_ : qAsConst(ptd_.real_data)) {
 			++current_checked_index;
 			if (current_checked_index == index) {
 				return rtd_;
@@ -607,7 +620,7 @@ RealTerminalData TerminalStripModel::realDataAtIndex(int index) const
 		}
 	}
 
-	return RealTerminalData();
+	return modelRealTerminalData();
 }
 
 QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
@@ -621,28 +634,31 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		return QPixmap();
 	}
 
-	auto rtd = realTerminalDataForIndex(index);
+	auto mrtd = modelRealTerminalDataForIndex(index);
 
 		//Terminal level correspond to the column level of index
-	if (level_column == rtd.level_)
+	if (level_column == mrtd.level_)
 	{
-		if (rtd.is_bridged)
+		if (mrtd.bridged_)
 		{
-			auto bridge_uuid = rtd.bridge_uuid;
-			auto previous_bridge_uuid = m_terminal_strip->previousTerminalInLevel(rtd.real_terminal_uuid).bridge_uuid;
-			auto next_bridge_uuid = m_terminal_strip->nextTerminalInLevel(rtd.real_terminal_uuid).bridge_uuid;
+			auto bridge_ = m_terminal_strip->bridgeFor(mrtd.real_terminal);
+			if (bridge_)
+			{
+				auto previous_bridge = m_terminal_strip->previousTerminalInLevel(mrtd.real_terminal).bridge();
+				auto next_bridge = m_terminal_strip->nextTerminalInLevel(mrtd.real_terminal).bridge();
 
-			auto color_ = m_terminal_strip->bridgeFor(rtd.real_terminal_uuid)->color_;
-			auto pixmap_ = m_bridges_pixmaps.value(color_);
+				auto color_ = bridge_->color_;
+				auto pixmap_ = m_bridges_pixmaps.value(color_);
 
 				//Current real terminal between two bridged terminal
-			if ((bridge_uuid == previous_bridge_uuid) &&
-				(bridge_uuid == next_bridge_uuid)) {
-				return pixmap_.middle_;
-			} else if (bridge_uuid == previous_bridge_uuid) {
-				return pixmap_.bottom_;
-			} else if (bridge_uuid == next_bridge_uuid) {
-				return pixmap_.top_;
+				if ((bridge_ == previous_bridge) &&
+					(bridge_ == next_bridge)) {
+					return pixmap_.middle_;
+				} else if (bridge_ == previous_bridge) {
+					return pixmap_.bottom_;
+				} else if (bridge_ == next_bridge) {
+					return pixmap_.top_;
+				}
 			}
 		}
 	}
@@ -650,26 +666,25 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		//Check if we need to draw a none bridge pixmap
 
 		//Check previous
-	auto physical_data = m_terminal_strip->physicalTerminalData(rtd);
-	auto current_real_uuid = rtd.real_terminal_uuid;
+	auto physical_data = m_terminal_strip->physicalTerminalData(mrtd.real_terminal);
+	auto current_real_terminal = mrtd;
 	auto current_phy_uuid = physical_data.uuid_;
 	bool already_jumped_to_previous = false;
-	RealTerminalData previous_data;
+	modelRealTerminalData previous_data;
 
 	do {
-		auto previous_rtd = m_terminal_strip->previousRealTerminal(current_real_uuid);
-		current_real_uuid = previous_rtd.real_terminal_uuid;
+		current_real_terminal = modelRealData(m_terminal_strip->previousRealTerminal(current_real_terminal.real_terminal));
 
-		if (previous_rtd.level_ == -1) {
+		if (current_real_terminal.level_ == -1) {
 			break;
 		}
 
 			//We are in the same physical terminal as previous loop
-		if (current_phy_uuid == m_terminal_strip->physicalTerminalData(previous_rtd).uuid_)
+		if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_)
 		{
-			if (previous_rtd.is_bridged &&
-				previous_rtd.level_ == level_column) {
-				previous_data = previous_rtd;
+			if (current_real_terminal.bridged_ &&
+				current_real_terminal.level_ == level_column) {
+				previous_data = current_real_terminal;
 				break;
 			}
 		}
@@ -677,34 +692,34 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 			break;
 		} else {
 			already_jumped_to_previous = true;
-			current_phy_uuid = m_terminal_strip->physicalTerminalData(previous_rtd).uuid_;
-			if (previous_rtd.is_bridged &&
-				previous_rtd.level_ == level_column) {
-				previous_data = previous_rtd;
+			current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_;
+			if (current_real_terminal.bridged_ &&
+				current_real_terminal.level_ == level_column) {
+				previous_data = current_real_terminal;
 				break;
 			}
 		}
 	} while(true);
 
 		//Check next
-	current_real_uuid = rtd.real_terminal_uuid;
+	current_real_terminal = mrtd;
 	current_phy_uuid = physical_data.uuid_;
 	bool already_jumped_to_next = false;
-	RealTerminalData next_data;
-	do {
-		auto next_rtd = m_terminal_strip->nextRealTerminal(current_real_uuid);
-		current_real_uuid = next_rtd.real_terminal_uuid;
+	modelRealTerminalData next_data;
 
-		if (next_rtd.level_ == -1) {
+	do {
+		current_real_terminal = modelRealData(m_terminal_strip->nextRealTerminal(current_real_terminal.real_terminal));
+
+		if (current_real_terminal.level_ == -1) {
 			break;
 		}
 
 			//We are in the same physical terminal as previous loop
-		if (current_phy_uuid == m_terminal_strip->physicalTerminalData(next_rtd).uuid_)
+		if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_)
 		{
-			if (next_rtd.is_bridged &&
-				next_rtd.level_ == level_column) {
-				next_data = next_rtd;
+			if (current_real_terminal.bridged_ &&
+				current_real_terminal.level_ == level_column) {
+				next_data = current_real_terminal;
 				break;
 			}
 		}
@@ -712,27 +727,50 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 			break;
 		} else {
 			already_jumped_to_next = true;
-			current_phy_uuid = m_terminal_strip->physicalTerminalData(next_rtd).uuid_;
-			if (next_rtd.is_bridged &&
-				next_rtd.level_ == level_column) {
-				next_data = next_rtd;
+			current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_;
+			if (current_real_terminal.bridged_ &&
+				current_real_terminal.level_ == level_column) {
+				next_data = current_real_terminal;
 				break;
 			}
 		}
 	} while(true);
 
-	if (previous_data.bridge_uuid == next_data.bridge_uuid) {
-		auto bridge_ = m_terminal_strip->bridgeFor(previous_data.real_terminal_uuid);
-		if (bridge_) {
-			return m_bridges_pixmaps.value(bridge_->color_).none_;
+	auto previous_bridge = m_terminal_strip->bridgeFor(previous_data.real_terminal);
+	if (previous_bridge == m_terminal_strip->bridgeFor(next_data.real_terminal))
+	{
+		if (previous_bridge) {
+			return m_bridges_pixmaps.value(previous_bridge->color_).none_;
 		}
 	}
 
 	return QPixmap();
 }
 
+modelRealTerminalData TerminalStripModel::modelRealData(const RealTerminalData &data)
+{
+	modelRealTerminalData mrtd;
+	if (!data.isNull())
+	{
+		mrtd.level_ = data.level();
+		mrtd.label_ = data.label();
+		mrtd.Xref_ = data.Xref();
+		mrtd.cable_ = data.cable();
+		mrtd.cable_wire = data.cableWire();
+		mrtd.conductor_ = data.conductor();
+		mrtd.led_ = data.isLed();
+		mrtd.type_ = data.type();
+		mrtd.function_ = data.function();
+		mrtd.element_ = data.element();
+		mrtd.real_terminal = data.realTerminal();
+		mrtd.bridged_ = data.isBridged();
+	}
+
+	return mrtd;
+}
+
 /***********************************************************
- * Alittle delegate for add a combobox to edit type
+ * A little delegate for add a combobox to edit type
  * and a spinbox to edit the level of a terminal
  **********************************************************/
 

sources/TerminalStrip/ui/terminalstripmodel.h

@@ -26,14 +26,54 @@
 #include <QColor>
 
 #include "../terminalstrip.h"
+#include "../../qetgraphicsitem/element.h"
 
 //Code to use QColor as key for QHash
 inline uint qHash(const QColor &key, uint seed) {
 	return qHash(key.name(), seed);
 }
 
+//needed to use QPointer<Element> as key of QHash
+inline uint qHash(const QPointer<Element> &key, uint seed) {
+	if (key)
+		return qHash(key->uuid(), seed);
+	else
+		return qHash(nullptr, seed);
+}
+
 class TerminalStrip;
 
+
+struct modelRealTerminalData
+{
+		int level_ = -1;
+		QString label_;
+		QString Xref_;
+		QString cable_;
+		QString cable_wire;
+		QString conductor_;
+		bool led_ = false;
+		bool bridged_ = false;
+
+		ElementData::TerminalType type_ = ElementData::TerminalType::TTGeneric;
+		ElementData::TerminalFunction function_ = ElementData::TerminalFunction::TFGeneric;
+		QPointer<Element> element_;
+
+		QWeakPointer<RealTerminal> real_terminal;
+
+};
+
+struct modelPhysicalTerminalData
+{
+		QVector<modelRealTerminalData> real_data;
+		int pos_ = -1;
+		QUuid uuid_;
+};
+
+inline bool operator == (const modelPhysicalTerminalData &data_1, const modelPhysicalTerminalData &data_2) {
+	return data_1.uuid_ == data_2.uuid_;
+}
+
 class TerminalStripModel : public QAbstractTableModel
 {
 	public:
@@ -68,27 +108,28 @@ class TerminalStripModel : public QAbstractTableModel
 		virtual bool setData (const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
 		virtual QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
 		virtual Qt::ItemFlags flags (const QModelIndex &index) const override;
-		QVector<QPair<RealTerminalData, RealTerminalData>> modifiedRealTerminalData() const;
+		QVector<modelRealTerminalData> modifiedmodelRealTerminalData() const;
 
-		QVector<PhysicalTerminalData> physicalTerminalDataForIndex(QModelIndexList index_list) const;
-		QVector<RealTerminalData> realTerminalDataForIndex(QModelIndexList index_list) const;
-		RealTerminalData realTerminalDataForIndex(const QModelIndex &index) const;
+		QVector<modelPhysicalTerminalData> modelPhysicalTerminalDataForIndex(QModelIndexList index_list) const;
+		QVector<modelRealTerminalData> modelRealTerminalDataForIndex(QModelIndexList index_list) const;
+		modelRealTerminalData modelRealTerminalDataForIndex(const QModelIndex &index) const;
 
 		void buildBridgePixmap(const QSize &pixmap_size);
 
 	private:
 		void fillPhysicalTerminalData();
-		RealTerminalData dataAtRow(int row) const;
-		void replaceDataAtRow(RealTerminalData data, int row);
-		PhysicalTerminalData physicalDataAtIndex(int index) const;
-		RealTerminalData realDataAtIndex(int index) const;
+		modelRealTerminalData dataAtRow(int row) const;
+		void replaceDataAtRow(modelRealTerminalData data, int row);
+		modelPhysicalTerminalData physicalDataAtIndex(int index) const;
+		modelRealTerminalData realDataAtIndex(int index) const;
 		QPixmap bridgePixmapFor(const QModelIndex &index) const;
 
+		static modelRealTerminalData modelRealData(const RealTerminalData &data);
+
     private:
         QPointer<TerminalStrip> m_terminal_strip;
-		QVector<PhysicalTerminalData> m_edited_terminal_data, m_original_terminal_data;
-		QHash<Element *, QVector<bool>> m_modified_cell;
-
+		QHash<QPointer<Element>, QVector<bool>> m_modified_cell;
+		QVector<modelPhysicalTerminalData> m_physical_data;
 		struct BridgePixmap
 		{
 				QPixmap top_,