Merge branch 'terminal_strip'

* terminal_strip:
  Improve execution time of some actions.
  Minor : fix little gui defect
  Improve opening time of terminal strip editor window
  Display conductor number

sources/TerminalStrip/UndoCommand/addterminaltostripcommand.cpp

@@ -28,20 +28,36 @@
  * @param parent : parent undo command
  */
 AddTerminalToStripCommand::AddTerminalToStripCommand(QSharedPointer<RealTerminal> terminal, TerminalStrip *strip, QUndoCommand *parent) :
-    QUndoCommand(parent),
+	QUndoCommand{parent},
-    m_terminal(terminal),
+	m_terminal{terminal},
-	m_new_strip(strip)
+	m_new_strip{strip}
 {
-	auto t_label = terminal->label();
+	const auto t_label = terminal->label();
-    auto ts_name = strip->name();
+	const auto ts_name = strip->name();
 
-    auto str_1 = t_label.isEmpty() ? QObject::tr("Ajouter une borne") :
+	const auto str_1 = t_label.isEmpty() ? QObject::tr("Ajouter une borne") :
 									 QObject::tr("Ajouter la borne %1").arg(t_label);
 
-    auto str_2 = ts_name.isEmpty() ? QObject::tr("à un groupe de bornes") :
+	const auto str_2 = ts_name.isEmpty() ? QObject::tr("à un groupe de bornes") :
 									 QObject::tr("au groupe de bornes %1").arg(ts_name);
 
-    setText(str_1 + " " + str_2);
+	setText(str_1 + " " + str_2);
+}
+
+AddTerminalToStripCommand::AddTerminalToStripCommand(QVector<QSharedPointer<RealTerminal>> terminals, TerminalStrip *strip, QUndoCommand *parent) :
+	QUndoCommand{parent},
+	m_terminal{terminals},
+	m_new_strip{strip}
+{
+	const auto ts_name = strip->name();
+
+	const auto str_1 = m_terminal.size() > 1 ? QObject::tr("Ajouter %1 bornes").arg(m_terminal.size()) :
+											   QObject::tr("Ajouter une borne");
+
+	const auto str_2 = ts_name.isEmpty() ? QObject::tr("à un groupe de bornes") :
+										  QObject::tr("au groupe de bornes %1").arg(ts_name);
+
+	setText(str_1 + " " + str_2);
 }
 
 
@@ -54,11 +70,9 @@ AddTerminalToStripCommand::~AddTerminalToStripCommand()
  */
 void AddTerminalToStripCommand::undo()
 {
-    if (!m_terminal ||
+	if (m_new_strip) {
-        !m_new_strip) {
+		m_new_strip->removeTerminals(m_terminal);
-        return;
     }
-    m_new_strip->removeTerminal(m_terminal);
 }
 
 /**
@@ -67,11 +81,9 @@ void AddTerminalToStripCommand::undo()
  */
 void AddTerminalToStripCommand::redo()
 {
-    if (!m_terminal ||
+	if (m_new_strip) {
-        !m_new_strip) {
+		m_new_strip->addTerminals(m_terminal);
-        return;
     }
-    m_new_strip->addTerminal(m_terminal);
 }
 
 /**
@@ -83,38 +95,29 @@ void AddTerminalToStripCommand::redo()
 RemoveTerminalFromStripCommand::RemoveTerminalFromStripCommand(QSharedPointer<PhysicalTerminal> terminal,
 															   TerminalStrip *strip,
 															   QUndoCommand *parent) :
-	QUndoCommand(parent),
+	QUndoCommand{parent},
-	m_terminals(terminal->realTerminals()),
+	m_strip{strip}
-	m_strip(strip)
+{
-{	
+	m_terminals.append(terminal->realTerminals());
-	QString t_label;
+	setCommandTitle();
-	for (const auto &real_t : m_terminals) {
+}
-		if (!t_label.isEmpty())
+
-			t_label.append(", ");
+RemoveTerminalFromStripCommand::RemoveTerminalFromStripCommand(const QVector<QSharedPointer<PhysicalTerminal> > &phy_t_vector,
-		t_label.append(real_t->label());
+															   TerminalStrip *strip,
+															   QUndoCommand *parent):
+	QUndoCommand{parent},
+	m_strip{strip}
+{
+	for (const auto &phy_t : phy_t_vector) {
+		m_terminals.append(phy_t->realTerminals());
 	}
-
+	setCommandTitle();
-	auto strip_name = strip->name();
-
-	auto str_1 = t_label.isEmpty() ? QObject::tr("Enlever une borne") :
-									 QObject::tr("Enlever la borne %1").arg(t_label);
-
-	auto str_2 = strip_name.isEmpty() ? QObject::tr("d'un groupe de bornes") :
-										QObject::tr("du groupe de bornes %1").arg(strip_name);
-	setText(str_1 + " " + str_2);
 }
 
 void RemoveTerminalFromStripCommand::undo()
 {
-	if (m_strip)
+	if (m_strip) {
-	{
+		m_strip->addAndGroupTerminals(m_terminals);
-		for (const auto &real_t : m_terminals) {
-			m_strip->addTerminal(real_t);
-		}
-		auto phy_t = m_terminals.first()->physicalTerminal();
-		if (phy_t) {
-			m_strip->groupTerminals(phy_t, m_terminals);
-		}
 	}
 }
 
@@ -122,12 +125,27 @@ void RemoveTerminalFromStripCommand::redo()
 {
 	if (m_strip)
 	{
-		for (const auto & real_t : m_terminals) {
+		QVector<QSharedPointer<RealTerminal>> real_t;
-			m_strip->removeTerminal(real_t);
+		for (const auto &real_t_vector : qAsConst(m_terminals)) {
+			real_t.append(real_t_vector);
 		}
+
+		m_strip->removeTerminals(real_t);
 	}
 }
 
+void RemoveTerminalFromStripCommand::setCommandTitle()
+{
+	const auto strip_name = m_strip->name();
+
+	const auto str_1 = m_terminals.size()>1 ? QObject::tr("Enlever %1 bornes").arg(m_terminals.size()):
+											  QObject::tr("Enlever une borne");
+
+	const auto str_2 = strip_name.isEmpty() ? QObject::tr("d'un groupe de bornes") :
+											  QObject::tr("du groupe de bornes %1").arg(strip_name);
+	setText(str_1 + " " + str_2);
+}
+
 /**
  * @brief MoveTerminalCommand::MoveTerminalCommand
  * @param terminal
@@ -137,10 +155,10 @@ void RemoveTerminalFromStripCommand::redo()
  */
 MoveTerminalCommand::MoveTerminalCommand(QSharedPointer<PhysicalTerminal> terminal, TerminalStrip *old_strip,
 										 TerminalStrip *new_strip, QUndoCommand *parent) :
-	QUndoCommand (parent),
+	QUndoCommand {parent},
-	m_terminal(terminal),
+	m_terminal {terminal},
-	m_old_strip(old_strip),
+	m_old_strip {old_strip},
-	m_new_strip(new_strip)
+	m_new_strip {new_strip}
 {
 	QString t_label;
 	for (auto real_t : terminal->realTerminals()) {
@@ -163,28 +181,45 @@ MoveTerminalCommand::MoveTerminalCommand(QSharedPointer<PhysicalTerminal> termin
 	setText(str_1 + " " + str_2 + " " + str_3);
 }
 
+MoveTerminalCommand::MoveTerminalCommand(QVector<QSharedPointer<PhysicalTerminal>> terminals, TerminalStrip *old_strip,
+										 TerminalStrip *new_strip, QUndoCommand *parent) :
+	QUndoCommand {parent},
+	m_terminal {terminals},
+	m_old_strip {old_strip},
+	m_new_strip {new_strip}
+
+{
+	const auto strip_name = old_strip->name();
+	const auto new_strip_name = new_strip->name();
+
+	const auto str_1 = m_terminal.size() > 1 ? QObject::tr("Déplacer des bornes") :
+											   QObject::tr("Déplacer une borne");
+
+	const auto str_2 = strip_name.isEmpty() ? QObject::tr(" d'un groupe de bornes") :
+											  QObject::tr(" du groupe de bornes %1").arg(strip_name);
+
+	const auto str_3 = new_strip_name.isEmpty() ? QObject::tr("vers un groupe de bornes") :
+												  QObject::tr("vers le groupe de bornes %1").arg(new_strip_name);
+
+	setText(str_1 + " " + str_2 + " " + str_3);
+}
+
 void MoveTerminalCommand::undo()
 {
-	if (m_terminal)
+	if (m_new_strip) {
-	{
+		m_new_strip->removeTerminals(m_terminal);
-		if (m_new_strip) {
+	}
-			m_new_strip->removeTerminal(m_terminal);
+	if (m_old_strip) {
-		}
+		m_old_strip->addTerminals(m_terminal);
-		if (m_old_strip) {
-			m_old_strip->addTerminal(m_terminal);
-		}
 	}
 }
 
 void MoveTerminalCommand::redo()
 {
-	if (m_terminal)
+	if (m_old_strip) {
-	{
+		m_old_strip->removeTerminals(m_terminal);
-		if (m_old_strip) {
+	}
-			m_old_strip->removeTerminal(m_terminal);
+	if (m_new_strip) {
-		}
+		m_new_strip->addTerminals(m_terminal);
-		if (m_new_strip) {
-			m_new_strip->addTerminal(m_terminal);
-		}
 	}
 }

sources/TerminalStrip/UndoCommand/addterminaltostripcommand.h

@@ -38,13 +38,14 @@ class AddTerminalToStripCommand : public QUndoCommand
 {
     public:
 		AddTerminalToStripCommand(QSharedPointer<RealTerminal> terminal, TerminalStrip *strip, QUndoCommand *parent = nullptr);
+		AddTerminalToStripCommand(QVector<QSharedPointer<RealTerminal>> terminals, TerminalStrip *strip, QUndoCommand *parent = nullptr);
         ~AddTerminalToStripCommand() override;
 
         void undo() override;
         void redo() override;
 
     private:
-		QSharedPointer<RealTerminal> m_terminal;
+		QVector<QSharedPointer<RealTerminal>> m_terminal;
         QPointer<TerminalStrip> m_new_strip;
 };
 
@@ -57,13 +58,17 @@ class RemoveTerminalFromStripCommand : public QUndoCommand
 {
 	public:
 		RemoveTerminalFromStripCommand (QSharedPointer<PhysicalTerminal> terminal, TerminalStrip *strip, QUndoCommand *parent = nullptr);
+		RemoveTerminalFromStripCommand (const QVector<QSharedPointer<PhysicalTerminal>> &phy_t_vector, TerminalStrip *strip, QUndoCommand *parent = nullptr);
 		~RemoveTerminalFromStripCommand() override {}
 
 		void undo() override;
 		void redo() override;
 
 	private:
-		QVector<QSharedPointer<RealTerminal>> m_terminals;
+		void setCommandTitle();
+
+	private:
+		QVector<QVector<QSharedPointer<RealTerminal>>> m_terminals;
 		QPointer<TerminalStrip> m_strip;
 };
 
@@ -72,12 +77,14 @@ class MoveTerminalCommand : public QUndoCommand
 	public:
 		MoveTerminalCommand (QSharedPointer<PhysicalTerminal> terminal, TerminalStrip *old_strip,
 							 TerminalStrip *new_strip, QUndoCommand *parent = nullptr);
+		MoveTerminalCommand (QVector<QSharedPointer<PhysicalTerminal>> terminals, TerminalStrip *old_strip,
+							 TerminalStrip *new_strip, QUndoCommand *parent = nullptr);
 
 		void undo() override;
 		void redo() override;
 
 	private:
-		const QSharedPointer<PhysicalTerminal> m_terminal;
+		const QVector<QSharedPointer<PhysicalTerminal>> m_terminal;
 		QPointer<TerminalStrip> m_old_strip, m_new_strip;
 
 };

sources/TerminalStrip/realterminal.cpp

@@ -19,6 +19,7 @@
 #include "terminalstrip.h"
 #include "../qetgraphicsitem/terminalelement.h"
 #include "physicalterminal.h"
+#include "../qetgraphicsitem/conductor.h"
 
 /**
  * @brief RealTerminal
@@ -175,6 +176,13 @@ QString RealTerminal::cableWire() const {
  * @return
  */
 QString RealTerminal::conductor() const {
+	if (m_element)
+	{
+		const auto conductors_{m_element->conductors()};
+		if (conductors_.size()) {
+			return conductors_.first()->properties().text;
+		}
+	}
 	return QString();
 }
 

sources/TerminalStrip/terminalstrip.cpp

@@ -121,6 +121,62 @@ bool TerminalStrip::addTerminal(QSharedPointer<RealTerminal> real_t)
 	return true;
 }
 
+/**
+ * @brief TerminalStrip::addTerminals
+ * Add terminal in @a real_t_vector to this terminal
+ * @param real_t_vector
+ */
+void TerminalStrip::addTerminals(QVector<QSharedPointer<RealTerminal>> real_t_vector)
+{
+	bool added_{false};
+	for (const auto &real_t : real_t_vector)
+	{
+		if (real_t->parentStrip()) {
+			continue;
+		}
+
+		auto raw_phy_ptr = new PhysicalTerminal(this, QVector<QSharedPointer<RealTerminal>>{real_t});
+		m_physical_terminals.append(raw_phy_ptr->sharedRef());
+		added_ = true;
+	}
+
+	if (added_) {
+		emit orderChanged();
+	}
+}
+
+/**
+ * @brief TerminalStrip::addAndGroupTerminals
+ * For each real terminals of second vector, add it to terminal strip and group
+ * them together
+ * @param real_t_vector
+ */
+void TerminalStrip::addAndGroupTerminals(const QVector<QVector<QSharedPointer<RealTerminal>>> &real_t_vector)
+{
+	QVector<QSharedPointer<RealTerminal>> vector_;
+	bool added_{false};
+
+	for (const auto &t_vector : real_t_vector)
+	{
+		vector_.clear();
+		for (const auto &real_t : t_vector)
+		{
+			if (real_t->parentStrip()) {
+				continue;
+			}
+			vector_.append(real_t);
+		}
+
+		auto raw_phy_ptr = new PhysicalTerminal(this, vector_);
+		m_physical_terminals.append(raw_phy_ptr->sharedRef());
+		added_ = true;
+	}
+
+	if (added_) {
+		emit orderChanged();
+	}
+}
+
 bool TerminalStrip::removeTerminal(QSharedPointer<RealTerminal> real_t)
 {
 	if (real_t->parentStrip() != this) {
@@ -145,6 +201,39 @@ bool TerminalStrip::removeTerminal(QSharedPointer<RealTerminal> real_t)
 	return false;
 }
 
+/**
+ * @brief TerminalStrip::removeTerminals
+ * Remove terminals in @a real_t_vector from this terminal strip
+ * @param real_t_vector
+ */
+void TerminalStrip::removeTerminals(QVector<QSharedPointer<RealTerminal>> real_t_vector)
+{
+	bool removed_{false};
+	for (const auto &real_t : real_t_vector)
+	{
+		if (real_t->parentStrip() != this) {
+			continue;
+		}
+
+		if (auto bridge_ = real_t->bridge()) {
+			bridge_->removeTerminal(real_t);
+		}
+
+		if (auto phy_t = real_t->physicalTerminal())
+		{
+			phy_t->removeTerminal(real_t);
+			if (phy_t->realTerminalCount() == 0) {
+				m_physical_terminals.removeOne(phy_t);
+			}
+			removed_ = true;
+		}
+	}
+
+	if (removed_) {
+		emit orderChanged();
+	}
+}
+
 /**
  * @brief TerminalStrip::addTerminal
  * Add terminal to this terminal strip
@@ -225,6 +314,25 @@ bool TerminalStrip::addTerminal(QSharedPointer<PhysicalTerminal> phy_t)
 
 }
 
+void TerminalStrip::addTerminals(QVector<QSharedPointer<PhysicalTerminal> > phy_t_vector)
+{
+	bool added_{false};
+	for (const auto &phy_t : phy_t_vector)
+	{
+		if (phy_t->terminalStrip()) {
+			continue;
+		}
+
+		m_physical_terminals.append(phy_t);
+		phy_t->setParentStrip(this);
+		added_ = true;
+	}
+
+	if (added_) {
+		emit orderChanged();
+	}
+}
+
 /**
  * @brief TerminalStrip::removeTerminal
  * Remove @a phy_t from this terminal strip.
@@ -250,6 +358,29 @@ bool TerminalStrip::removeTerminal(QSharedPointer<PhysicalTerminal> phy_t)
 	return false;
 }
 
+void TerminalStrip::removeTerminals(QVector<QSharedPointer<PhysicalTerminal> > phy_t_vector)
+{
+	bool removed_{false};
+	for (const auto &phy_t : phy_t_vector)
+	{
+		if (m_physical_terminals.removeOne(phy_t))
+		{
+			for (const auto &real_t : phy_t->realTerminals()) {
+				if (auto bridge_ = real_t->bridge()) {
+					bridge_->removeTerminal(real_t);
+				}
+			}
+
+			phy_t->setParentStrip(nullptr);
+			removed_ = true;
+		}
+	}
+
+	if (removed_) {
+		emit orderChanged();
+	}
+}
+
 /**
  * @brief TerminalStrip::pos
  * @param terminal

sources/TerminalStrip/terminalstrip.h

@@ -78,12 +78,17 @@ class TerminalStrip : public QObject
 		TerminalStripData data() const;
 		void setData(const TerminalStripData &data);
 
-		bool addTerminal    (QSharedPointer<RealTerminal> real_t);
+		bool addTerminal (QSharedPointer<RealTerminal> real_t);
+		void addTerminals (QVector<QSharedPointer<RealTerminal>> real_t_vector);
+		void addAndGroupTerminals (const QVector<QVector<QSharedPointer<RealTerminal>>> &real_t_vector);
 		bool removeTerminal (QSharedPointer<RealTerminal> real_t);
+		void removeTerminals (QVector<QSharedPointer<RealTerminal>> real_t_vector);
 		bool addTerminal    (Element *terminal);
 		bool removeTerminal (Element *terminal);
 		bool addTerminal   (QSharedPointer<PhysicalTerminal> phy_t);
-		bool removeTerminal(QSharedPointer<PhysicalTerminal> phy_t);
+		void addTerminals (QVector<QSharedPointer<PhysicalTerminal>> phy_t_vector);
+		bool removeTerminal (QSharedPointer<PhysicalTerminal> phy_t);
+		void removeTerminals (QVector<QSharedPointer<PhysicalTerminal>> phy_t_vector);
 
 		int pos(const QSharedPointer<PhysicalTerminal> &terminal) const;
 		int physicalTerminalCount() const;

sources/TerminalStrip/ui/freeterminaleditor.cpp

@@ -239,12 +239,7 @@ void FreeTerminalEditor::on_m_move_pb_clicked()
 		return;
 	}
 
-		//Apply action with an undo command
+	m_project->undoStack()->push(new AddTerminalToStripCommand(real_t_vector, terminal_strip));
-	auto parent_undo = new QUndoCommand(tr("Déplacer des bornes à un groupe de bornes"));
-	for (const auto &rt_ : real_t_vector) {
-		new AddTerminalToStripCommand(rt_, terminal_strip, parent_undo);
-	}
-	m_project->undoStack()->push(parent_undo);
 
 	reload();
 }

sources/TerminalStrip/ui/freeterminalmodel.cpp

@@ -22,6 +22,7 @@
 #include "../../utils/qetutils.h"
 #include "../../qetgraphicsitem/terminalelement.h"
 #include "../realterminal.h"
+#include "../../qetinformation.h"
 
 const int LABEL_CELL = 0;
 const int XREF_CELL = 1;
@@ -29,7 +30,7 @@ const int TYPE_CELL = 2;
 const int FUNCTION_CELL = 3;
 const int LED_CELL = 4;
 
-const int ROW_COUNT = 5;
+const int COLUMN_COUNT = 5;
 
 static QVector<bool> UNMODIFIED_CELL_VECTOR{false, false, false, false, false};
 
@@ -79,7 +80,7 @@ int FreeTerminalModel::rowCount(const QModelIndex &parent) const
 int FreeTerminalModel::columnCount(const QModelIndex &parent) const
 {
 	Q_UNUSED(parent)
-	return ROW_COUNT;
+	return COLUMN_COUNT;
 }
 
 /**
@@ -310,7 +311,8 @@ void FreeTerminalModel::fillTerminalVector()
 	std::sort(free_terminal_vector.begin(), free_terminal_vector.end(),
 			  [](TerminalElement *a, TerminalElement *b)
 	{
-		return QETUtils::sortBeginIntString(a->actualLabel(), b->actualLabel());
+		return QETUtils::sortBeginIntString(a->elementData().m_informations.value(QETInformation::ELMT_LABEL).toString(),
+											b->elementData().m_informations.value(QETInformation::ELMT_LABEL).toString());
 	});
 
 	for (const auto &terminal_ : free_terminal_vector) {

sources/TerminalStrip/ui/terminalstripeditor.cpp

@@ -709,22 +709,15 @@ void TerminalStripEditor::on_m_move_to_pb_clicked()
 		return;
 	}
 
-	auto undo_stack{m_current_strip->project()->undoStack()};
 	const auto uuid_{ui->m_move_to_cb->currentData().toUuid()};
 		//Uuid is null we move the selected terminal to indepandant terminal
-	if (uuid_.isNull())
+	if (uuid_.isNull()) {
-	{
+		m_current_strip->project()->undoStack()->push(new RemoveTerminalFromStripCommand(phy_vector, m_current_strip));
-		 undo_stack->beginMacro(tr("Retirer des bornes d'un bornier"));
-		 for (const auto &phy_ : phy_vector) {
-			 undo_stack->push(new RemoveTerminalFromStripCommand(phy_, m_current_strip));
-		 }
-		 undo_stack->endMacro();
 	}
 	else
 	{
 		TerminalStrip *receiver_strip{nullptr};
-		const auto strip_vector = m_current_strip->project()->terminalStrip();
+		for (const auto &strip_ : m_current_strip->project()->terminalStrip())
-		for (const auto &strip_ : strip_vector)
 		{
 			if (strip_->uuid() == uuid_) {
 				receiver_strip = strip_;
@@ -736,11 +729,7 @@ void TerminalStripEditor::on_m_move_to_pb_clicked()
 			return;
 		}
 
-		undo_stack->beginMacro(tr("Déplacer des bornes d'un bornier à un autre"));
+		m_current_strip->project()->undoStack()->push(new MoveTerminalCommand(phy_vector, m_current_strip, receiver_strip));
-		for (const auto &phy_ : phy_vector) {
-			undo_stack->push(new MoveTerminalCommand(phy_, m_current_strip, receiver_strip));
-		}
-		undo_stack->endMacro();
 	}
 }
 

sources/TerminalStrip/ui/terminalstripmodel.cpp

@@ -39,15 +39,15 @@ const int LEVEL_1_CELL = 3;
 const int LEVEL_2_CELL = 4;
 const int LEVEL_3_CELL = 5;
 const int LABEL_CELL = 6;
-const int XREF_CELL = 7;
+const int CONDUCTOR_CELL = 7;
-const int CABLE_CELL = 8;
+const int XREF_CELL = 8;
-const int CABLE_WIRE_CELL = 9;
+const int CABLE_CELL = 9;
-const int TYPE_CELL = 10;
+const int CABLE_WIRE_CELL = 10;
-const int FUNCTION_CELL = 11;
+const int TYPE_CELL = 11;
-const int LED_CELL = 12;
+const int FUNCTION_CELL = 12;
-const int CONDUCTOR_CELL = 13;
+const int LED_CELL = 13;
 
-const int ROW_COUNT = 13;
+const int COLUMN_COUNT = 14;
 
 static QVector<bool> UNMODIFIED_CELL_VECTOR{false, false, false, false, false, false, false, false, false, false, false, false, false, false};
 
@@ -86,13 +86,13 @@ TerminalStripModel::Column TerminalStripModel::columnTypeForIndex(const QModelIn
 			case 4 : return Level2;
 			case 5 : return Level3;
 			case 6 : return Label;
-			case 7 : return XRef;
+			case 7 : return Conductor;
-			case 8 : return Cable;
+			case 8 : return XRef;
-			case 9 : return CableWire;
+			case 9 : return Cable;
-			case 10 : return Type;
+			case 10 : return CableWire;
-			case 11 : return Function;
+			case 11 : return Type;
-			case 12 : return Led;
+			case 12 : return Function;
-			case 13 : return Conductor;
+			case 13 : return Led;
 			default : return Invalid;
 		}
 	}
@@ -146,7 +146,7 @@ int TerminalStripModel::rowCount(const QModelIndex &parent) const
 int TerminalStripModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
-	return ROW_COUNT;
+	return COLUMN_COUNT;
 }
 
 QVariant TerminalStripModel::data(const QModelIndex &index, int role) const
@@ -164,12 +164,12 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const
 			case POS_CELL :        return physicalDataAtIndex(index.row()).pos_;
 			case LEVEL_CELL :      return mrtd.level_;
 			case LABEL_CELL :      return mrtd.label_;
+			case CONDUCTOR_CELL :  return mrtd.conductor_;
 			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();
 		}
 	}
@@ -287,13 +287,13 @@ QVariant TerminalStripModel::headerData(int section, Qt::Orientation orientation
 				case LEVEL_2_CELL:    return QStringLiteral("2");
 				case LEVEL_3_CELL:    return QStringLiteral("3");
 				case LABEL_CELL:      return tr("Label");
+				case CONDUCTOR_CELL:  return tr("Numéro de conducteur");
 				case XREF_CELL:       return tr("Référence croisé");
 				case CABLE_CELL:      return tr("Câble");
 				case CABLE_WIRE_CELL: return tr("Couleur / numéro de fil câble");
 				case TYPE_CELL:       return tr("Type");
 				case FUNCTION_CELL :  return tr("Fonction");
 				case LED_CELL:        return tr("led");
-				case CONDUCTOR_CELL:  return tr("Numéro de conducteur");
 				default : return QVariant();
 			}
 		}

sources/TerminalStrip/ui/terminalstripmodel.h

@@ -54,13 +54,13 @@ class TerminalStripModel : public QAbstractTableModel
 			Level2 = 4,
 			Level3 = 5,
 			Label = 6,
-			XRef = 7,
+			Conductor = 7,
-			Cable = 8,
+			XRef = 8,
-			CableWire = 9,
+			Cable = 9,
-			Type = 10,
+			CableWire = 10,
-			Function = 11,
+			Type = 11,
-			Led = 12,
+			Function = 12,
-			Conductor = 13,
+			Led = 13,
 			Invalid = 99
 		};
 

sources/TerminalStrip/ui/terminalstriptreedockwidget.cpp

@@ -26,6 +26,7 @@
 #include "../realterminal.h"
 #include "../../qetgraphicsitem/terminalelement.h"
 #include "../terminalstrip.h"
+#include "../../qetinformation.h"
 
 TerminalStripTreeDockWidget::TerminalStripTreeDockWidget(QETProject *project, QWidget *parent) :
 	QDockWidget(parent),
@@ -176,17 +177,26 @@ void TerminalStripTreeDockWidget::on_m_tree_view_currentItemChanged(QTreeWidgetI
 	}
 
 	TerminalStrip *strip_ = nullptr;
-	if (current->type() == Strip) {
+	bool current_is_free{false};
+	const auto current_type{current->type()};
+	if (current_type == Strip) {
 		strip_ = m_item_strip_H.value(current);
 	}
-	else if (current->type() == Terminal
+	else if (current_type == Terminal && current->parent())
-			 && current->parent()
+	{
-			 && current->parent()->type() == Strip) {
+		const auto parent_type{current->parent()->type()};
-		strip_ = m_item_strip_H.value(current->parent());
+		if (parent_type == Strip) {
+			strip_ = m_item_strip_H.value(current->parent());
+		} else if (parent_type == FreeTerminal) {
+			current_is_free = true;
+		}
 	}
 
 	if (strip_ != m_current_strip) {
 		setCurrentStrip(strip_);
+	} else if (current_is_free != m_current_is_free_terminal) {
+		m_current_is_free_terminal = current_is_free;
+		emit currentStripChanged(nullptr);
 	}
 }
 
@@ -305,8 +315,11 @@ void TerminalStripTreeDockWidget::addFreeTerminal()
 	}
 
 		//Sort the terminal element by label
-	std::sort(vector_.begin(), vector_.end(), [](TerminalElement *a, TerminalElement *b) {
+	std::sort(vector_.begin(), vector_.end(), [](TerminalElement *a, TerminalElement *b)
-		return a->actualLabel() < b->actualLabel();
+	{
+		return a->elementData().m_informations.value(QETInformation::ELMT_LABEL).toString()
+				<
+				b->elementData().m_informations.value(QETInformation::ELMT_LABEL).toString();
 	});
 
 	auto free_terminal_item = ui->m_tree_view->topLevelItem(1);

sources/TerminalStrip/ui/terminalstriptreedockwidget.h

@@ -78,6 +78,7 @@ class TerminalStripTreeDockWidget : public QDockWidget
 		QHash<QUuid, QSharedPointer<RealTerminal>> m_uuid_terminal_H;
 		QHash<QUuid, QPointer<TerminalStrip>> m_uuid_strip_H;
 		QVector<QMetaObject::Connection> m_strip_changed_connection;
+		bool m_current_is_free_terminal{false};
 };
 
 #endif // TERMINALSTRIPTREEDOCKWIDGET_H

sources/elementprovider.cpp

@@ -198,14 +198,17 @@ QVector<TerminalElement *> ElementProvider::freeTerminal() const
 {
 	QVector<TerminalElement *> vector_;
 
-	for (const auto diagram : m_diagram_list) {
+	for (const auto &diagram : qAsConst(m_diagram_list))
-		DiagramContent dc(diagram, false);
+	{
-		for (const auto element : qAsConst(dc.m_elements)) {
+		const auto elmt_list{diagram->elements()};
+
+		for (const auto element : elmt_list)
+		{
 			if (element->elementData().m_type == ElementData::Terminale)
 			{
-				auto te = static_cast<TerminalElement *>(element);
+				const auto te{static_cast<TerminalElement *>(element)};
 				if (!te->parentTerminalStrip()) {
-					vector_.append(static_cast<TerminalElement *>(element));
+					vector_.append(te);
 				}
 			}
 		}