Add initial support of texts group

git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@5117 bfdf4180-ca20-0410-9c96-a3a8aa849046

sources/ui/diagrampropertieseditordockwidget.cpp

@@ -24,6 +24,7 @@
 #include "qetshapeitem.h"
 #include "shapegraphicsitempropertieswidget.h"
 #include "dynamicelementtextitem.h"
+#include "elementtextitemgroup.h"
 
 /**
  * @brief DiagramPropertiesEditorDockWidget::DiagramPropertiesEditorDockWidget
@@ -90,7 +91,8 @@ void DiagramPropertiesEditorDockWidget::selectionChanged()
 
 	switch (type_)
 	{
-		case Element::Type: {
+		case Element::Type:
+		{
 				//We already edit an element, just update the editor with a new element
 			if (m_edited_qgi_type == type_)
 			{
@@ -101,15 +103,17 @@ void DiagramPropertiesEditorDockWidget::selectionChanged()
 			clear();
 			m_edited_qgi_type = type_;
 			addEditor(new ElementPropertiesWidget(static_cast<Element*>(item), this));
-			break; }
-
-		case DiagramImageItem::Type: {
+			break;
+		}
+		case DiagramImageItem::Type:
+		{
 			clear();
 			m_edited_qgi_type = type_;
 			addEditor(new ImagePropertiesWidget(static_cast<DiagramImageItem*>(item), this));
-			break; }
-
-		case QetShapeItem::Type: {
+			break;
+		}
+		case QetShapeItem::Type:
+		{
 			if (m_edited_qgi_type == type_)
 			{
 				static_cast<ShapeGraphicsItemPropertiesWidget*>(editors().first())->setItem(static_cast<QetShapeItem*>(item));
@@ -119,13 +123,14 @@ void DiagramPropertiesEditorDockWidget::selectionChanged()
 			clear();
 			m_edited_qgi_type = type_;
 			addEditor(new ShapeGraphicsItemPropertiesWidget(static_cast<QetShapeItem*>(item), this));
-			break; }
-			
-		case DynamicElementTextItem::Type: {
+			break;
+		}
+		case DynamicElementTextItem::Type:
+		{
 			DynamicElementTextItem *deti = static_cast<DynamicElementTextItem *>(item);
 			
-				//For dynamic element text, we open the element editor
-				//We already edit an element, just update the editor with a new element
+				//For dynamic element text, we open the element editor to edit it
+				//If we already edit an element, just update the editor with a new element
 			if (m_edited_qgi_type == Element::Type)
 			{
 				static_cast<ElementPropertiesWidget*>(editors().first())->setDynamicText(deti);
@@ -135,8 +140,26 @@ void DiagramPropertiesEditorDockWidget::selectionChanged()
 			clear();
 			m_edited_qgi_type = Element::Type;
 			addEditor(new ElementPropertiesWidget(deti, this));
-			break; }
-
+			break;
+		}
+		case QGraphicsItemGroup::Type:
+		{
+			if(ElementTextItemGroup *group = dynamic_cast<ElementTextItemGroup *>(item))
+			{
+					//For element text item group, we open the element editor to edit it
+					//If we already edit an element, just update the editor with a new element
+				if(m_edited_qgi_type == Element::Type)
+				{
+					static_cast<ElementPropertiesWidget *>(editors().first())->setTextsGroup(group);
+					return;
+				}
+				
+				clear();
+				m_edited_qgi_type = Element::Type;
+				addEditor(new ElementPropertiesWidget(group, this));
+			}
+			break;
+		}
 		default:
 			m_edited_qgi_type = -1;
 			clear();

sources/ui/dynamicelementtextitemeditor.cpp

@@ -24,6 +24,8 @@
 #include "undocommand/deleteqgraphicsitemcommand.h"
 #include "undocommand/addelementtextcommand.h"
 #include "QPropertyUndoCommand/qpropertyundocommand.h"
+#include "elementtextitemgroup.h"
+#include "deleteqgraphicsitemcommand.h"
 
 #include <QTreeView>
 #include <QUndoCommand>
@@ -33,12 +35,17 @@ DynamicElementTextItemEditor::DynamicElementTextItemEditor(Element *element, QWi
     ui(new Ui::DynamicElementTextItemEditor)
 {
     ui->setupUi(this);
+	
     m_tree_view = new QTreeView(this);
     m_tree_view->header()->setDefaultSectionSize(150);
     m_tree_view->setItemDelegate(new DynamicTextItemDelegate(m_tree_view));
 	m_tree_view->setAlternatingRowColors(true);
 	m_tree_view->setEditTriggers(QAbstractItemView::CurrentChanged);
+	m_tree_view->installEventFilter(this);
     ui->verticalLayout->addWidget(m_tree_view);
+	
+	setUpAction();
+	
     setElement(element);
 }
 
@@ -55,12 +62,8 @@ void DynamicElementTextItemEditor::setElement(Element *element)
      m_element = element;
     
     DynamicElementTextModel *old_model = m_model;
-    m_model = new DynamicElementTextModel(m_tree_view);
+    m_model = new DynamicElementTextModel(element, m_tree_view);
 	connect(m_model, &DynamicElementTextModel::dataForTextChanged, this, &DynamicElementTextItemEditor::dataEdited);
-    
-    for (DynamicElementTextItem *deti : m_element->dynamicTextItems())
-        m_model->addText(deti);
-    
     m_tree_view->setModel(m_model);
     
     if(old_model)
@@ -76,7 +79,14 @@ bool DynamicElementTextItemEditor::setLiveEdit(bool live_edit)
 void DynamicElementTextItemEditor::apply()
 {
 	QList <QUndoCommand *> undo_list;
-	for (DynamicElementTextItem *deti : m_element->dynamicTextItems())
+	
+		//Get all dynamic text item of the element
+	QList <DynamicElementTextItem *> deti_list;
+	deti_list << m_element.data()->dynamicTextItems();
+		for(ElementTextItemGroup *group : m_element.data()->textGroups())
+			deti_list << group->texts();
+		
+	for (DynamicElementTextItem *deti : deti_list)
 	{
 		QUndoCommand *undo = m_model->undoForEditedText(deti);
 
@@ -94,9 +104,6 @@ void DynamicElementTextItemEditor::apply()
 			delete undo;
 	}
 	
-	for (DynamicElementTextItem *deti : m_element->dynamicTextItems())
-		deti->blockSignals(true);
-	
 	if(!undo_list.isEmpty() && m_element->diagram())
 	{
 		if (undo_list.size() == 1)
@@ -112,9 +119,6 @@ void DynamicElementTextItemEditor::apply()
 			us.endMacro();
 		}
 	}
-	
-	for (DynamicElementTextItem *deti : m_element->dynamicTextItems())
-		deti->blockSignals(false);
 }
 
 /**
@@ -133,6 +137,21 @@ void DynamicElementTextItemEditor::setCurrentText(DynamicElementTextItem *text)
 	m_tree_view->setCurrentIndex(index);
 }
 
+/**
+ * @brief DynamicElementTextItemEditor::setCurrentGroup
+ * Expand and select the item for group @group
+ * @param group
+ */
+void DynamicElementTextItemEditor::setCurrentGroup(ElementTextItemGroup *group)
+{
+	QModelIndex index = m_model->indexFromGroup(group);
+	if(!index.isValid())
+		return;
+	
+	m_tree_view->expand(index);
+	m_tree_view->setCurrentIndex(index);
+}
+
 QUndoCommand *DynamicElementTextItemEditor::associatedUndo() const
 {
 	QUndoCommand *parent_undo = new QUndoCommand(tr("Modifier un texte d'élément"));
@@ -149,6 +168,164 @@ QUndoCommand *DynamicElementTextItemEditor::associatedUndo() const
 		return nullptr;
 }
 
+/**
+ * @brief DynamicElementTextItemEditor::eventFilter
+ * Reimplemented for intercept the context menu event of the tree view
+ * @param watched
+ * @param event
+ * @return 
+ */
+bool DynamicElementTextItemEditor::eventFilter(QObject *watched, QEvent *event)
+{
+	if(watched == m_tree_view && event->type() == QEvent::ContextMenu)
+	{
+		QContextMenuEvent *qcme = static_cast<QContextMenuEvent *>(event);
+		QModelIndex index = m_tree_view->currentIndex();
+		
+		if(index.isValid())
+		{
+			for(QAction *action : m_actions_list)
+				m_context_menu->removeAction(action);
+			m_add_to_group->menu()->clear();
+			
+				//Pop up a context menu for a group or a text in a group
+			if(m_model->indexIsInGroup(index))
+			{
+				QStandardItem *item = m_model->itemFromIndex(index);
+				if(item)
+				{
+					if(m_model->textFromItem(item)) //User click on a text or a child item of a text
+					{
+						m_context_menu->addAction(m_remove_text_from_group);
+						m_context_menu->addAction(m_remove_current_text);
+					}
+					else//User click on a group item
+						m_context_menu->addAction(m_remove_current_group);
+				}
+			}
+			else //Popup a context menu for a text not owned by a group
+			{
+				if(m_element.data()->textGroups().isEmpty())
+					m_context_menu->addAction(m_new_group);
+				else
+				{
+					m_context_menu->addAction(m_add_to_group);
+					m_context_menu->addAction(m_new_group);
+					m_context_menu->addAction(m_remove_current_text);
+					
+					for(ElementTextItemGroup *grp : m_element.data()->textGroups())
+					{
+						QAction *action = m_add_to_group->menu()->addAction(grp->name());
+						connect(action, &QAction::triggered, m_signal_mapper, static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
+						m_signal_mapper->setMapping(action, grp->name());
+					}
+				}
+			}
+			
+			m_context_menu->popup(qcme->globalPos());
+			return true;
+		}
+	}
+	return AbstractElementPropertiesEditorWidget::eventFilter(watched, event);
+}
+
+void DynamicElementTextItemEditor::setUpAction()
+{
+	m_context_menu = new QMenu(this);
+	
+		//Action add text to a group
+	m_add_to_group = new QAction(tr("Ajouter au groupe"), m_context_menu);
+	m_add_to_group->setMenu(new QMenu(m_context_menu));
+	
+	m_signal_mapper = new QSignalMapper(this);
+	connect(m_signal_mapper, static_cast<void (QSignalMapper::*)(const QString &)>(&QSignalMapper::mapped), this, &DynamicElementTextItemEditor::addCurrentTextToGroup);
+	
+		//Action remove text from a group
+	m_remove_text_from_group = new QAction(tr("Supprimer le texte de ce groupe"), m_context_menu);
+	connect(m_remove_text_from_group, &QAction::triggered, [this]()
+	{
+		QAbstractItemModel *m = this->m_tree_view->model();
+		if(m == nullptr)
+			return;
+		
+		DynamicElementTextModel *model = static_cast<DynamicElementTextModel *>(m);
+		if(model->indexIsInGroup(m_tree_view->currentIndex()))
+		{
+			DynamicElementTextItem *deti = m_model->textFromIndex(m_tree_view->currentIndex());
+			if(deti && deti->parentGroup())
+				m_element.data()->removeTextFromGroup(deti, deti->parentGroup());
+		}
+	});
+	
+		//Action create new group and the connection for open a dialog to edit the name
+		//of the new group
+	m_new_group = new QAction(tr("Nouveau groupe"), m_context_menu);
+	connect(m_new_group, &QAction::triggered, [this]()
+	{
+		QAbstractItemModel *m = this->m_tree_view->model();
+		if(m == nullptr)
+			return;
+		
+		DynamicElementTextModel *model = static_cast<DynamicElementTextModel *>(m);
+		if(model->indexIsInGroup(m_tree_view->currentIndex()))
+			return;
+		
+		DynamicElementTextItem *deti = model->textFromIndex(m_tree_view->currentIndex());
+		if(deti)
+		{
+			Element *element = deti->parentElement();
+			QString name = QInputDialog::getText(this, tr("Nom du groupe"), tr("Entrer le nom du nouveau groupe"));
+			
+			if(name.isEmpty())
+				return;
+			else
+				element->addTextGroup(name);
+		}
+	});
+	
+		//Action remove the selected text
+	m_remove_current_text = new QAction(tr("Supprimer le texte"), m_context_menu);
+	connect(m_remove_current_text, &QAction::triggered, [this]()
+	{
+		QAbstractItemModel *m = this->m_tree_view->model();
+		if(m == nullptr)
+			return;
+		
+		DynamicElementTextModel *model = static_cast<DynamicElementTextModel *>(m);
+		if(DynamicElementTextItem *deti = model->textFromIndex(m_tree_view->currentIndex()))
+		{
+			if(m_element.data()->diagram() && m_element.data()->diagram()->project())
+			{
+				QUndoStack *us =m_element.data()->diagram()->project()->undoStack();
+				DiagramContent dc;
+				dc.m_element_texts << deti;
+				us->push((new DeleteQGraphicsItemCommand(m_element.data()->diagram(), dc)));
+			}
+		}
+	});
+	
+		//Action remove the selected group
+	m_remove_current_group = new QAction(tr("Supprimer le groupe"), m_context_menu);
+	connect(m_remove_current_group, &QAction::triggered, [this]()
+	{
+		QAbstractItemModel *m = this->m_tree_view->model();
+		if(m == nullptr)
+			return;
+		
+		DynamicElementTextModel *model = static_cast<DynamicElementTextModel *>(m);
+		QModelIndex index = m_tree_view->currentIndex();
+		if(model->indexIsInGroup(index) && !model->textFromIndex(index)) //Item is in group and is not a text, so item is the group
+			m_element.data()->removeTextGroup(model->groupFromIndex(index));
+	});
+	
+	m_actions_list << m_add_to_group \
+				   << m_remove_text_from_group \
+				   << m_new_group \
+				   << m_remove_current_text \
+				   << m_remove_current_group;
+	
+}
+
 void DynamicElementTextItemEditor::dataEdited(DynamicElementTextItem *deti)
 {
 	Q_UNUSED(deti)
@@ -156,6 +333,30 @@ void DynamicElementTextItemEditor::dataEdited(DynamicElementTextItem *deti)
 		apply();
 }
 
+/**
+ * @brief DynamicElementTextItemEditor::addCurrentTextToGroup
+ * Add the current selected text to the group named @name
+ * @param name
+ */
+void DynamicElementTextItemEditor::addCurrentTextToGroup(QString name)
+{
+	QModelIndex index = m_tree_view->currentIndex();
+	DynamicElementTextModel *model = static_cast<DynamicElementTextModel *>(m_tree_view->model());
+	
+	DynamicElementTextItem *deti = model->textFromIndex(index);
+	ElementTextItemGroup *group = m_element.data()->textGroup(name);
+	
+	if(deti && group)
+	{
+		if(deti->isSelected())
+		{
+			deti->setSelected(false);
+			group->setSelected(true);
+		}
+		m_element.data()->addTextToGroup(deti, group);
+	}
+}
+
 /**
  * @brief DynamicElementTextItemEditor::on_m_add_text_clicked
  * Add a new dynamic text
@@ -169,8 +370,6 @@ void DynamicElementTextItemEditor::on_m_add_text_clicked()
 	if (m_element->diagram())
 	{
 		m_element->diagram()->undoStack().push(new AddElementTextCommand(m_element, deti));
-		m_model->addText(deti);
-		
 		setCurrentText(deti);
 	}
 	else
@@ -193,7 +392,12 @@ void DynamicElementTextItemEditor::on_m_remove_text_clicked()
 			DiagramContent dc;
 			dc.m_element_texts << deti;
 			m_element->diagram()->undoStack().push(new DeleteQGraphicsItemCommand(m_element->diagram(), dc));
-			m_model->removeText(deti);
 		}
+		return;
     }
+	ElementTextItemGroup *group = m_model->groupFromIndex(m_tree_view->currentIndex());
+	if(group)
+	{
+		m_element.data()->removeTextGroup(group);
+	}
 }

sources/ui/dynamicelementtextitemeditor.h

@@ -24,6 +24,9 @@ class DynamicElementTextItem;
 class DynamicElementTextModel;
 class QTreeView;
 class QStandardItem;
+class QMenu;
+class QSignalMapper;
+class ElementTextItemGroup;
 
 namespace Ui {
 	class DynamicElementTextItemEditor;
@@ -42,10 +45,14 @@ class DynamicElementTextItemEditor : public AbstractElementPropertiesEditorWidge
 		bool setLiveEdit(bool live_edit) override;
 		void apply() override;
 		void setCurrentText(DynamicElementTextItem *text);
+		void setCurrentGroup(ElementTextItemGroup *group);
 		QUndoCommand *associatedUndo() const override;
+		bool eventFilter(QObject *watched, QEvent *event) override;
 	
 	private:
+		void setUpAction();
 		void dataEdited(DynamicElementTextItem *deti);
+		void addCurrentTextToGroup(QString name);
     
     private slots:
         void on_m_add_text_clicked();
@@ -55,7 +62,14 @@ class DynamicElementTextItemEditor : public AbstractElementPropertiesEditorWidge
 		Ui::DynamicElementTextItemEditor *ui;
         QTreeView *m_tree_view = nullptr;
         DynamicElementTextModel *m_model = nullptr;
-        
+		QMenu *m_context_menu = nullptr;
+		QSignalMapper *m_signal_mapper = nullptr;
+		QAction *m_add_to_group = nullptr,
+				*m_remove_text_from_group = nullptr,
+				*m_new_group = nullptr,
+				*m_remove_current_text = nullptr,
+				*m_remove_current_group = nullptr;
+		QList<QAction *> m_actions_list;
 };
 
 #endif // DYNAMICELEMENTTEXTITEMEDITOR_H

sources/ui/dynamicelementtextitemeditor.ui

@@ -31,6 +31,9 @@
      </item>
      <item>
       <widget class="QPushButton" name="m_add_text">
+       <property name="toolTip">
+        <string>Ajouter un texte</string>
+       </property>
        <property name="text">
         <string/>
        </property>
@@ -42,6 +45,9 @@
      </item>
      <item>
       <widget class="QPushButton" name="m_remove_text">
+       <property name="toolTip">
+        <string>Supprimer la sélection</string>
+       </property>
        <property name="text">
         <string/>
        </property>

sources/ui/dynamicelementtextmodel.cpp

@@ -29,15 +29,31 @@
 #include "compositetexteditdialog.h"
 #include "terminal.h"
 #include "conductor.h"
+#include "elementtextitemgroup.h"
+#include "qeticons.h"
 
-DynamicElementTextModel::DynamicElementTextModel(QObject *parent) :
-QStandardItemModel(parent)
+DynamicElementTextModel::DynamicElementTextModel(Element *element, QObject *parent) :
+	QStandardItemModel(parent),
+	m_element(element)
 {
     setColumnCount(2);
     setHeaderData(0, Qt::Horizontal, tr("Propriété"), Qt::DisplayRole);
     setHeaderData(1, Qt::Horizontal, tr("Valeur"), Qt::DisplayRole);
     
 	connect(this, &DynamicElementTextModel::itemChanged, this, &DynamicElementTextModel::itemDataChanged);
+	
+	connect(m_element.data(), &Element::textsGroupAdded,            this, &DynamicElementTextModel::addGroup,            Qt::DirectConnection);
+	connect(m_element.data(), &Element::textsGroupAboutToBeRemoved, this, &DynamicElementTextModel::removeGroup,         Qt::DirectConnection);
+	connect(m_element.data(), &Element::textRemoved,                this, &DynamicElementTextModel::removeText,          Qt::DirectConnection);
+	connect(m_element.data(), &Element::textRemovedFromGroup,       this, &DynamicElementTextModel::removeTextFromGroup, Qt::DirectConnection);
+	connect(m_element.data(), &Element::textAdded,                  this, &DynamicElementTextModel::addText,             Qt::DirectConnection);
+	connect(m_element.data(), &Element::textAddedToGroup,           this, &DynamicElementTextModel::addTextToGroup,      Qt::DirectConnection);
+	
+	for (ElementTextItemGroup *grp : m_element.data()->textGroups())
+		addGroup(grp);
+	
+    for (DynamicElementTextItem *deti : m_element.data()->dynamicTextItems())
+		this->appendRow(itemsForText(deti));
 }
 
 DynamicElementTextModel::~DynamicElementTextModel()
@@ -49,18 +65,43 @@ DynamicElementTextModel::~DynamicElementTextModel()
 }
 
 /**
- * @brief DynamicElementTextModel::addText
- * @param deti
+ * @brief DynamicElementTextModel::indexIsInGroup
+ * @param index
+ * @return True if the index represent a group or an item in a group
  */
-void DynamicElementTextModel::addText(DynamicElementTextItem *deti)
+bool DynamicElementTextModel::indexIsInGroup(const QModelIndex &index) const
 {
-    if(m_texts_list.keys().contains(deti))
-        return;
-    
-    QList <QStandardItem *> qsi_list;
+	QStandardItem *item = itemFromIndex(index);
+	if(item)
+	{
+		while (item->parent())
+			item = item->parent();
+		
+		if(m_groups_list.values().contains(item))
+			return true;
+		else
+			return false;
+	}
+	return false;
+}
 
+/**
+ * @brief DynamicElementTextModel::itemsForText
+ * @param deti
+ * @return The items for the text @deti, if the text@deti is already managed by this model
+ * the returned list is empty
+ * The returned items haven't got the same number of childs if the text is in a group or not.
+ */
+QList<QStandardItem *> DynamicElementTextModel::itemsForText(DynamicElementTextItem *deti)
+{
+	QList <QStandardItem *> qsi_list;
+	
+	if(m_texts_list.keys().contains(deti))
+        return qsi_list;
+    
 	QStandardItem *qsi = new QStandardItem(deti->toPlainText());
     qsi->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+	qsi->setIcon(QET::Icons::PartText);
 	
 	
         //Source of text
@@ -174,44 +215,57 @@ void DynamicElementTextModel::addText(DynamicElementTextItem *deti)
 	qsi_list << frame << frame_a;
 	qsi->appendRow(qsi_list);
 	
-		//X pos
-	QStandardItem *x_pos = new QStandardItem(tr("Position X"));
-	x_pos->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-	
-	QStandardItem *x_pos_a = new QStandardItem;
-	x_pos_a->setData(deti->pos().x(), Qt::EditRole);
-	x_pos_a->setData(DynamicElementTextModel::pos, Qt::UserRole+1);
-	x_pos_a->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
-	
-	qsi_list.clear();
-	qsi_list << x_pos << x_pos_a;
-	qsi->appendRow(qsi_list);
-	
-		//Y pos
-	QStandardItem *y_pos = new QStandardItem(tr("Position Y"));
-	y_pos->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-	
-	QStandardItem *y_pos_a = new QStandardItem;
-	y_pos_a->setData(deti->pos().y(), Qt::EditRole);
-	y_pos_a->setData(DynamicElementTextModel::pos, Qt::UserRole+1);
-	y_pos_a->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
-	
-	qsi_list.clear();
-	qsi_list << y_pos << y_pos_a;
-	qsi->appendRow(qsi_list);
+	if(deti->parentGroup() == nullptr)
+	{
+			//X pos
+		QStandardItem *x_pos = new QStandardItem(tr("Position X"));
+		x_pos->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+		
+		QStandardItem *x_pos_a = new QStandardItem;
+		x_pos_a->setData(deti->pos().x(), Qt::EditRole);
+		x_pos_a->setData(DynamicElementTextModel::pos, Qt::UserRole+1);
+		x_pos_a->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
+		
+		qsi_list.clear();
+		qsi_list << x_pos << x_pos_a;
+		qsi->appendRow(qsi_list);
+		
+			//Y pos
+		QStandardItem *y_pos = new QStandardItem(tr("Position Y"));
+		y_pos->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+		
+		QStandardItem *y_pos_a = new QStandardItem;
+		y_pos_a->setData(deti->pos().y(), Qt::EditRole);
+		y_pos_a->setData(DynamicElementTextModel::pos, Qt::UserRole+1);
+		y_pos_a->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
+		
+		qsi_list.clear();
+		qsi_list << y_pos << y_pos_a;
+		qsi->appendRow(qsi_list);
+	}
 	
 	
 	qsi_list.clear();
 	QStandardItem *empty_qsi = new QStandardItem(0);
 	empty_qsi->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	qsi_list << qsi << empty_qsi;
-    this->appendRow(qsi_list);
 	
     m_texts_list.insert(deti, qsi);
 	blockSignals(true);
 	enableSourceText(deti, deti->textFrom());
 	blockSignals(false);
 	setConnection(deti, true);
+	
+	return qsi_list;
+}
+
+/**
+ * @brief DynamicElementTextModel::addText
+ * @param deti
+ */
+void DynamicElementTextModel::addText(DynamicElementTextItem *deti)
+{
+	this->appendRow(itemsForText(deti));
 }
 
 /**
@@ -251,15 +305,44 @@ DynamicElementTextItem *DynamicElementTextModel::textFromIndex(const QModelIndex
  * @param item
  * @return the text associated with @item. Return value can be nullptr
  * @item can be a child of an item associated with a text
+ * Note can return nullptr
  */
 DynamicElementTextItem *DynamicElementTextModel::textFromItem(QStandardItem *item) const
 {
+		//Item haven't got parent, so they can be only a text or a group
+	if(!item->parent()) 
+	{
+		if(m_texts_list.values().contains(item))
+			return m_texts_list.key(item);
+		else
+			return nullptr;
+	}
+	
+	
+	
 	QStandardItem *text_item = item;
 	while (text_item->parent())
 		text_item = text_item->parent();
 	
-	if (m_texts_list.values().contains(text_item))
+	if (m_texts_list.values().contains(text_item)) //The item is a text
 		return m_texts_list.key(text_item);
+	else if (m_groups_list.values().contains(text_item)) //The item is a group
+	{
+		QStandardItem *previous = item;
+		QStandardItem *top = item;
+			//At the end of the while, previous must be the text
+			//and top the group
+		while(top->parent())
+		{
+			previous = top;
+			top = top->parent();
+		}
+		
+		if(m_texts_list.values().contains(previous))
+			return m_texts_list.key(previous);
+		else
+			return nullptr;
+	}
 	else
 		return nullptr;
 }
@@ -271,10 +354,10 @@ DynamicElementTextItem *DynamicElementTextModel::textFromItem(QStandardItem *ite
  */
 QModelIndex DynamicElementTextModel::indexFromText(DynamicElementTextItem *text) const
 {
-	if(!m_texts_list.contains(text))
+	if(m_texts_list.contains(text))
+		return m_texts_list.value(text)->index();
+	else
 		return QModelIndex();
-	
-	return m_texts_list.value(text)->index();
 }
 
 /**
@@ -353,17 +436,142 @@ QUndoCommand *DynamicElementTextModel::undoForEditedText(DynamicElementTextItem
 		quc->setText(tr("Modifier le cadre d'un texte d'élément"));
 	}
 	
-	QPointF p(text_qsi->child(5,1)->data(Qt::EditRole).toDouble(),
-			  text_qsi->child(6,1)->data(Qt::EditRole).toDouble());
-	if(p != deti->pos())
+		//When text is in a group, they're isn't item for position of the text
+	if(text_qsi->child(5,1) && text_qsi->child(6,1))
 	{
-		QPropertyUndoCommand *quc = new QPropertyUndoCommand(deti, "pos", QVariant(deti->pos()), QVariant(p), undo);
-		quc->setText(tr("Déplacer un texte d'élément"));
+		QPointF p(text_qsi->child(5,1)->data(Qt::EditRole).toDouble(),
+				  text_qsi->child(6,1)->data(Qt::EditRole).toDouble());
+		if(p != deti->pos())
+		{
+			QPropertyUndoCommand *quc = new QPropertyUndoCommand(deti, "pos", QVariant(deti->pos()), QVariant(p), undo);
+			quc->setText(tr("Déplacer un texte d'élément"));
+		}
 	}
 	
 	return undo;
 }
 
+/**
+ * @brief DynamicElementTextModel::AddGroup
+ * Add a text item group to this model
+ * @param group
+ */
+void DynamicElementTextModel::addGroup(ElementTextItemGroup *group)
+{
+	if(m_groups_list.keys().contains(group))
+		return;
+	
+	QStandardItem *grp = new QStandardItem(group->name());
+	grp->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+	grp->setIcon(QET::Icons::textGroup);
+	
+	QStandardItem *empty_qsi = new QStandardItem(0);
+	empty_qsi->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+	
+	QList<QStandardItem *> qsi_list;
+	qsi_list << grp << empty_qsi;
+	
+	this->insertRow(0, qsi_list);
+	m_groups_list.insert(group, grp);
+	
+		//Add the texts of the group
+	for(DynamicElementTextItem *deti : group->texts())
+	{
+		QStandardItem *group_item = m_groups_list.value(group);
+		group_item->appendRow(itemsForText(deti));
+	}
+}
+
+/**
+ * @brief DynamicElementTextModel::removeGroup
+ * Remove the text item group from this model
+ * @param group
+ */
+void DynamicElementTextModel::removeGroup(ElementTextItemGroup *group)
+{
+	if(m_groups_list.keys().contains(group))
+	{
+		QModelIndex group_index = m_groups_list.value(group)->index();
+		this->removeRow(group_index.row(), group_index.parent());
+		m_groups_list.remove(group);
+	}
+}
+
+/**
+ * @brief DynamicElementTextModel::textAddedToGroup
+ * Add the text @text to the group @group
+ * @param deti
+ * @param group
+ */
+void DynamicElementTextModel::addTextToGroup(DynamicElementTextItem *deti, ElementTextItemGroup *group)
+{
+	QStandardItem *group_item = m_groups_list.value(group);
+	group_item->appendRow(itemsForText(deti));
+}
+
+void DynamicElementTextModel::removeTextFromGroup(DynamicElementTextItem *deti, ElementTextItemGroup *group)
+{
+	Q_UNUSED(group)
+	
+	if(m_texts_list.keys().contains(deti))
+	{
+		QStandardItem *text_item = m_texts_list.value(deti);
+		QModelIndex text_index = indexFromItem(text_item);
+		removeRow(text_index.row(), text_index.parent());
+		m_texts_list.remove(deti);
+	}
+}
+
+/**
+ * @brief DynamicElementTextModel::groupFromIndex
+ * @param index
+ * @return the group associated with @index. Return value can be nullptr
+ * @Index can be a child of an index associated with a group
+ */
+ElementTextItemGroup *DynamicElementTextModel::groupFromIndex(const QModelIndex &index) const
+{
+	if(!index.isValid())
+        return nullptr;
+    
+    if (QStandardItem *item = itemFromIndex(index))
+        return groupFromItem(item);
+    else
+        return nullptr;
+}
+
+/**
+ * @brief DynamicElementTextModel::groupFromItem
+ * @param item
+ * @return the group associated with @item. Return value can be nullptr
+ * @item can be a child of an item associated with a group
+ */
+ElementTextItemGroup *DynamicElementTextModel::groupFromItem(QStandardItem *item) const
+{
+	QStandardItem *group_item = item;
+	
+	while (group_item->parent())
+		group_item = group_item->parent();
+	
+	if(m_groups_list.values().contains(group_item))
+		return m_groups_list.key(group_item);
+	else
+		return nullptr;
+}
+
+/**
+ * @brief DynamicElementTextModel::indexFromGroup
+ * @param group
+ * @return The index associated to the group @group
+ * or a default QModelIndex if not match
+ */
+QModelIndex DynamicElementTextModel::indexFromGroup(ElementTextItemGroup *group) const
+{
+	if(m_groups_list.keys().contains(group))
+		return m_groups_list.value(group)->index();
+	else
+		return QModelIndex();
+}
+
 /**
  * @brief DynamicElementTextModel::enableSourceText
  * Enable the good field, according to the current source of text, for the edited text @deti
@@ -556,8 +764,10 @@ void DynamicElementTextModel::updateDataFromText(DynamicElementTextItem *deti, V
 		}
 		case pos:
 		{
-			qsi->child(5,1)->setData(deti->pos().x(), Qt::EditRole);
-			qsi->child(6,1)->setData(deti->pos().y(), Qt::EditRole);
+			if(qsi->child(5,1))
+				qsi->child(5,1)->setData(deti->pos().x(), Qt::EditRole);
+			if(qsi->child(6,1))
+				qsi->child(6,1)->setData(deti->pos().y(), Qt::EditRole);
 			break;
 		}
 		case frame:

sources/ui/dynamicelementtextmodel.h

@@ -23,6 +23,8 @@
 #include "dynamicelementtextitem.h"
 
 class QUndoCommand;
+class ElementTextItemGroup;
+class Element;
 
 /**
  * @brief The DynamicElementTextModel class
@@ -47,27 +49,39 @@ class DynamicElementTextModel : public QStandardItemModel
 			frame
         };
         
-		DynamicElementTextModel(QObject *parent = nullptr);
+		DynamicElementTextModel(Element *element, QObject *parent = nullptr);
 		~DynamicElementTextModel() override;
 		
-		void addText(DynamicElementTextItem *deti);
-		void removeText(DynamicElementTextItem *deti);
+		bool indexIsInGroup(const QModelIndex &index) const;
         DynamicElementTextItem *textFromIndex(const QModelIndex &index) const;
         DynamicElementTextItem *textFromItem(QStandardItem *item) const;
 		QModelIndex indexFromText(DynamicElementTextItem *text) const;
 		QUndoCommand *undoForEditedText(DynamicElementTextItem *deti, QUndoCommand *parent_undo = nullptr) const;
 		
+		ElementTextItemGroup *groupFromIndex(const QModelIndex &index) const;
+		ElementTextItemGroup *groupFromItem(QStandardItem *item) const;
+		QModelIndex indexFromGroup(ElementTextItemGroup *group) const;
+		
 	signals:
 		void dataForTextChanged(DynamicElementTextItem *text);
         
     private:
+		QList<QStandardItem *> itemsForText(DynamicElementTextItem *deti);
+		void addText(DynamicElementTextItem *deti);
+		void removeText(DynamicElementTextItem *deti);
+		void addGroup(ElementTextItemGroup *group);
+		void removeGroup(ElementTextItemGroup *group);
+		void addTextToGroup(DynamicElementTextItem *deti, ElementTextItemGroup *group);
+		void removeTextFromGroup(DynamicElementTextItem *deti, ElementTextItemGroup *group);
 		void enableSourceText(DynamicElementTextItem *deti, DynamicElementTextItem::TextFrom tf );
         void itemDataChanged(QStandardItem *qsi);
 		void setConnection(DynamicElementTextItem *deti, bool set);
 		void updateDataFromText(DynamicElementTextItem *deti, DynamicElementTextModel::ValueType type);
 		
 	private:
+		QPointer<Element> m_element;
 		QHash <DynamicElementTextItem *, QStandardItem *> m_texts_list;
+		QHash <ElementTextItemGroup *, QStandardItem *> m_groups_list;
 		QHash <DynamicElementTextItem *, QList<QMetaObject::Connection>> m_hash_text_connect;
 		bool m_block_dataForTextChanged = false;
 };

sources/ui/elementpropertieswidget.cpp

@@ -26,6 +26,7 @@
 #include "qeticons.h"
 #include "dynamicelementtextitemeditor.h"
 #include "dynamicelementtextitem.h"
+#include "elementtextitemgroup.h"
 
 #include <QVBoxLayout>
 #include <QLabel>
@@ -68,6 +69,28 @@ ElementPropertiesWidget::ElementPropertiesWidget(DynamicElementTextItem *text, Q
 	}
 }
 
+/**
+ * @brief ElementPropertiesWidget::ElementPropertiesWidget
+ * Same as default constructor, the edited element, is the parent element of @group.
+ * The only difference with default constructor, is that the current tab is the tab for dynamic texts,
+ * and the item in the tree that represent @group is expanded and selected.
+ * @param group
+ * @param parent
+ */
+ElementPropertiesWidget::ElementPropertiesWidget(ElementTextItemGroup *group, QWidget *parent) :
+	AbstractElementPropertiesEditorWidget (parent),
+	m_tab (nullptr),
+	m_general_widget(nullptr)
+{
+	if(group->parentItem() && group->parentItem()->type() == Element::Type)
+	{
+		Element *elmt = static_cast<Element *>(group->parentItem());
+		m_diagram = elmt->diagram();
+		buildGui();
+		setTextsGroup(group);
+	}
+}
+
 /**
  * @brief ElementPropertiesWidget::setElement
  * Set @element to be the edited element
@@ -118,6 +141,29 @@ void ElementPropertiesWidget::setDynamicText(DynamicElementTextItem *text)
 	}
 }
 
+/**
+ * @brief ElementPropertiesWidget::setTextsGroup
+ * Conveniance function : same as call : ElementPropertiesWidget::setElement, with parameter the parent element of @group.
+ * Set the dynamics text tab as current tab, expand and select the item that represent @group
+ * @param group
+ */
+void ElementPropertiesWidget::setTextsGroup(ElementTextItemGroup *group)
+{
+	if(group->parentItem() && group->parentItem()->type() == Element::Type)
+	{
+		setElement(static_cast<Element *>(group->parentItem()));
+		for(AbstractElementPropertiesEditorWidget *aepew : m_list_editor)
+		{
+			if (QString(aepew->metaObject()->className()) == "DynamicElementTextItemEditor")
+			{
+				DynamicElementTextItemEditor *detie = static_cast<DynamicElementTextItemEditor *>(aepew);
+				m_tab->setCurrentWidget(detie);
+				detie->setCurrentGroup(group);
+			}
+		}
+	}
+}
+
 /**
  * @brief ElementPropertiesWidget::apply
  * Apply the new properties by pushing an undo command

sources/ui/elementpropertieswidget.h

@@ -25,6 +25,7 @@ class Diagram;
 class QTabWidget;
 class ElementsLocation;
 class DynamicElementTextItem;
+class ElementTextItemGroup;
 
 
 class ElementPropertiesWidget : public AbstractElementPropertiesEditorWidget
@@ -34,8 +35,10 @@ class ElementPropertiesWidget : public AbstractElementPropertiesEditorWidget
 	public:
 		explicit ElementPropertiesWidget(Element *elmt, QWidget *parent = nullptr);
 		explicit ElementPropertiesWidget(DynamicElementTextItem *text, QWidget *parent = nullptr);
+		explicit ElementPropertiesWidget(ElementTextItemGroup *group, QWidget *parent = nullptr);
 		void setElement(Element *element) override;
 		void setDynamicText(DynamicElementTextItem *text);
+		void setTextsGroup(ElementTextItemGroup *group);
 		void apply() override;
 		void reset() override;
 		bool setLiveEdit(bool live_edit) override;