Improve execution time of some actions.

Improve the execution time when we add, change or remove
several terminals to/from terminal strip.

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),
-    m_terminal(terminal),
-	m_new_strip(strip)
+	QUndoCommand{parent},
+	m_terminal{terminal},
+	m_new_strip{strip}
 {
-	auto t_label = terminal->label();
-    auto ts_name = strip->name();
+	const auto t_label = terminal->label();
+	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 ||
-        !m_new_strip) {
-        return;
+	if (m_new_strip) {
+		m_new_strip->removeTerminals(m_terminal);
     }
-    m_new_strip->removeTerminal(m_terminal);
 }
 
 /**
@@ -67,11 +81,9 @@ void AddTerminalToStripCommand::undo()
  */
 void AddTerminalToStripCommand::redo()
 {
-    if (!m_terminal ||
-        !m_new_strip) {
-        return;
+	if (m_new_strip) {
+		m_new_strip->addTerminals(m_terminal);
     }
-    m_new_strip->addTerminal(m_terminal);
 }
 
 /**
@@ -83,38 +95,29 @@ void AddTerminalToStripCommand::redo()
 RemoveTerminalFromStripCommand::RemoveTerminalFromStripCommand(QSharedPointer<PhysicalTerminal> terminal,
 															   TerminalStrip *strip,
 															   QUndoCommand *parent) :
-	QUndoCommand(parent),
-	m_terminals(terminal->realTerminals()),
-	m_strip(strip)
-{	
-	QString t_label;
-	for (const auto &real_t : m_terminals) {
-		if (!t_label.isEmpty())
-			t_label.append(", ");
-		t_label.append(real_t->label());
+	QUndoCommand{parent},
+	m_strip{strip}
+{
+	m_terminals.append(terminal->realTerminals());
+	setCommandTitle();
+}
+
+RemoveTerminalFromStripCommand::RemoveTerminalFromStripCommand(const QVector<QSharedPointer<PhysicalTerminal> > &phy_t_vector,
+															   TerminalStrip *strip,
+															   QUndoCommand *parent):
+	QUndoCommand{parent},
+	m_strip{strip}
+{
+	for (const auto &phy_t : phy_t_vector) {
+		m_terminals.append(phy_t->realTerminals());
 	}
-
-	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);
+	setCommandTitle();
 }
 
 void RemoveTerminalFromStripCommand::undo()
 {
-	if (m_strip)
-	{
-		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);
-		}
+	if (m_strip) {
+		m_strip->addAndGroupTerminals(m_terminals);
 	}
 }
 
@@ -122,12 +125,27 @@ void RemoveTerminalFromStripCommand::redo()
 {
 	if (m_strip)
 	{
-		for (const auto & real_t : m_terminals) {
-			m_strip->removeTerminal(real_t);
+		QVector<QSharedPointer<RealTerminal>> 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),
-	m_terminal(terminal),
-	m_old_strip(old_strip),
-	m_new_strip(new_strip)
+	QUndoCommand {parent},
+	m_terminal {terminal},
+	m_old_strip {old_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->removeTerminal(m_terminal);
-		}
-		if (m_old_strip) {
-			m_old_strip->addTerminal(m_terminal);
-		}
+	if (m_new_strip) {
+		m_new_strip->removeTerminals(m_terminal);
+	}
+	if (m_old_strip) {
+		m_old_strip->addTerminals(m_terminal);
 	}
 }
 
 void MoveTerminalCommand::redo()
 {
-	if (m_terminal)
-	{
-		if (m_old_strip) {
-			m_old_strip->removeTerminal(m_terminal);
-		}
-		if (m_new_strip) {
-			m_new_strip->addTerminal(m_terminal);
-		}
+	if (m_old_strip) {
+		m_old_strip->removeTerminals(m_terminal);
+	}
+	if (m_new_strip) {
+		m_new_strip->addTerminals(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/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
-	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);
+	m_project->undoStack()->push(new AddTerminalToStripCommand(real_t_vector, terminal_strip));
 
 	reload();
 }

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())
-	{
-		 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();
+	if (uuid_.isNull()) {
+		m_current_strip->project()->undoStack()->push(new RemoveTerminalFromStripCommand(phy_vector, m_current_strip));
 	}
 	else
 	{
 		TerminalStrip *receiver_strip{nullptr};
-		const auto strip_vector = m_current_strip->project()->terminalStrip();
-		for (const auto &strip_ : strip_vector)
+		for (const auto &strip_ : m_current_strip->project()->terminalStrip())
 		{
 			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"));
-		for (const auto &phy_ : phy_vector) {
-			undo_stack->push(new MoveTerminalCommand(phy_, m_current_strip, receiver_strip));
-		}
-		undo_stack->endMacro();
+		m_current_strip->project()->undoStack()->push(new MoveTerminalCommand(phy_vector, m_current_strip, receiver_strip));
 	}
 }