Revamp terminalStrip feature code

Move RealTerminal class in a new file
Move PhysicalTerminal class in a new file.
Remove the use of QWeakPointer and use instead QSharedPointer
in a big part of the revamp.

sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp

@@ -18,7 +18,7 @@
 #include "bridgeterminalscommand.h"
 
 BridgeTerminalsCommand::BridgeTerminalsCommand(TerminalStrip *strip,
-											   QVector<QWeakPointer<RealTerminal>> real_terminal,
+											   QVector<QSharedPointer<RealTerminal>> real_terminal,
 											   QUndoCommand *parent):
 	QUndoCommand(parent),
 	m_strip(strip),
@@ -42,7 +42,7 @@ void BridgeTerminalsCommand::redo()
 }
 
 UnBridgeTerminalsCommand::UnBridgeTerminalsCommand(TerminalStrip *strip,
-												   QVector<QWeakPointer<RealTerminal>> real_terminal,
+												   QVector<QSharedPointer<RealTerminal>> real_terminal,
 												   QUndoCommand *parent):
 	QUndoCommand(parent),
 	m_strip(strip)
@@ -52,14 +52,14 @@ UnBridgeTerminalsCommand::UnBridgeTerminalsCommand(TerminalStrip *strip,
 	if (strip->canUnBridge(real_terminal))
 	{
 		m_terminals = real_terminal;
-		m_bridge = strip->bridgeFor(real_terminal.first());
+		m_bridge = strip->isBridged(real_terminal.first());
 	}
 }
 
 void UnBridgeTerminalsCommand::undo()
 {
 	if (m_strip && m_bridge) {
-		m_strip->setBridge(m_bridge.toStrongRef(), m_terminals);
+		m_strip->setBridge(m_bridge, m_terminals);
 	}
 }
 

sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h

@@ -33,7 +33,7 @@
 class BridgeTerminalsCommand : public QUndoCommand
 {
 	public:
-		BridgeTerminalsCommand(TerminalStrip *strip, QVector<QWeakPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
+		BridgeTerminalsCommand(TerminalStrip *strip, QVector<QSharedPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
 		~BridgeTerminalsCommand() override {}
 
 		void undo() override;
@@ -41,7 +41,7 @@ class BridgeTerminalsCommand : public QUndoCommand
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		QVector<QWeakPointer<RealTerminal>> m_real_terminal_vector;
+		QVector<QSharedPointer<RealTerminal>> m_real_terminal_vector;
 };
 
 
@@ -53,7 +53,7 @@ class BridgeTerminalsCommand : public QUndoCommand
 class UnBridgeTerminalsCommand : public QUndoCommand
 {
 	public:
-		UnBridgeTerminalsCommand(TerminalStrip *strip, QVector<QWeakPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
+		UnBridgeTerminalsCommand(TerminalStrip *strip, QVector<QSharedPointer<RealTerminal>> real_terminal, QUndoCommand *parent = nullptr);
 		~UnBridgeTerminalsCommand() override{}
 
 		void undo() override;
@@ -61,8 +61,8 @@ class UnBridgeTerminalsCommand : public QUndoCommand
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		QWeakPointer<TerminalStripBridge> m_bridge;
-		QVector<QWeakPointer<RealTerminal>> m_terminals;
+		QSharedPointer<TerminalStripBridge> m_bridge;
+		QVector<QSharedPointer<RealTerminal>> m_terminals;
 };
 
 #endif // BRIDGETERMINALSCOMMAND_H

sources/TerminalStrip/UndoCommand/changeterminallevel.cpp

@@ -16,6 +16,7 @@
 		along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "changeterminallevel.h"
+#include "../realterminal.h"
 
 ChangeTerminalLevel::ChangeTerminalLevel(TerminalStrip *strip,
 										 const QWeakPointer<RealTerminal> &real_terminal,

sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp

@@ -17,6 +17,7 @@
 */
 #include "groupterminalscommand.h"
 #include "../../utils/qetutils.h"
+#include "../physicalterminal.h"
 
 /**
  * @brief GroupTerminalsCommand::GroupTerminalsCommand
@@ -38,13 +39,13 @@ GroupTerminalsCommand::GroupTerminalsCommand(TerminalStrip *strip,
 
 void GroupTerminalsCommand::undo() {
 	if (m_terminal_strip) {
-		m_terminal_strip->unGroupTerminals(QETUtils::sharedVectorToWeak(m_to_group));
+		m_terminal_strip->unGroupTerminals(m_to_group);
 	}
 }
 
 void GroupTerminalsCommand::redo() {
 	if (m_terminal_strip) {
-		m_terminal_strip->groupTerminals(m_receiver, QETUtils::sharedVectorToWeak(m_to_group));
+		m_terminal_strip->groupTerminals(m_receiver,m_to_group);
 	}
 }
 
@@ -63,7 +64,7 @@ void UnGroupTerminalsCommand::undo()
 	if (m_terminal_strip)
 	{
 		for (const auto &key : m_physical_real_H.keys()) {
-			m_terminal_strip->groupTerminals(key, QETUtils::sharedVectorToWeak(m_physical_real_H.value(key)));
+			m_terminal_strip->groupTerminals(key, m_physical_real_H.value(key));
 		}
 	}
 }
@@ -73,7 +74,7 @@ void UnGroupTerminalsCommand::redo()
 	if (m_terminal_strip)
 	{
 		for (const auto &value : qAsConst(m_physical_real_H)) {
-			m_terminal_strip->unGroupTerminals(QETUtils::sharedVectorToWeak(value));
+			m_terminal_strip->unGroupTerminals(value);
 		}
 	}
 }
@@ -86,7 +87,7 @@ void UnGroupTerminalsCommand::setUp(const QVector<QSharedPointer<RealTerminal>>
 		if (phy_t)
 		{
 				//Physical have only one real terminal, no need to ungroup it
-			if (phy_t.toStrongRef()->realTerminalCount() <= 1) {
+			if (phy_t->realTerminalCount() <= 1) {
 				continue;
 			}
 

sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp

@@ -17,6 +17,8 @@
 */
 #include "sortterminalstripcommand.h"
 #include "../terminalstrip.h"
+#include "../physicalterminal.h"
+#include "../realterminal.h"
 #include "../../utils/qetutils.h"
 
 SortTerminalStripCommand::SortTerminalStripCommand(TerminalStrip *strip, QUndoCommand *parent) :
@@ -24,22 +26,22 @@ SortTerminalStripCommand::SortTerminalStripCommand(TerminalStrip *strip, QUndoCo
 	m_strip(strip)
 {
 	setText(QObject::tr("Trier le bornier %1").arg(m_strip->name()));
-	m_old_order = QETUtils::weakVectorToShared(m_strip->physicalTerminal());
-	m_new_order = QETUtils::weakVectorToShared(m_strip->physicalTerminal());
+	m_old_order = m_strip->physicalTerminal();
+	m_new_order = m_strip->physicalTerminal();
 	sort();
 }
 
 void SortTerminalStripCommand::undo()
 {
 	if (m_strip) {
-		m_strip->setOrderTo(QETUtils::sharedVectorToWeak(m_old_order));
+		m_strip->setOrderTo(m_old_order);
 	}
 }
 
 void SortTerminalStripCommand::redo()
 {
 	if (m_strip) {
-		m_strip->setOrderTo(QETUtils::sharedVectorToWeak(m_new_order));
+		m_strip->setOrderTo(m_new_order);
 	}
 }
 
@@ -56,7 +58,7 @@ void SortTerminalStripCommand::sort()
 
 		if (arg1->realTerminalCount())
 		{
-			str1 = arg1->realTerminals().constLast().toStrongRef()->label();
+			str1 = arg1->realTerminals().constLast()->label();
 
 			auto match = rx.match(str1);
 			if (match.hasMatch()) {
@@ -66,7 +68,7 @@ void SortTerminalStripCommand::sort()
 
 		if (arg2->realTerminalCount())
 		{
-			str2 = arg2->realTerminals().constLast().toStrongRef()->label();
+			str2 = arg2->realTerminals().constLast()->label();
 
 			auto match = rx.match(str2);
 			if (match.hasMatch()) {

sources/TerminalStrip/physicalterminal.cpp

@@ -0,0 +1,176 @@
+/*
+	Copyright 2006-2021 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "physicalterminal.h"
+#include "realterminal.h"
+#include "terminalstrip.h"
+
+/**
+ * @brief PhysicalTerminal
+ * @param parent_strip : Parent terminal strip
+ * @param terminals : A vector of real terminals
+ * who compose this physical terminal.
+ * \p terminals must have at least one terminal
+ */
+PhysicalTerminal::PhysicalTerminal(TerminalStrip *parent_strip,
+								   QVector<QSharedPointer<RealTerminal>> terminals) :
+	m_parent_terminal_strip(parent_strip),
+	m_real_terminal(terminals)
+{}
+
+/**
+ * @brief PhysicalTerminal::sharedRef
+ * @return a QSharedPointer of this
+ */
+QSharedPointer<PhysicalTerminal> PhysicalTerminal::sharedRef()
+{
+	QSharedPointer<PhysicalTerminal> this_shared(this->weakRef());
+	if (this_shared.isNull())
+	{
+		this_shared = QSharedPointer<PhysicalTerminal>(this);
+		m_this_weak = this_shared.toWeakRef();
+	}
+
+	return this_shared;
+}
+
+/**
+ * @brief PhysicalTerminal::weakRef
+ * @return a QWeakPointer of this, weak pointer can be null
+ */
+QWeakPointer<PhysicalTerminal> PhysicalTerminal::weakRef() {
+	return m_this_weak;
+}
+
+/**
+ * @brief toXml
+ * @param parent_document
+ * @return this physical terminal to xml
+ */
+QDomElement PhysicalTerminal::toXml(QDomDocument &parent_document) const
+{
+	auto root_elmt = parent_document.createElement(this->xmlTagName());
+	for (auto &real_t : m_real_terminal) {
+		root_elmt.appendChild(real_t->toXml(parent_document));
+	}
+
+	return root_elmt;
+}
+
+/**
+ * @brief setTerminals
+ * Set the RealTerminal who compose this physical terminal.
+ * The position of the RealTerminal in @a terminals
+ * represent the level of these in this physical terminal.
+ * @param terminals
+ */
+void PhysicalTerminal::setTerminals(const QVector<QSharedPointer<RealTerminal>> &terminals) {
+	m_real_terminal = terminals;
+}
+
+/**
+ * @brief addTerminals
+ * Append the real terminal @a terminal
+ * to this physical terminal.
+ * @param terminal
+ */
+void PhysicalTerminal::addTerminal(const QSharedPointer<RealTerminal> &terminal) {
+	m_real_terminal.append(terminal);
+}
+
+/**
+ * @brief removeTerminal
+ * Remove @a terminal from the list of real terminal
+ * @param terminal
+ * @return true if sucessfully removed
+ */
+bool PhysicalTerminal::removeTerminal(const QSharedPointer<RealTerminal> &terminal) {
+	return m_real_terminal.removeOne(terminal);
+}
+
+/**
+ * @brief setLevelOf
+ * Change the level of \p terminal
+ * @param terminal
+ * @param level
+ */
+bool PhysicalTerminal::setLevelOf(const QSharedPointer<RealTerminal> &terminal, int level)
+{
+	const int i = m_real_terminal.indexOf(terminal);
+	if (i >= 0)
+	{
+#if QT_VERSION >= QT_VERSION_CHECK(5,14,0)
+		m_real_terminal.swapItemsAt(i, std::min(level, m_real_terminal.size()-1));
+#else
+		auto j = std::min(level, m_real_terminal.size()-1);
+		std::swap(m_real_terminal.begin()[i], m_real_terminal.begin()[j]);
+#endif
+		return true;
+	}
+	return false;
+}
+
+/**
+ * @brief levelCount
+ * @return the number of level of this terminal
+ */
+int PhysicalTerminal::levelCount() const {
+	return m_real_terminal.size();
+}
+
+/**
+ * @brief levelOf
+ * @param terminal
+ * @return the level of real terminal \p terminal or
+ * -1 if \terminal is not a part of this physicalTerminal
+ */
+int PhysicalTerminal::levelOf(const QSharedPointer<RealTerminal> &terminal) const {
+	return m_real_terminal.indexOf(terminal);
+}
+
+/**
+ * @brief terminals
+ * @return A vector of RealTerminal who compose this PhysicalTerminal
+ */
+QVector<QSharedPointer<RealTerminal>> PhysicalTerminal::realTerminals() const {
+	return m_real_terminal;
+}
+
+/**
+ * @brief uuid
+ * @return the uuid of this physical terminal
+ */
+QUuid PhysicalTerminal::uuid() const {
+	return m_uuid;
+}
+
+int PhysicalTerminal::pos() const
+{
+	if (m_parent_terminal_strip) {
+		return m_parent_terminal_strip->pos(m_this_weak);
+	} else {
+		return -1;
+	}
+}
+
+int PhysicalTerminal::realTerminalCount() const {
+	return m_real_terminal.size();
+}
+
+QString PhysicalTerminal::xmlTagName() {
+	return QStringLiteral("physical_terminal");
+}

sources/TerminalStrip/physicalterminal.h

@@ -0,0 +1,96 @@
+/*
+	Copyright 2006-2021 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef PHYSICALTERMINAL_H
+#define PHYSICALTERMINAL_H
+
+#include <QSharedPointer>
+#include <QDomElement>
+#include <QPointer>
+#include <QUuid>
+
+class RealTerminal;
+class TerminalStrip;
+
+/**
+ * @brief The PhysicalTerminal class
+ * Represent a physical terminal.
+ * A physical terminal is composed a least by one RealTerminal.
+ * When a physical terminal have more than one real terminal
+ * that mean the physical terminal have levels (one by real terminal).
+ * The index of real terminals returned by the function terminals()
+ * is the same as the real level of the real terminal, the index are from back to front.
+ *
+ * Example for a 3 levels terminal.
+ * index 0 = back (mounting plate)
+ * index 1 = middle
+ * index 2 = front (electrical cabinet door)
+ *
+ *	m
+ *	o	  _
+ *	u	 | |
+ *	n	 | | _
+ *	t	 | || |
+ *	i	 | || | _
+ *	n	 | || || |   d
+ *	g	 |0||1||2|   o
+ *		 | || ||_|   o
+ *	p	 | || |      r
+ *	l	 | ||_|
+ *	a	 | |
+ *	t	 |_|
+ *	e
+ *
+ *
+ */
+class PhysicalTerminal
+{
+		friend class TerminalStrip;
+
+	private:
+		PhysicalTerminal(TerminalStrip *parent_strip, QVector<QSharedPointer<RealTerminal>> terminals);
+		QSharedPointer<PhysicalTerminal> sharedRef();
+		QWeakPointer<PhysicalTerminal> weakRef();
+
+		QDomElement toXml(QDomDocument &parent_document) const;
+
+		void setTerminals(const QVector<QSharedPointer<RealTerminal>> &terminals);
+		void addTerminal(const QSharedPointer<RealTerminal> &terminal);
+		bool removeTerminal(const QSharedPointer<RealTerminal> &terminal);
+
+		bool setLevelOf(const QSharedPointer<RealTerminal> &terminal, int level);
+
+	public:
+		PhysicalTerminal(){}
+
+		int levelCount() const;
+		int levelOf(const QSharedPointer<RealTerminal> &terminal) const;
+		QVector<QSharedPointer<RealTerminal>> realTerminals() const;
+		QUuid uuid() const;
+		int pos() const;
+		int realTerminalCount() const;
+
+		static QString xmlTagName();
+
+	private:
+		QPointer<TerminalStrip> m_parent_terminal_strip;
+		QVector<QSharedPointer<RealTerminal>> m_real_terminal;
+		QUuid m_uuid = QUuid::createUuid();
+		QWeakPointer<PhysicalTerminal> m_this_weak;
+};
+
+#endif // PHYSICALTERMINAL_H

sources/TerminalStrip/realterminal.cpp

@@ -0,0 +1,286 @@
+/*
+	Copyright 2006-2021 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "realterminal.h"
+#include "terminalstrip.h"
+#include "../qetgraphicsitem/terminalelement.h"
+#include "physicalterminal.h"
+
+/**
+ * @brief RealTerminal
+ * @param parent_strip : parent terminal strip
+ * @param terminal : terminal element (if any) in a folio
+ */
+RealTerminal::RealTerminal(TerminalStrip *parent_strip,
+						   Element *terminal) :
+	m_element(terminal),
+	m_parent_terminal_strip(parent_strip)
+{}
+
+/**
+ * @brief RealTerminal::sharedRef
+ * @return a QSharedPointer of this
+ */
+QSharedPointer<RealTerminal> RealTerminal::sharedRef()
+{
+	QSharedPointer<RealTerminal> this_shared(this->weakRef());
+	if (this_shared.isNull())
+	{
+		this_shared = QSharedPointer<RealTerminal>(this);
+		m_this_weak = this_shared.toWeakRef();
+	}
+
+	return this_shared;
+}
+
+/**
+ * @brief RealTerminal::weakRef
+ * @return a QWeakPointer of this, weak pointer can be bull
+ */
+QWeakPointer<RealTerminal> RealTerminal::weakRef() {
+	return m_this_weak;
+}
+
+/**
+ * @brief fromXml
+ * @param xml_element
+ * @return
+ */
+bool RealTerminal::fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector)
+{
+	if (xml_element.tagName() != xmlTagName()) {
+		return true;
+	}
+
+	auto is_draw = xml_element.attribute(QStringLiteral("is_draw")) == QLatin1String("true")
+				   ? true : false;
+
+	QUuid uuid_(xml_element.attribute(QStringLiteral("uuid")));
+
+	if (is_draw) {
+		for (auto terminal : terminal_vector) {
+			if (terminal->uuid() == uuid_)
+			{
+				m_element = terminal;
+				break;
+			}
+		}
+	} else {
+		m_uuid = uuid_;
+	}
+
+	return true;
+}
+
+/**
+ * @brief toXml
+ * @param parent_document
+ * @return this real terminal to xml
+ */
+QDomElement RealTerminal::toXml(QDomDocument &parent_document) const
+{
+	auto root_elmt = parent_document.createElement(this->xmlTagName());
+	root_elmt.setAttribute("is_draw", m_element ? "true" : "false");
+	root_elmt.setAttribute("uuid", m_element ? m_element->uuid().toString() :
+											   m_uuid.toString());
+
+	return root_elmt;
+}
+
+/**
+		 * @brief parentStrip
+		 * @return parent terminal strip
+		 */
+TerminalStrip *RealTerminal::parentStrip() const {
+	return m_parent_terminal_strip.data();
+}
+
+/**
+ * @brief RealTerminal::level
+ * @return
+ */
+int RealTerminal::level() const
+{
+	if (m_parent_terminal_strip) {
+		const auto phy_t = m_parent_terminal_strip->physicalTerminal(m_this_weak);
+		if (phy_t) {
+			return phy_t->levelOf(m_this_weak);
+		}
+	}
+
+	return -1;
+}
+
+/**
+ * @brief label
+ * @return the label of this real terminal
+ */
+QString RealTerminal::label() const {
+	if (!m_element.isNull()) {
+		return m_element->actualLabel();
+	} else {
+		return QLatin1String();
+	}
+}
+
+/**
+ * @brief RealTerminal::Xref
+ * @return Conveniant method to get the XRef
+ * formated to string
+ */
+QString RealTerminal::Xref() const
+{
+	if (!m_element.isNull()) {
+		return autonum::AssignVariables::genericXref(m_element.data());
+	} else {
+		return QString();
+	}
+}
+
+/**
+ * @brief RealTerminal::cable
+ * @return
+ */
+QString RealTerminal::cable() const {
+	return QString();
+}
+
+/**
+ * @brief RealTerminal::cableWire
+ * @return
+ */
+QString RealTerminal::cableWire() const {
+	return QString();
+}
+
+/**
+ * @brief RealTerminal::conductor
+ * @return
+ */
+QString RealTerminal::conductor() const {
+	return QString();
+}
+
+/**
+ * @brief RealTerminal::type
+ * @return
+ */
+ElementData::TerminalType RealTerminal::type() const {
+	if (m_element) {
+		return m_element->elementData().terminalType();
+	} else {
+		return ElementData::TTGeneric;
+	}
+}
+
+/**
+ * @brief RealTerminal::function
+ * @return
+ */
+ElementData::TerminalFunction RealTerminal::function() const {
+	if (m_element) {
+		return m_element->elementData().terminalFunction();
+	} else {
+		return ElementData::TFGeneric;
+	}
+}
+
+/**
+ * @brief RealTerminal::isLed
+ * @return
+ */
+bool RealTerminal::isLed() const {
+	if (m_element) {
+		return m_element->elementData().terminalLed();
+	} else {
+		return false;
+	}
+}
+
+/**
+ * @brief isElement
+ * @return true if this real terminal is linked to a terminal element
+ */
+bool RealTerminal::isElement() const {
+	return m_element.isNull() ? false : true;
+}
+
+/**
+ * @brief RealTerminal::isBridged
+ * @return true if is bridged.
+ * @sa TerminalStrip::isBridged
+ */
+bool RealTerminal::isBridged() const
+{
+	if (m_parent_terminal_strip) {
+		return !m_parent_terminal_strip->isBridged(m_this_weak.toStrongRef()).isNull();
+	} else {
+		return false;
+	}
+}
+
+/**
+ * @brief RealTerminal::bridge
+ * @return
+ */
+QSharedPointer<TerminalStripBridge> RealTerminal::bridge() const
+{
+	if (m_parent_terminal_strip) {
+		return m_parent_terminal_strip->isBridged(m_this_weak.toStrongRef());
+	} else {
+		return QSharedPointer<TerminalStripBridge>();
+	}
+}
+
+/**
+ * @brief element
+ * @return the element linked to this real terminal
+ * or nullptr if not linked to an Element.
+ */
+Element *RealTerminal::element() const {
+	return m_element.data();
+}
+
+/**
+ * @brief elementUuid
+ * @return if this real terminal is an element
+ * in a folio, return the uuid of the element
+ * else return a null uuid.
+ */
+QUuid RealTerminal::elementUuid() const {
+	if (!m_element.isNull()) {
+		return m_element->uuid();
+	} else {
+		return QUuid();
+	}
+}
+
+/**
+ * @brief uuid
+ * @return the uuid of this real terminal
+ */
+QUuid RealTerminal::uuid() const {
+	return m_uuid;
+}
+
+/**
+ * @brief RealTerminal::RealTerminal::xmlTagName
+ * @return
+ */
+QString RealTerminal::RealTerminal::xmlTagName() {
+	return QStringLiteral("real_terminal");
+}

sources/TerminalStrip/realterminal.h

@@ -0,0 +1,86 @@
+/*
+	Copyright 2006-2021 The QElectroTech Team
+	This file is part of QElectroTech.
+
+	QElectroTech is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	QElectroTech is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef REALTERMINAL_H
+#define REALTERMINAL_H
+
+#include <QSharedPointer>
+#include <QDomElement>
+#include "../properties/elementdata.h"
+
+class TerminalStrip;
+class Element;
+class TerminalElement;
+class PhysicalTerminal;
+struct TerminalStripBridge;
+
+/**
+ * @brief The RealTerminal class
+ * Represent a real terminal.
+ * A real terminal can be a drawed terminal in a folio
+ * or a terminal set by user but not present
+ * on any folio (for example a reserved terminal).
+ *
+ * When create a new instance of RealTerminal you must
+ * call sharedRef() and only use the returned QSharedPointer
+ * instead of the raw pointer
+ */
+class RealTerminal
+{
+		friend class TerminalStrip;
+		friend class PhysicalTerminal;
+
+	private:
+		RealTerminal(TerminalStrip *strip, Element *element = nullptr);
+		QSharedPointer<RealTerminal> sharedRef();
+		QWeakPointer<RealTerminal> weakRef();
+
+		bool fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector);
+		QDomElement toXml(QDomDocument &parent_document) const;
+
+	public:
+		TerminalStrip *parentStrip() 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;
+
+		QSharedPointer<TerminalStripBridge> bridge() const;
+
+		Element* element() const;
+		QUuid elementUuid() const;
+		QUuid uuid() const;
+
+		static QString xmlTagName();
+
+	private :
+		QPointer<Element> m_element;
+		QPointer<TerminalStrip> m_parent_terminal_strip;
+		QUuid m_uuid = QUuid::createUuid();
+		QWeakPointer<RealTerminal> m_this_weak;
+};
+
+#endif // REALTERMINAL_H

sources/TerminalStrip/terminalstrip.h

@@ -40,97 +40,6 @@ struct TerminalStripBridge
 		QUuid uuid_ = QUuid::createUuid();
 };
 
-/**
- * @brief The RealTerminal class
- * Represent a real terminal.
- * A real terminal can be a drawed terminal in a folio
- * or a terminal set by user but not present
- * on any folio (for example a reserved terminal).
- *
- * When create a new instance of RealTerminal you must
- * call sharedRef() and only use the returned QSharedPointer
- * instead of the raw pointer
- */
-class RealTerminal
-{
-		friend class TerminalStrip;
-		friend class PhysicalTerminal;
-
-	private:
-		RealTerminal(TerminalStrip *strip, Element *element = nullptr);
-		QSharedPointer<RealTerminal> sharedRef();
-		QWeakPointer<RealTerminal> weakRef();
-
-		bool fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector);
-		QDomElement toXml(QDomDocument &parent_document) const;
-
-	public:
-		TerminalStrip *parentStrip() 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;
-
-		QSharedPointer<TerminalStripBridge> bridge() const;
-
-		Element* element() const;
-		QUuid elementUuid() const;
-		QUuid uuid() const;
-
-		static QString xmlTagName();
-
-	private :
-		QPointer<Element> m_element;
-		QPointer<TerminalStrip> m_parent_terminal_strip;
-		QUuid m_uuid = QUuid::createUuid();
-		QWeakPointer<RealTerminal> m_this_weak;
-};
-
-class PhysicalTerminal
-{
-		friend class TerminalStrip;
-
-	private:
-		PhysicalTerminal(TerminalStrip *parent_strip, QVector<QSharedPointer<RealTerminal>> terminals);
-		QSharedPointer<PhysicalTerminal> sharedRef();
-		QWeakPointer<PhysicalTerminal> weakRef();
-
-		QDomElement toXml(QDomDocument &parent_document) const;
-
-		void setTerminals(const QVector<QSharedPointer<RealTerminal>> &terminals);
-		void addTerminal(const QSharedPointer<RealTerminal> &terminal);
-		bool removeTerminal(const QSharedPointer<RealTerminal> &terminal);
-
-		bool setLevelOf(const QSharedPointer<RealTerminal> &terminal, int level);
-
-	public:
-		PhysicalTerminal(){}
-
-		int levelCount() const;
-		int levelOf(const QWeakPointer<RealTerminal> &terminal) const;
-		QVector<QWeakPointer<RealTerminal>> realTerminals() const;
-		QUuid uuid() const;
-		int pos() const;
-		int realTerminalCount() const;
-
-		static QString xmlTagName();
-
-	private:
-		QPointer<TerminalStrip> m_parent_terminal_strip;
-		QVector<QSharedPointer<RealTerminal>> m_real_terminal;
-		QUuid m_uuid = QUuid::createUuid();
-		QWeakPointer<PhysicalTerminal> m_this_weak;
-};
-
 /**
  * @brief The TerminalStrip class
  * This class hold all the datas and configurations
@@ -178,28 +87,30 @@ class TerminalStrip : public QObject
 		bool addTerminal    (Element *terminal);
 		bool removeTerminal (Element *terminal);
 
-		int pos(const QWeakPointer<PhysicalTerminal> &terminal) const;
+		int pos(const QSharedPointer<PhysicalTerminal> &terminal) const;
 		int physicalTerminalCount() const;
-		QWeakPointer<PhysicalTerminal> physicalTerminal(int index) const;
-		QWeakPointer<PhysicalTerminal> physicalTerminal (const QWeakPointer<RealTerminal> &real_terminal) const;
-		QVector<QWeakPointer<PhysicalTerminal>> physicalTerminal() const;
+		QSharedPointer<PhysicalTerminal> physicalTerminal(int index) const;
+		QSharedPointer<PhysicalTerminal> physicalTerminal (const QSharedPointer<RealTerminal> &real_terminal) const;
+		QVector<QSharedPointer<PhysicalTerminal>> physicalTerminal() const;
+		QSharedPointer<RealTerminal> realTerminal(Element *terminal) const;
 
-		bool setOrderTo(const QVector<QWeakPointer<PhysicalTerminal>> &sorted_vector);
-		bool groupTerminals(const QWeakPointer<PhysicalTerminal> &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);
+		bool setOrderTo(const QVector<QSharedPointer<PhysicalTerminal>> &sorted_vector);
+		bool groupTerminals(const QSharedPointer<PhysicalTerminal> &receiver_terminal, const QVector<QSharedPointer<RealTerminal>> &added_terminals);
+		void unGroupTerminals(const QVector<QSharedPointer<RealTerminal>> &terminals_to_ungroup);
+		bool setLevel(const QSharedPointer<RealTerminal> &real_terminal, int level);
 
-		bool isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const;
-		bool setBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
-		bool setBridge(const QSharedPointer<TerminalStripBridge> &bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals);
-		void unBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
-		bool canUnBridge(const QVector <QWeakPointer<RealTerminal>> &real_terminals) const;
-		QSharedPointer<TerminalStripBridge> bridgeFor(const QWeakPointer<RealTerminal> &real_terminal) const;
+		bool isBridgeable(const QVector<QSharedPointer<RealTerminal>> &real_terminals) const;
+		bool setBridge(const QVector<QSharedPointer<RealTerminal>> &real_terminals);
+		bool setBridge(const QSharedPointer<TerminalStripBridge> &bridge, const QVector<QSharedPointer<RealTerminal>> &real_terminals);
+		void unBridge(const QVector<QSharedPointer<RealTerminal>> &real_terminals);
+		bool canUnBridge(const QVector <QSharedPointer<RealTerminal>> &real_terminals) const;
+		QSharedPointer<TerminalStripBridge> isBridged(const QSharedPointer<RealTerminal> real_terminal) const;
+		QSharedPointer<TerminalStripBridge> bridgeFor (const QVector<QSharedPointer<RealTerminal>> &terminal_vector) const;
 
-		QWeakPointer<RealTerminal> previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
-		QWeakPointer<RealTerminal> nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
-		QWeakPointer<RealTerminal> previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
-		QWeakPointer<RealTerminal> nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
+		QSharedPointer<RealTerminal> previousTerminalInLevel(const QSharedPointer<RealTerminal> &real_terminal) const;
+		QSharedPointer<RealTerminal> nextTerminalInLevel(const QSharedPointer<RealTerminal> &real_terminal) const;
+		QSharedPointer<RealTerminal> previousRealTerminal(const QSharedPointer<RealTerminal> &real_terminal) const;
+		QSharedPointer<RealTerminal> nextRealTerminal(const QSharedPointer<RealTerminal> &real_terminal) const;
 
 		QVector<QPointer<Element>> terminalElement() const;
 
@@ -208,10 +119,6 @@ class TerminalStrip : public QObject
 		bool fromXml(QDomElement &xml_element);
 
 	private:
-		QSharedPointer<RealTerminal> realTerminal(Element *terminal);
-		QSharedPointer<PhysicalTerminal> physicalTerminal(QSharedPointer<RealTerminal> terminal) const;
-		QSharedPointer<TerminalStripBridge> isBridged(const QSharedPointer<RealTerminal> real_terminal) const;
-		QSharedPointer<TerminalStripBridge> bridgeFor (const QVector<QSharedPointer<RealTerminal>> &terminal_vector) const;
 		void rebuildRealVector();
 
 	private:

sources/TerminalStrip/ui/terminalstripeditor.cpp

@@ -35,6 +35,8 @@
 #include "../UndoCommand/changeterminallevel.h"
 #include "../UndoCommand/bridgeterminalscommand.h"
 #include "../../utils/qetutils.h"
+#include "../physicalterminal.h"
+#include "../realterminal.h"
 
 #include <QTreeWidgetItem>
 
@@ -232,10 +234,10 @@ QTreeWidgetItem* TerminalStripEditor::addTerminalStrip(TerminalStrip *terminal_s
 		//Add child terminal of the strip
 	for (auto i=0 ; i<terminal_strip->physicalTerminalCount() ; ++i)
 	{
-		auto phy_t = terminal_strip->physicalTerminal(i).toStrongRef();
+		auto phy_t = terminal_strip->physicalTerminal(i);
 		if (phy_t->realTerminalCount())
 		{
-			const auto real_t = phy_t->realTerminals().at(0).toStrongRef();
+			const auto real_t = phy_t->realTerminals().at(0);
 			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);
@@ -353,7 +355,7 @@ void TerminalStripEditor::spanMultiLevelTerminals()
 	auto current_row = 0;
 	for (auto i = 0 ; i < m_current_strip->physicalTerminalCount() ; ++i)
 	{
-		const auto level_count = m_current_strip->physicalTerminal(i).toStrongRef()->realTerminalCount();
+		const auto level_count = m_current_strip->physicalTerminal(i)->realTerminalCount();
 		if (level_count > 1) {
 			ui->m_table_widget->setSpan(current_row, 0, level_count, 1);
 		}
@@ -434,13 +436,13 @@ void TerminalStripEditor::selectionChanged()
 	{
 			//Select only terminals of corresponding level cell selection
 		QVector<modelRealTerminalData> model_real_terminal_level_vector;
-		QVector<QWeakPointer<RealTerminal>> real_terminal_in_level_vector;
+		QVector<QSharedPointer<RealTerminal>> real_terminal_in_level_vector;
 		for (const auto &mrtd : model_real_terminal_vector)
 		{
 			if (mrtd.level_ == level_)
 			{
 				model_real_terminal_level_vector.append(mrtd);
-				real_terminal_in_level_vector.append(mrtd.real_terminal);
+				real_terminal_in_level_vector.append(mrtd.real_terminal.toStrongRef());
 			}
 		}
 		enable_bridge = m_current_strip->isBridgeable(real_terminal_in_level_vector);
@@ -829,11 +831,11 @@ void TerminalStripEditor::on_m_bridge_terminals_pb_clicked()
 			const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes();
 			const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list);
 
-			QVector <QWeakPointer<RealTerminal>> match_vector;
+			QVector <QSharedPointer<RealTerminal>> match_vector;
 			for (const auto &mrtd : mrtd_vector)
 			{
 				if (mrtd.level_ == level_) {
-					match_vector.append(mrtd.real_terminal);
+					match_vector.append(mrtd.real_terminal.toStrongRef());
 				}
 			}
 
@@ -862,12 +864,12 @@ void TerminalStripEditor::on_m_unbridge_terminals_pb_clicked()
 
 			const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes();
 			const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list);
-			QVector<QWeakPointer<RealTerminal>> match_vector;
+			QVector<QSharedPointer<RealTerminal>> match_vector;
 			for (const auto &mrtd : mrtd_vector)
 			{
 				if (mrtd.level_ == level_
 					&& mrtd.bridged_) {
-					match_vector.append(mrtd.real_terminal);
+					match_vector.append(mrtd.real_terminal.toStrongRef());
 				}
 			}
 			m_project->undoStack()->push(new UnBridgeTerminalsCommand(m_current_strip, match_vector));

sources/TerminalStrip/ui/terminalstripmodel.cpp

@@ -18,6 +18,8 @@
 #include "terminalstripmodel.h"
 #include "../terminalstrip.h"
 #include "../../qetgraphicsitem/element.h"
+#include "../physicalterminal.h"
+#include "../realterminal.h"
 #include <QDebug>
 #include <QBrush>
 #include <QVector>
@@ -481,9 +483,8 @@ void TerminalStripModel::fillPhysicalTerminalData()
 		//Get all physical terminal
 	if (m_terminal_strip)
 	{
-		for (const auto &t_ : m_terminal_strip->physicalTerminal())
+		for (const auto &phy_t : m_terminal_strip->physicalTerminal())
 		{
-			const auto phy_t = t_.toStrongRef();
 			modelPhysicalTerminalData mptd;
 			mptd.pos_ = phy_t->pos();
 			mptd.uuid_ = phy_t->uuid();
@@ -642,15 +643,15 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 	{
 		if (mrtd.bridged_)
 		{
-			auto bridge_ = m_terminal_strip->bridgeFor(mrtd.real_terminal);
+			auto bridge_ = m_terminal_strip->isBridged(mrtd.real_terminal);
 			if (bridge_)
 			{
-				const auto previous_t = m_terminal_strip->previousTerminalInLevel(mrtd.real_terminal).toStrongRef();
+				const auto previous_t = m_terminal_strip->previousTerminalInLevel(mrtd.real_terminal);
 				QSharedPointer<TerminalStripBridge> previous_bridge;
 				if (previous_t)
 					previous_bridge = previous_t->bridge();
 
-				const auto next_t = m_terminal_strip->nextTerminalInLevel(mrtd.real_terminal).toStrongRef();
+				const auto next_t = m_terminal_strip->nextTerminalInLevel(mrtd.real_terminal);
 				QSharedPointer<TerminalStripBridge> next_bridge;
 				if (next_t)
 					next_bridge = next_t->bridge();
@@ -674,7 +675,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		//Check if we need to draw a none bridge pixmap
 
 		//Check previous
-	auto phy_t = m_terminal_strip->physicalTerminal(mrtd.real_terminal).toStrongRef();
+	auto phy_t = m_terminal_strip->physicalTerminal(mrtd.real_terminal);
 	auto current_real_terminal = mrtd;
 	auto current_phy_uuid = phy_t->uuid();
 	bool already_jumped_to_previous = false;
@@ -688,7 +689,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		}
 
 			//We are in the same physical terminal as previous loop
-		if (current_phy_uuid == m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal).toStrongRef()->uuid())
+		if (current_phy_uuid == m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal)->uuid())
 		{
 			if (current_real_terminal.bridged_ &&
 				current_real_terminal.level_ == level_column) {
@@ -700,7 +701,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 			break;
 		} else {
 			already_jumped_to_previous = true;
-			current_phy_uuid = m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal).toStrongRef()->uuid();
+			current_phy_uuid = m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal)->uuid();
 			if (current_real_terminal.bridged_ &&
 				current_real_terminal.level_ == level_column) {
 				previous_data = current_real_terminal;
@@ -723,7 +724,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		}
 
 			//We are in the same physical terminal as previous loop
-		if (current_phy_uuid == m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal).toStrongRef()->uuid())
+		if (current_phy_uuid == m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal)->uuid())
 		{
 			if (current_real_terminal.bridged_ &&
 				current_real_terminal.level_ == level_column) {
@@ -735,7 +736,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 			break;
 		} else {
 			already_jumped_to_next = true;
-			current_phy_uuid = m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal).toStrongRef()->uuid();
+			current_phy_uuid = m_terminal_strip->physicalTerminal(current_real_terminal.real_terminal)->uuid();
 			if (current_real_terminal.bridged_ &&
 				current_real_terminal.level_ == level_column) {
 				next_data = current_real_terminal;
@@ -744,8 +745,8 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
 		}
 	} while(true);
 
-	auto previous_bridge = m_terminal_strip->bridgeFor(previous_data.real_terminal);
-	if (previous_bridge == m_terminal_strip->bridgeFor(next_data.real_terminal))
+	auto previous_bridge = m_terminal_strip->isBridged(previous_data.real_terminal);
+	if (previous_bridge == m_terminal_strip->isBridged(next_data.real_terminal))
 	{
 		if (previous_bridge) {
 			return m_bridges_pixmaps.value(previous_bridge->color_).none_;