Merge branch 'terminal_strip'

sources/TerminalStrip/GraphicsItem/demoterminalstrip.cpp

@@ -35,13 +35,14 @@ namespace TerminalStripDrawer
 			const QUuid m_uuid;
 	};
 
-	class DemoRealTerminal : public AbstractRealTerminalInterface
-	{
-		public:
-			DemoRealTerminal(const QString &label, const QUuid &bridge) :
+    class DemoRealTerminal : public AbstractRealTerminalInterface
+    {
+        public:
+			DemoRealTerminal(const QString &label, const QString &xref, const QUuid &bridge) :
 				m_label { label },
+				m_xref{ xref },
 				m_bridge { bridge }
-			{}
+            {}
 
 			QString label() const override {
 				return m_label;
@@ -55,10 +56,14 @@ namespace TerminalStripDrawer
 				return new DemoBridge { m_bridge };
 			}
 
-		private:
-			QString m_label;
-			QUuid m_bridge;
-	};
+			QString xref() const override {
+				return m_xref;
+			}
+
+        private:
+			QString m_label, m_xref;
+            QUuid m_bridge;
+    };
 
 	class DemoPhysicalTerminal : public AbstractPhysicalTerminalInterface
 	{
@@ -102,51 +107,63 @@ namespace TerminalStripDrawer
 		QVector <QSharedPointer<AbstractRealTerminalInterface>> real_terminals_vector;
 
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("24vdc"),
-														lvl_1)};
+																			   new DemoRealTerminal( QStringLiteral("24vdc"),
+																									QStringLiteral("1_A1"),
+																									lvl_1)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("0vdc"),
-														lvl_2)};
+																			   new DemoRealTerminal( QStringLiteral("0vdc"),
+																									QStringLiteral("1_A2"),
+																									lvl_2)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("signal"),
-														lvl_3)};
+																			   new DemoRealTerminal( QStringLiteral("signal"),
+																									QStringLiteral("1_A3"),
+																									lvl_3)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("teach"),
-														lvl_4)};
+																			   new DemoRealTerminal( QStringLiteral("teach"),
+																									QStringLiteral("1_A4"),
+																									lvl_4)};
 		m_physical_terminal << QSharedPointer<AbstractPhysicalTerminalInterface> {
-							   new DemoPhysicalTerminal {real_terminals_vector}};
+																				 new DemoPhysicalTerminal {real_terminals_vector}};
 
-		real_terminals_vector.clear();
+        real_terminals_vector.clear();
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("24vdc"),
-														lvl_1)};
+																			   new DemoRealTerminal( QStringLiteral("24vdc"),
+																									QStringLiteral("2_A1"),
+																									lvl_1)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("0vdc"),
-														lvl_2)};
+																			   new DemoRealTerminal( QStringLiteral("0vdc"),
+																									QStringLiteral("2_A2"),
+																									lvl_2)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("signal"),
-														lvl_3)};
+																			   new DemoRealTerminal( QStringLiteral("signal"),
+																									QStringLiteral("2_A3"),
+																									lvl_3)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("teach"),
-														lvl_4)};
+																			   new DemoRealTerminal( QStringLiteral("teach"),
+																									QStringLiteral("2_A4"),
+																									lvl_4)};
 		m_physical_terminal << QSharedPointer<AbstractPhysicalTerminalInterface> {
-							   new DemoPhysicalTerminal {real_terminals_vector}};
+																				 new DemoPhysicalTerminal {real_terminals_vector}};
 
-		real_terminals_vector.clear();
+
+        real_terminals_vector.clear();
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("24vdc"),
-														lvl_1)};
+																			   new DemoRealTerminal( QStringLiteral("24vdc"),
+																									QStringLiteral("3_A1"),
+																									lvl_1)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("0vdc"),
-														lvl_2)};
+																			   new DemoRealTerminal( QStringLiteral("0vdc"),
+																									QStringLiteral("3_A2"),
+																									lvl_2)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("signal"),
-														lvl_3)};
+																			   new DemoRealTerminal( QStringLiteral("signal"),
+																									QStringLiteral("3_A3"),
+																									lvl_3)};
 		real_terminals_vector << QSharedPointer<AbstractRealTerminalInterface> {
-								 new DemoRealTerminal( QStringLiteral("teach"),
-														lvl_4)};
+																			   new DemoRealTerminal( QStringLiteral("teach"),
+																									QStringLiteral("3_A4"),
+																									lvl_4)};
 		m_physical_terminal << QSharedPointer<AbstractPhysicalTerminalInterface> {
-							   new DemoPhysicalTerminal {real_terminals_vector}};
-	}
-
+																				 new DemoPhysicalTerminal {real_terminals_vector}};
+    }
 }

sources/TerminalStrip/GraphicsItem/properties/terminalstriplayoutpattern.cpp

@@ -16,16 +16,24 @@
 	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "terminalstriplayoutpattern.h"
-#include <QDebug>
+#include "../../../utils/qetutils.h"
 
 TerminalStripLayoutPattern::TerminalStripLayoutPattern()
 {
+    m_font.setPixelSize(15);
 	updateHeaderTextOption();
 	updateTerminalsTextOption();
 }
 
+/**
+ * @brief TerminalStripLayoutPattern::setHeaderTextAlignment
+ * Set text alignment to @param alignment. If alignment have no
+ * flag this function do nothing
+ * @param alignment
+ */
 void TerminalStripLayoutPattern::setHeaderTextAlignment(const Qt::Alignment &alignment)
 {
+    if (!alignment) return;
 	m_header_text_alignment = alignment;
 	updateHeaderTextOption();
 }
@@ -39,22 +47,61 @@ QTextOption TerminalStripLayoutPattern::headerTextOption() const {
 	return m_header_text_option;
 }
 
-void TerminalStripLayoutPattern::setTerminalsTextAlignment(const QVector<Qt::Alignment> &alignment)
+QFont TerminalStripLayoutPattern::font() const {
+    return m_font;
+}
+
+void TerminalStripLayoutPattern::setFont(const QFont &font) {
+    m_font = font;
+    QETUtils::pixelSizedFont(m_font);
+}
+
+/**
+ * @brief TerminalStripLayoutPattern::setTerminalsTextAlignment
+ * Set text alignment to @param alignment. If alignment have no
+ * flag this function do nothing
+ * @param alignment
+ */
+void TerminalStripLayoutPattern::setTerminalsTextAlignment(const Qt::Alignment &alignment)
 {
+    if (!alignment) return;
 	m_terminals_text_alignment = alignment;
 	updateTerminalsTextOption();
 }
 
-QVector<Qt::Alignment> TerminalStripLayoutPattern::terminalsTextAlignment() const
+Qt::Alignment TerminalStripLayoutPattern::terminalsTextAlignment() const
 {
 	return m_terminals_text_alignment;
 }
 
-QVector<QTextOption> TerminalStripLayoutPattern::terminalsTextOption() const
+QTextOption TerminalStripLayoutPattern::terminalsTextOption() const
 {
 	return m_terminals_text_option;
 }
 
+/**
+ * @brief TerminalStripLayoutPattern::setXrefTextAlignment
+ * Set text alignment to @param alignment. If alignment have no
+ * flag this function do nothing
+ * @param alignment
+ */
+void TerminalStripLayoutPattern::setXrefTextAlignment(const Qt::Alignment &alignment)
+{
+	if (!alignment) return;
+	m_xref_text_alignment = alignment;
+	updateTerminalsTextOption();
+}
+
+Qt::Alignment TerminalStripLayoutPattern::xrefTextAlignment() const
+{
+	return m_xref_text_alignment;
+}
+
+QTextOption TerminalStripLayoutPattern::xrefTextOption() const
+{
+	return m_xref_text_option;
+}
+
 void TerminalStripLayoutPattern::updateHeaderTextOption()
 {
 	m_header_text_option.setAlignment(m_header_text_alignment);
@@ -63,16 +110,9 @@ void TerminalStripLayoutPattern::updateHeaderTextOption()
 
 void TerminalStripLayoutPattern::updateTerminalsTextOption()
 {
-	if (m_terminals_text_option.size() ==
-		m_terminals_text_alignment.size())
-	{
-		for (auto i = 0 ; i<m_terminals_text_option.size() ; ++i)
-		{
-			m_terminals_text_option[i].setAlignment(m_terminals_text_alignment.at(i));
-			m_terminals_text_option[i].setWrapMode(QTextOption::WordWrap);
-		}
-	}
-	else {
-		qDebug() << "TerminalStripLayoutPattern::updateTerminalsTextOption() : Wrong vector size";
-	}
+    m_terminals_text_option.setAlignment(m_terminals_text_alignment);
+    m_terminals_text_option.setWrapMode(QTextOption::WordWrap);
+
+	m_xref_text_option.setAlignment(m_xref_text_alignment);
+	m_xref_text_option.setWrapMode(QTextOption::WordWrap);
 }

sources/TerminalStrip/GraphicsItem/properties/terminalstriplayoutpattern.h

@@ -18,6 +18,7 @@
 #ifndef TERMINALSTRIPLAYOUTPATTERN_H
 #define TERMINALSTRIPLAYOUTPATTERN_H
 
+#include <QFont>
 #include <QRect>
 #include <QSize>
 #include <QTextOption>
@@ -43,45 +44,46 @@ class TerminalStripLayoutPattern
 		TerminalStripLayoutPattern();
 
 			//Header of terminal strip
-		QRect m_header_rect{0,30,50,130};
+        QRectF m_header_rect{0,30,50,130};
 		Qt::Orientation m_header_text_orientation{Qt::Horizontal};
 		void setHeaderTextAlignment(const Qt::Alignment &alignment);
 		Qt::Alignment headerTextAlignment() const;
 		QTextOption headerTextOption() const;
 
 			//Spacer between the header and the terminals
-		QRect m_spacer_rect{0, 50, 10, 90};
+        QRectF m_spacer_rect{0, 50, 10, 90};
+
+            //Font
+        QFont font() const;
+        void setFont (const QFont &font);
 
 			//Terminals
-		QVector<QRect> m_terminal_rect
+        QVector<QRectF> m_terminal_rect
 		{
-			QRect{0, 0, 20, 190},
-			QRect{0, 10, 20, 170},
-			QRect{0, 20, 20, 150},
-			QRect{0, 30, 20, 130}
+            QRectF{0, 0, 20, 190},
+            QRectF{0, 10, 20, 170},
+            QRectF{0, 20, 20, 150},
+            QRectF{0, 30, 20, 130}
 		};
 
-		void setTerminalsTextAlignment(const QVector<Qt::Alignment> &alignment);
-		QVector<Qt::Alignment> terminalsTextAlignment() const;
-		QVector<QTextOption> terminalsTextOption() const;
+            //Terminal text
+        void setTerminalsTextAlignment(const Qt::Alignment &alignment);
+        Qt::Alignment terminalsTextAlignment() const;
+        QTextOption terminalsTextOption() const;
+        qreal m_terminals_text_height{50};
+        qreal m_terminals_text_y{35};
+        Qt::Orientation m_terminals_text_orientation {Qt::Vertical};
 
-		QVector<QRect> m_terminals_text_rect
-		{
-			QRect{0,35,20,50},
-			QRect{0,35,20,50},
-			QRect{0,35,20,50},
-			QRect{0,35,20,50}
-		};
-		QVector<Qt::Orientation> m_terminals_text_orientation
-		{
-			Qt::Vertical,
-			Qt::Vertical,
-			Qt::Vertical,
-			Qt::Vertical
-		};
+			//Xref text
+		void setXrefTextAlignment(const Qt::Alignment &alignment);
+		Qt::Alignment xrefTextAlignment() const;
+		QTextOption xrefTextOption() const;
+		qreal m_xref_text_height{60};
+		qreal m_xref_text_y{95};
+		Qt::Orientation m_xref_text_orientation {Qt::Vertical};
 
-		int m_bridge_point_d{5};
-		QVector<int> m_bridge_point_y_offset{50,70,90,110};
+        qreal m_bridge_point_d{5};
+        QVector<qreal> m_bridge_point_y_offset{50,70,90,110};
 
 		QUuid m_uuid{QUuid::createUuid()};
 		QString m_name;
@@ -90,24 +92,17 @@ class TerminalStripLayoutPattern
 		void updateHeaderTextOption();
 		void updateTerminalsTextOption();
 
-	private:
+    private:
+        QFont m_font;
 		Qt::Alignment m_header_text_alignment{Qt::AlignCenter};
 		QTextOption m_header_text_option;
 
-		QVector<Qt::Alignment> m_terminals_text_alignment
-		{
-			Qt::AlignRight | Qt::AlignVCenter,
-			Qt::AlignRight | Qt::AlignVCenter,
-			Qt::AlignRight | Qt::AlignVCenter,
-			Qt::AlignRight | Qt::AlignVCenter
-		};
-		QVector<QTextOption> m_terminals_text_option
-		{
-			QTextOption(),
-			QTextOption(),
-			QTextOption(),
-			QTextOption()
-		};
+		Qt::Alignment
+			m_terminals_text_alignment {Qt::AlignRight | Qt::AlignVCenter},
+			m_xref_text_alignment {Qt::AlignLeft | Qt::AlignVCenter};
+		QTextOption
+			m_terminals_text_option{QTextOption()},
+			m_xref_text_option{QTextOption()};
 };
 
 #endif // TERMINALSTRIPLAYOUTPATTERN_H

sources/TerminalStrip/GraphicsItem/terminalstripdrawer.cpp

@@ -16,6 +16,7 @@
 	along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "terminalstripdrawer.h"
+
 #include <QPainter>
 
 namespace TerminalStripDrawer {
@@ -42,12 +43,13 @@ void TerminalStripDrawer::setStrip(QSharedPointer<AbstractTerminalStripInterface
  */
 void TerminalStripDrawer::paint(QPainter *painter)
 {
-	if (m_strip && m_pattern)
-	{
-			//To draw text, QPainter need a Qrect. Instead of create an instance
-			//for each text, we re-use the same instance of QRect.
-		QRect text_rect;
-		painter->save();
+    if (m_strip && m_pattern)
+    {
+		m_united_xref_text_rect = QRectF();
+            //To draw text, QPainter need a Qrect. Instead of create an instance
+            //for each text, we re-use the same instance of QRect.
+        QRect text_rect;
+        painter->save();
 
 		auto pen_{painter->pen()};
 		pen_.setColor(Qt::black);
@@ -56,16 +58,20 @@ void TerminalStripDrawer::paint(QPainter *painter)
 		auto brush_ = painter->brush();
 		brush_.setColor(Qt::white);
 
-		painter->setPen(pen_);
-		painter->setBrush(brush_);
+        painter->setFont(m_pattern->font());
 
-		if (m_preview_draw)
-		{
-			painter->save();
-			painter->setPen(Qt::blue);
-			painter->drawRect(boundingRect());
-			painter->restore();
-		}
+        painter->setPen(pen_);
+        painter->setBrush(brush_);
+
+        if (m_preview_draw)
+        {
+            painter->save();
+            painter->setPen(Qt::blue);
+            painter->drawRect(boundingRect());
+            painter->drawLine(QPointF{boundingRect().left(), boundingRect().center().y()},
+                              QPointF{boundingRect().right(), boundingRect().center().y()});
+            painter->restore();
+        }
 
 			//Draw header
 		painter->drawRect(m_pattern->m_header_rect);
@@ -84,14 +90,13 @@ void TerminalStripDrawer::paint(QPainter *painter)
 			text_rect.setRect(0,0,m_pattern->m_header_rect.height(),m_pattern->m_header_rect.width());
 		}
 
-		const auto text_{m_strip->installation() + " " + m_strip->location() + " " + m_strip->name()};
-		painter->drawText(text_rect, text_, m_pattern->headerTextOption());
+        const auto text_{m_strip->installation() + " " + m_strip->location() + " " + m_strip->name()};
+        painter->drawText(text_rect, text_, m_pattern->headerTextOption());
 		painter->restore();
 
-			//Move painter pos to next drawing
-		painter->translate(m_pattern->m_header_rect.width(),0);
-
-		int x_offset{m_pattern->m_header_rect.width()};
+            //Move painter pos to next drawing
+        painter->translate(m_pattern->m_header_rect.width(),0);
+        qreal x_offset{m_pattern->m_header_rect.width()};
 
 			//Draw spacer
 		painter->drawRect(m_pattern->m_spacer_rect);
@@ -99,22 +104,30 @@ void TerminalStripDrawer::paint(QPainter *painter)
 		painter->translate(m_pattern->m_spacer_rect.width(),0);
 		x_offset += m_pattern->m_spacer_rect.width();
 
+            //Draw terminals
+        const auto terminals_text_orientation{m_pattern->m_terminals_text_orientation};
+        const auto terminals_text_option{m_pattern->terminalsTextOption()};
+        const auto terminals_text_height{m_pattern->m_terminals_text_height};
+        const auto terminals_text_y{m_pattern->m_terminals_text_y};
+        QRectF terminal_rect;
 
-			//Draw terminals
-		const auto terminals_text_rect{m_pattern->m_terminals_text_rect};
-		const auto terminals_text_orientation{m_pattern->m_terminals_text_orientation};
-		const auto terminals_text_option{m_pattern->terminalsTextOption()};
-		QRect terminal_rect;
+		const auto xref_text_orientation{m_pattern->m_xref_text_orientation};
+		const auto xref_text_option{m_pattern->xrefTextOption()};
+		const auto xref_text_height{m_pattern->m_xref_text_height};
+		const auto xref_text_y{m_pattern->m_xref_text_y};
+		QRectF xref_rect;
 
 		QHash<QUuid, QVector<QPointF>> bridges_anchor_points;
 
-			//Loop over physical terminals
-		for (const auto &physical_t : m_strip->physicalTerminal())
-		{
-				//Get the good offset according to how many level have the current physical terminal
-			const QVector<QSharedPointer<AbstractRealTerminalInterface>> real_terminal_vector{physical_t->realTerminals()};
-			const auto real_t_count{real_terminal_vector.size()};
-			const auto offset_{4 - real_t_count};
+		m_hovered_xref = hoverTerminal{};
+		int physical_index = 0;
+            //Loop over physical terminals
+        for (const auto &physical_t : m_strip->physicalTerminal())
+        {
+                //Get the good offset according to how many level have the current physical terminal
+            const QVector<QSharedPointer<AbstractRealTerminalInterface>> real_terminal_vector{physical_t->realTerminals()};
+            const auto real_t_count{real_terminal_vector.size()};
+            const auto offset_{4 - real_t_count};
 
 				//Loop over real terminals
 			for (auto i=0 ; i<real_t_count ; ++i)
@@ -124,45 +137,50 @@ void TerminalStripDrawer::paint(QPainter *painter)
 					break;
 				}
 
-				terminal_rect = m_pattern->m_terminal_rect[index_];
-					//Draw terminal rect
-				painter->drawRect(terminal_rect);
-					//Draw a stronger line if the current terminal have level
-					//and the current level is the first
-				if (real_t_count > 1 && i == 0)
-				{
-					painter->save();
-					pen_ = painter->pen();
-					pen_.setWidth(4);
-					pen_.setCapStyle(Qt::FlatCap);
-					painter->setPen(pen_);
-					const auto p1 { terminal_rect.topLeft() };
-						//We can't use terminal_rect.bottomLeft for p2 because
-						//the returned value deviate from the true value
-						//(see Qt documentation about QRect)
-					const QPoint p2 { p1.x(), p1.y() + terminal_rect.height() };
-					painter->drawLine(p1, p2);
-					painter->restore();
+                terminal_rect = m_pattern->m_terminal_rect[index_];
+                    //Draw terminal rect
+                painter->drawRect(terminal_rect);
+                    //Draw a stronger line if the current terminal have level
+                    //and the current level is the first
+                if (real_t_count > 1 && i == 0)
+                {
+                    painter->save();
+                    pen_ = painter->pen();
+                    pen_.setWidth(4);
+                    pen_.setCapStyle(Qt::FlatCap);
+                    painter->setPen(pen_);
+                    const auto p1 { terminal_rect.topLeft() };
+                        //We can't use terminal_rect.bottomLeft for p2 because
+                        //the returned value deviate from the true value
+                        //(see Qt documentation about QRect)
+                    const QPointF p2 { p1.x(), p1.y() + terminal_rect.height() };
+                    painter->drawLine(p1, p2);
+                    painter->restore();
+                }
+
+				if(m_preview_draw)
+                {
+                    painter->save();
+                    painter->setPen(Qt::yellow);
+                    painter->drawLine(QPointF{terminal_rect.x(), terminal_rect.y() + terminal_rect.height()/2},
+                                      QPointF{terminal_rect.width(), terminal_rect.y() + terminal_rect.height()/2});
+                    painter->restore();
 				}
 
-					//Draw text
-				painter->save();
-				if (terminals_text_orientation[index_] == Qt::Horizontal)
-				{
-					text_rect = terminals_text_rect[index_];
-				}
-				else
-				{
-					const auto rect_{terminals_text_rect[index_]};
-					painter->translate(rect_.bottomLeft());
-					painter->rotate(270);
-					text_rect.setRect(0, 0, rect_.height(), terminal_rect.width());
-				}
+                    //Draw text
+                painter->save();
+                text_rect.setRect(0, terminals_text_y, terminal_rect.width(), terminals_text_height);
+                if (terminals_text_orientation == Qt::Vertical)
+                {
+                    painter->translate(text_rect.bottomLeft());
+                    painter->rotate(270);
+                    text_rect.setRect(0, 0, text_rect.height(), text_rect.width());
+                }
 
-				const auto shared_real_terminal{real_terminal_vector[i]};
+                const auto shared_real_terminal{real_terminal_vector[i]};
 				painter->drawText(text_rect,
 								  shared_real_terminal ? shared_real_terminal->label() : QLatin1String(),
-								  terminals_text_option[index_]);
+								  terminals_text_option);
 
 				if (m_preview_draw)
 				{
@@ -172,16 +190,60 @@ void TerminalStripDrawer::paint(QPainter *painter)
 
 				painter->restore();
 
-					//Add bridge anchor
-				if (shared_real_terminal->isBridged())
+					//Draw xref
+				xref_rect.setRect(0, xref_text_y, terminal_rect.width(), xref_text_height);
+				painter->save();
+				if (xref_text_orientation == Qt::Vertical)
 				{
-					painter->save();
-					if (QScopedPointer<AbstractBridgeInterface> bridge_ {
-						shared_real_terminal->bridge() })
-					{
-						const auto x_anchor{terminal_rect.width()/2};
-						const auto y_anchor {m_pattern->m_bridge_point_y_offset[index_]};
-						const auto radius_anchor{m_pattern->m_bridge_point_d/2};
+					painter->translate(xref_rect.bottomLeft());
+					painter->rotate(270);
+					xref_rect.setRect(0, 0, xref_rect.height(), xref_rect.width());
+				}
+
+				QTransform transform;
+				transform.translate(x_offset, 0);
+
+				if (xref_text_orientation == Qt::Vertical)
+				{
+					transform.translate(0, xref_text_y + xref_text_height);
+					transform.rotate(270);
+				}
+
+				auto xref_string = shared_real_terminal->xref();
+
+				const auto mapped_xref_text_rect = transform.mapRect(painter->boundingRect(xref_rect, xref_string, xref_text_option));
+				if (m_united_xref_text_rect.isNull()) {
+					m_united_xref_text_rect = mapped_xref_text_rect;
+				} else {
+					m_united_xref_text_rect = m_united_xref_text_rect.united(mapped_xref_text_rect);
+				}
+
+					//if mouse hover the xref text, draw it in blue to advise user the xref is clickable.
+				if (!m_mouse_hover_pos.isNull() && mapped_xref_text_rect.contains(m_mouse_hover_pos)) {
+					painter->setPen(Qt::blue);
+					m_hovered_xref.physical = physical_index;
+					m_hovered_xref.real = i;
+				}
+
+				painter->drawText(xref_rect, xref_string, xref_text_option);
+
+				if (m_preview_draw)
+				{
+					painter->setPen(Qt::blue);
+					painter->drawRect(xref_rect);
+				}
+				painter->restore();
+
+                    //Add bridge anchor
+                if (shared_real_terminal->isBridged())
+                {
+                    painter->save();
+                    if (QScopedPointer<AbstractBridgeInterface> bridge_ {
+                        shared_real_terminal->bridge() })
+                    {
+                        const auto x_anchor{terminal_rect.width()/2};
+                        const auto y_anchor {m_pattern->m_bridge_point_y_offset[index_]};
+                        const auto radius_anchor{m_pattern->m_bridge_point_d/2};
 
 						painter->setBrush(Qt::SolidPattern);
 						painter->drawEllipse(QPointF(x_anchor, y_anchor),
@@ -194,12 +256,13 @@ void TerminalStripDrawer::paint(QPainter *painter)
 					painter->restore();
 				}
 
-					//Move painter pos to next drawing
-				painter->translate(terminal_rect.width(),0);
-				x_offset += terminal_rect.width();
-			}
-		}
-		painter->restore();
+                    //Move painter pos to next drawing
+                painter->translate(terminal_rect.width(),0);
+                x_offset += terminal_rect.width();
+            }
+			physical_index++;
+        }
+        painter->restore();
 
 			//Draw the bridges
 		for (const auto &points_ : qAsConst(bridges_anchor_points))
@@ -216,7 +279,7 @@ void TerminalStripDrawer::paint(QPainter *painter)
 
 QRectF TerminalStripDrawer::boundingRect() const
 {
-	return QRect{0, 0, width(), height()};;
+    return QRectF{0, 0, width(), height()};;
 }
 
 void TerminalStripDrawer::setLayout(QSharedPointer<TerminalStripLayoutPattern> layout)
@@ -233,7 +296,42 @@ void TerminalStripDrawer::setPreviewDraw(bool draw) {
 	m_preview_draw = draw;
 }
 
-int TerminalStripDrawer::height() const
+void TerminalStripDrawer::setMouseHoverPos(const QPointF &pos)
+{
+	m_last_mouse_pos_in_xrefs_rect = m_united_xref_text_rect.contains(m_mouse_hover_pos);
+	m_mouse_hover_pos = pos;
+}
+
+/**
+ * @brief TerminalStripDrawer::mouseHoverXref
+ * @return True if the mouse position (given through the function setMouseHoverPos)
+ * hover the rect of a xref.
+ */
+bool TerminalStripDrawer::mouseHoverXref() const {
+	return m_united_xref_text_rect.contains(m_mouse_hover_pos);
+}
+
+bool TerminalStripDrawer::needUpdate()
+{
+	if (mouseHoverXref()) {
+		return true;
+	} else if (m_last_mouse_pos_in_xrefs_rect) {
+		return true;
+	}
+	return false;
+}
+
+/**
+ * @brief TerminalStripDrawer::hoveredXref
+ * @return the current terminal hovered by the mouse
+ * in the xref bounding rectangle
+ */
+hoverTerminal TerminalStripDrawer::hoveredXref() const
+{
+	return m_hovered_xref;
+}
+
+qreal TerminalStripDrawer::height() const
 {
 	if (m_pattern)
 	{
@@ -251,11 +349,11 @@ int TerminalStripDrawer::height() const
 	return 0;
 }
 
-int TerminalStripDrawer::width() const
+qreal TerminalStripDrawer::width() const
 {
-	if (m_pattern)
-	{
-		int width_{m_pattern->m_header_rect.width() + m_pattern->m_spacer_rect.width()};
+    if (m_pattern)
+    {
+        qreal width_{m_pattern->m_header_rect.width() + m_pattern->m_spacer_rect.width()};
 
 		if (m_strip)
 		{

sources/TerminalStrip/GraphicsItem/terminalstripdrawer.h

@@ -27,23 +27,35 @@ class TerminalStrip;
 
 namespace TerminalStripDrawer
 {
-	class AbstractBridgeInterface
-	{
-		public:
-			AbstractBridgeInterface() {}
-			virtual ~AbstractBridgeInterface() {}
-			virtual QUuid uuid() const = 0;
+	/**
+	 * @brief The hoverTerminal struct
+	 * Just a little struct use to know what is the physical and real terminal
+	 * when the mouse hover the Xref string of a terminal.
+	 * If mouse don't hover a Xref the value is set to -1;
+	 */
+	struct hoverTerminal{
+		int physical{-1};
+		int real{-1};
 	};
 
-	class AbstractRealTerminalInterface
-	{
-		public:
-			AbstractRealTerminalInterface() {}
-			virtual ~AbstractRealTerminalInterface() {}
-			virtual QString label() const = 0;
-			virtual bool isBridged() const = 0;
-			virtual AbstractBridgeInterface* bridge() const = 0;
-	};
+    class AbstractBridgeInterface
+    {
+        public:
+            AbstractBridgeInterface() {}
+            virtual ~AbstractBridgeInterface() {}
+            virtual QUuid uuid() const = 0;
+    };
+
+    class AbstractRealTerminalInterface
+    {
+        public:
+            AbstractRealTerminalInterface() {}
+            virtual ~AbstractRealTerminalInterface() {}
+            virtual QString label() const = 0;
+            virtual bool isBridged() const = 0;
+            virtual AbstractBridgeInterface* bridge() const = 0;
+			virtual QString xref() const = 0;
+    };
 
 	class AbstractPhysicalTerminalInterface
 	{
@@ -79,15 +91,24 @@ namespace TerminalStripDrawer
 
 			void setPreviewDraw(bool draw = true);
 
-		private:
-			int height() const;
-			int width() const;
+			void setMouseHoverPos(const QPointF &pos);
+			bool mouseHoverXref() const;
+			bool needUpdate();
+			hoverTerminal hoveredXref() const;
 
-		private:
-			QSharedPointer <AbstractTerminalStripInterface> m_strip;
-			QSharedPointer<TerminalStripLayoutPattern> m_pattern;
-			bool m_preview_draw { false };
-	};
+        private:
+            qreal height() const;
+            qreal width() const;
+
+        private:
+            QSharedPointer <AbstractTerminalStripInterface> m_strip;
+            QSharedPointer<TerminalStripLayoutPattern> m_pattern;
+            bool m_preview_draw { false };
+			QPointF m_mouse_hover_pos;
+			QRectF m_united_xref_text_rect;
+			bool m_last_mouse_pos_in_xrefs_rect{false};
+			hoverTerminal m_hovered_xref;
+    };
 }
 
 #endif // TERMINALSTRIPDRAWER_H

sources/TerminalStrip/GraphicsItem/terminalstripitem.cpp

@@ -22,6 +22,8 @@
 #include "../../project/projectpropertieshandler.h"
 #include "../../qetgraphicsitem/qgraphicsitemutility.h"
 #include "../terminalstrip.h"
+#include "../physicalterminal.h"
+#include "../realterminal.h"
 #include "../ui/terminalstripeditorwindow.h"
 #include "trueterminalstrip.h"
 
@@ -94,12 +96,52 @@ QString TerminalStripItem::name() const {
 	return tr("plan de bornes");
 }
 
+void TerminalStripItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
+	QetGraphicsItem::hoverMoveEvent(event);
+	m_drawer.setMouseHoverPos(hoverMousePos());
+	if (m_drawer.needUpdate()) {
+		update();
+	}
+}
+
+void TerminalStripItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
+	QetGraphicsItem::hoverLeaveEvent(event);
+	m_drawer.setMouseHoverPos(QPointF{});
+}
+
 void TerminalStripItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 {
 	Q_UNUSED (event);
 
+	const auto hovered = m_drawer.hoveredXref();
+
 	if (m_strip) {
-		TerminalStripEditorWindow::edit(m_strip);
+		if (hovered.physical >= 0 &&
+			hovered.real >= 0)
+		{
+			if (const auto physical_terminal = m_strip->physicalTerminal(hovered.physical);
+				!physical_terminal.isNull())
+			{
+				if (const auto real_terminal = physical_terminal->realTerminal(hovered.real);
+					!real_terminal.isNull() &&
+					real_terminal->isElement())
+				{
+					if (QPointer<Element> element = real_terminal->element();
+						!element.isNull())
+					{
+						//Unselect and ungrab mouse to prevent unwanted
+						//move when element is in the same scene of this.
+						setSelected(false);
+						ungrabMouse();
+						QetGraphicsItem::showItem(element);
+					}
+				}
+			}
+		} else {
+			TerminalStripEditorWindow::edit(m_strip);
+		}
 	}
 }
 

sources/TerminalStrip/GraphicsItem/terminalstripitem.h

@@ -46,18 +46,19 @@ class TerminalStripItem : public QetGraphicsItem
 		QRectF boundingRect() const override;
 		QString name() const override;
 
-		void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;
-		void refreshPending();
-		void setLayout(QSharedPointer<TerminalStripLayoutPattern> layout);
+		void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override;
+		void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;
+        void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;
+        void refreshPending();
+        void setLayout(QSharedPointer<TerminalStripLayoutPattern> layout);
 
 	private:
 		void setDefaultLayout();
 
 	private:
 		QPointer<TerminalStrip> m_strip;
-		TerminalStripDrawer::TerminalStripDrawer m_drawer;
-		QUuid m_pending_strip_uuid;
-
+        TerminalStripDrawer::TerminalStripDrawer m_drawer;
+        QUuid m_pending_strip_uuid;
 };
 
 #endif // TERMINALSTRIPITEM_H

sources/TerminalStrip/GraphicsItem/trueterminalstrip.cpp

@@ -20,6 +20,7 @@
 #include "../realterminal.h"
 #include "../terminalstrip.h"
 #include "../terminalstripbridge.h"
+#include "../../autoNum/assignvariables.h"
 
 #include "terminalstripdrawer.h"
 
@@ -118,9 +119,18 @@ namespace TerminalStripDrawer
 		return new TrueBridge(m_real->bridge());
 	}
 
-	TrueBridge::TrueBridge(QSharedPointer<TerminalStripBridge> bridge) :
-		m_bridge { bridge }
-	{}
+	QString TrueRealTerminal::xref() const
+	{
+		if (m_real && m_real->isElement()) {
+			return autonum::AssignVariables::genericXref(m_real->element());
+		} else {
+			return QString{};
+		}
+	}
+
+    TrueBridge::TrueBridge(QSharedPointer<TerminalStripBridge> bridge) :
+        m_bridge { bridge }
+    {}
 
 	QUuid TrueBridge::uuid() const
 	{

sources/TerminalStrip/GraphicsItem/trueterminalstrip.h

@@ -51,13 +51,14 @@ namespace TerminalStripDrawer
 			QSharedPointer<PhysicalTerminal> m_physical;
 	};
 
-	class TrueRealTerminal : public AbstractRealTerminalInterface
-	{
-		public:
-			TrueRealTerminal(QSharedPointer<RealTerminal> real);
-			QString label() const override;
-			bool isBridged() const override;
-			AbstractBridgeInterface* bridge() const override;
+    class TrueRealTerminal : public AbstractRealTerminalInterface
+    {
+        public:
+            TrueRealTerminal(QSharedPointer<RealTerminal> real);
+            QString label() const override;
+            bool isBridged() const override;
+            AbstractBridgeInterface* bridge() const override;
+			QString xref() const override;
 
 		private:
 			QSharedPointer<RealTerminal> m_real;