GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r87:d88ff9772a05

Merge branch 'feature/PluginTreeItem' into develop

Alexandre Leroux -

r87:d88ff9772a05

parent child

Context file:

r87:d88ff9772a05

Collapse all files

gui/include/DataSource/DataSourceTreeWidgetItem.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef SCIQLOP_DATASOURCETREEWIDGETITEM_H
	2	#define SCIQLOP_DATASOURCETREEWIDGETITEM_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QTreeWidgetItem>
	8
	9	Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem)
	10
	11	class DataSourceItem;
	12
	13	/**
	14	* @brief The DataSourceTreeWidgetItem is the graphical representation of a data source item. It is
	15	* intended to be displayed in a QTreeWidget.
	16	* @sa DataSourceItem
	17	*/
	18	class DataSourceTreeWidgetItem : public QTreeWidgetItem {
	19	public:
	20	explicit DataSourceTreeWidgetItem(const DataSourceItem *data, int type = Type);
	21	explicit DataSourceTreeWidgetItem(QTreeWidget parent, const DataSourceItem data,
	22	int type = Type);
	23
	24	virtual QVariant data(int column, int role) const override;
	25	virtual void setData(int column, int role, const QVariant &value) override;
	26
	27	private:
	28	class DataSourceTreeWidgetItemPrivate;
	29	spimpl::unique_impl_ptr<DataSourceTreeWidgetItemPrivate> impl;
	30	};
	31
	32	#endif // SCIQLOP_DATASOURCETREEWIDGETITEM_H

gui/include/DataSource/DataSourceWidget.h created 644 +33 0

@@ -0,0 +1,33
	1	#ifndef SCIQLOP_DATASOURCEWIDGET_H
	2	#define SCIQLOP_DATASOURCEWIDGET_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QWidget>
	7
	8	class DataSourceItem;
	9
	10	/**
	11	* @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
	12	* attached to SciQlop.
	13	*/
	14	class DataSourceWidget : public QWidget {
	15	Q_OBJECT
	16
	17	public:
	18	explicit DataSourceWidget(QWidget *parent = 0);
	19
	20	public slots:
	21	/**
	22	* Adds a data source. An item associated to the data source is created and then added to the
	23	* representation tree
	24	* @param dataSource the data source to add
	25	*/
	26	void addDataSource(DataSourceItem &dataSource) noexcept;
	27
	28	private:
	29	class DataSourceWidgetPrivate;
	30	spimpl::unique_impl_ptr<DataSourceWidgetPrivate> impl;
	31	};
	32
	33	#endif // SCIQLOP_DATASOURCEWIDGET_H

gui/src/DataSource/DataSourceTreeWidgetItem.cpp created 644 +68 0

@@ -0,0 +1,68
	1	#include <DataSource/DataSourceItem.h>
	2	#include <DataSource/DataSourceTreeWidgetItem.h>
	3
	4	#include <SqpApplication.h>
	5
	6	Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
	7
	8	namespace {
	9
	10	QIcon itemIcon(const DataSourceItem *dataSource)
	11	{
	12	if (dataSource) {
	13	auto dataSourceType = dataSource->type();
	14	switch (dataSourceType) {
	15	case DataSourceItemType::NODE:
	16	return sqpApp->style()->standardIcon(QStyle::SP_DirIcon);
	17	case DataSourceItemType::PRODUCT:
	18	return sqpApp->style()->standardIcon(QStyle::SP_FileIcon);
	19	default:
	20	// No action
	21	break;
	22	}
	23	}
	24
	25	// Default cases
	26	return QIcon{};
	27	}
	28
	29	} // namespace
	30
	31	struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
	32	explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
	33
	34	/// Model used to retrieve data source information
	35	const DataSourceItem *m_Data;
	36	};
	37
	38	DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
	39	: DataSourceTreeWidgetItem{nullptr, data, type}
	40	{
	41	}
	42
	43	DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget parent, const DataSourceItem data,
	44	int type)
	45	: QTreeWidgetItem{parent, type},
	46	impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
	47	{
	48	// Sets the icon depending on the data source
	49	setIcon(0, itemIcon(impl->m_Data));
	50	}
	51
	52	QVariant DataSourceTreeWidgetItem::data(int column, int role) const
	53	{
	54	if (role == Qt::DisplayRole) {
	55	return (impl->m_Data) ? impl->m_Data->data(column) : QVariant{};
	56	}
	57	else {
	58	return QTreeWidgetItem::data(column, role);
	59	}
	60	}
	61
	62	void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
	63	{
	64	// Data can't be changed by edition
	65	if (role != Qt::EditRole) {
	66	QTreeWidgetItem::setData(column, role, value);
	67	}
	68	}

gui/src/DataSource/DataSourceWidget.cpp created 644 +61 0

@@ -0,0 +1,61
	1	#include <DataSource/DataSourceWidget.h>
	2
	3	#include <ui_DataSourceWidget.h>
	4
	5	#include <DataSource/DataSourceItem.h>
	6	#include <DataSource/DataSourceTreeWidgetItem.h>
	7
	8	namespace {
	9
	10	/// Number of columns displayed in the tree
	11	const auto TREE_NB_COLUMNS = 1;
	12
	13	/// Header labels for the tree
	14	const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
	15
	16	/**
	17	* Creates the item associated to a data source
	18	* @param dataSource the data source for which to create the item
	19	* @return the new item
	20	*/
	21	DataSourceTreeWidgetItem createTreeWidgetItem(DataSourceItem dataSource)
	22	{
	23	// Creates item for the data source
	24	auto item = new DataSourceTreeWidgetItem{dataSource};
	25
	26	// Generates items for the children of the data source
	27	for (auto i = 0; i < dataSource->childCount(); ++i) {
	28	item->addChild(createTreeWidgetItem(dataSource->child(i)));
	29	}
	30
	31	return item;
	32	}
	33
	34	} // namespace
	35
	36	class DataSourceWidget::DataSourceWidgetPrivate {
	37	public:
	38	explicit DataSourceWidgetPrivate(DataSourceWidget &widget)
	39	: m_Ui{std::make_unique<Ui::DataSourceWidget>()}
	40	{
	41	m_Ui->setupUi(&widget);
	42
	43	// Set tree properties
	44	m_Ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
	45	m_Ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
	46	}
	47
	48	std::unique_ptr<Ui::DataSourceWidget> m_Ui;
	49	};
	50
	51	DataSourceWidget::DataSourceWidget(QWidget *parent)
	52	: QWidget{parent}, impl{spimpl::make_unique_impl<DataSourceWidgetPrivate>(*this)}
	53	{
	54	}
	55
	56	void DataSourceWidget::addDataSource(DataSourceItem &dataSource) noexcept
	57	{
	58	// Creates the item associated to the source and adds it to the tree widget. The tree widget
	59	// takes the ownership of the item
	60	impl->m_Ui->treeWidget->addTopLevelItem(createTreeWidgetItem(&dataSource));
	61	}

gui/ui/DataSource/DataSourceWidget.ui created 644 +24 0

@@ -0,0 +1,24
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>DataSourceWidget</class>
	4	<widget class="QWidget" name="DataSourceWidget">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>400</width>
	10	<height>300</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Data sources</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QTreeWidget" name="treeWidget"/>
	19	</item>
	20	</layout>
	21	</widget>
	22	<resources/>
	23	<connections/>
	24	</ui>

app/src/Main.cpp +21 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
+            #include <Plugin/PluginManager.h>
+            #include <QDir>
+            namespace {
+            /// Name of the directory containing the plugins
+            const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
+            } // namespace
             int main(int argc, char *argv[])
             {
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
+                // Loads plugins
+                auto pluginDir = QDir{sqpApp->applicationDirPath()};
+                pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
+                pluginDir.cd(PLUGIN_DIRECTORY_NAME);
+                qCDebug(LOG_PluginManager())
+                    << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
+                PluginManager pluginManager{};
+                pluginManager.loadPlugins(pluginDir);
                 return a.exec();
             }

app/src/MainWindow.cpp +10 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
+            #include <DataSource/DataSourceController.h>
+            #include <DataSource/DataSourceWidget.h>
+            #include <SqpApplication.h>
             #include <QAction>
             #include <QDate>
             #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             //#include <omp.h>
             //#include <network/filedownloader.h>
             //#include <qlopdatabase.h>
             //#include <qlopsettings.h>
             //#include <qlopgui.h>
             //#include <spacedata.h>
             //#include "qlopcore.h"
             //#include "qlopcodecmanager.h"
             //#include "cdfcodec.h"
             //#include "amdatxtcodec.h"
             //#include <qlopplotmanager.h>
             #include <QAction>
             #include <QToolBar>
             #include <memory.h>
             MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_Ui(new Ui::MainWindow)
             {
                 m_Ui->setupUi(this);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 leftSidePane->addAction("ACTION L1");
                 leftSidePane->addAction("ACTION L2");
                 leftSidePane->addAction("ACTION L3");
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 rightSidePane->addAction("ACTION R1");
                 rightSidePane->addAction("ACTION R2");
                 rightSidePane->addAction("ACTION R3");
                 this->menuBar()->addAction("File");
                 auto mainToolBar = this->addToolBar("MainToolBar");
                 mainToolBar->addAction("A1");
+                // Widgets / controllers connections
+                connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem &)),
+                        m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem &)));
                 /*    QLopGUI::registerMenuBar(menuBar());
                     this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
                     this->m_progressWidget = new QWidget();
                     this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
                     this->m_progressWidget->setLayout(this->m_progressLayout);
                     this->m_progressWidget->setWindowModality(Qt::WindowModal);
                     m_progressThreadIds = (int*) malloc(OMP_THREADS*sizeof(int));
                     for(int i=0;i<OMP_THREADS;i++)
                     {
                         this->m_progress.append(new QProgressBar(this->m_progressWidget));
                         this->m_progress.last()->setMinimum(0);
                         this->m_progress.last()->setMaximum(100);
                         this->m_progressLayout->addWidget(this->m_progress.last());
                         this->m_progressWidget->hide();
                         this->m_progressThreadIds[i] = -1;
                     }
                     this->m_progressWidget->setWindowTitle("Loading File");
                     const QList<QLopService*>ServicesToLoad=QList<QLopService*>()
                             << QLopCore::self()
                             << QLopPlotManager::self()
                             << QLopCodecManager::self()
                             << FileDownloader::self()
                             << QLopDataBase::self()
                             << SpaceData::self();
                     CDFCodec::registerToManager();
                     AMDATXTCodec::registerToManager();
                     for(int i=0;i<ServicesToLoad.count();i++)
                     {
                         qDebug()<<ServicesToLoad.at(i)->serviceName();
                         ServicesToLoad.at(i)->initialize(); //must be called before getGUI
                         QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
                         if(wdgt)
                         {
                             wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
                             this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
                         }
                         PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
                     }*/
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

app/ui/MainWindow.ui +7 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>800</width>
                 <height>600</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>QLop</string>
               </property>
               <property name="dockNestingEnabled">
                <bool>true</bool>
               </property>
               <widget class="QWidget" name="centralWidget">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>16777215</width>
                  <height>16777215</height>
                 </size>
                </property>
                <layout class="QHBoxLayout" name="horizontalLayout">
                 <property name="spacing">
                  <number>3</number>
                 </property>
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item>
                  <widget class="QWidget" name="leftInspectorWidget" native="true">
                   <layout class="QHBoxLayout" name="horizontalLayout_2">
                    <property name="spacing">
                     <number>3</number>
                    </property>
                    <property name="leftMargin">
                     <number>0</number>
                    </property>
                    <property name="topMargin">
                     <number>0</number>
                    </property>
                    <property name="rightMargin">
                     <number>0</number>
                    </property>
                    <property name="bottomMargin">
                     <number>0</number>
                    </property>
                    <item>
                     <widget class="QWidget" name="widget" native="true">
                      <layout class="QVBoxLayout" name="verticalLayout">
                       <property name="spacing">
                        <number>3</number>
                       </property>
                       <property name="leftMargin">
                        <number>0</number>
                       </property>
                       <property name="topMargin">
                        <number>0</number>
                       </property>
                       <property name="rightMargin">
                        <number>0</number>
                       </property>
                       <property name="bottomMargin">
                        <number>0</number>
                       </property>
                       <item>
-                       <widget class="QWidget" name="dateSourceWidget" native="true"/>
+                       <widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
                       </item>
                       <item>
                        <widget class="QWidget" name="dateTimeWidget" native="true"/>
                       </item>
                       <item>
                        <widget class="QWidget" name="variableInspectorWidget" native="true"/>
                       </item>
                      </layout>
                     </widget>
                    </item>
                    <item>
                     <widget class="SqpSidePane" name="leftInspectorSidePane" native="true">
                      <layout class="QVBoxLayout" name="verticalLayout_2">
                       <property name="spacing">
                        <number>3</number>
                       </property>
                       <property name="leftMargin">
                        <number>0</number>
                       </property>
                       <property name="topMargin">
                        <number>0</number>
                       </property>
                       <property name="rightMargin">
                        <number>0</number>
                       </property>
                       <property name="bottomMargin">
                        <number>0</number>
                       </property>
                      </layout>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                 </item>
                 <item>
                  <widget class="VisualizationWidget" name="view" native="true"/>
                 </item>
                 <item>
                  <widget class="QWidget" name="rightInspectorWidget" native="true">
                   <layout class="QHBoxLayout" name="horizontalLayout_3">
                    <property name="spacing">
                     <number>3</number>
                    </property>
                    <property name="leftMargin">
                     <number>0</number>
                    </property>
                    <property name="topMargin">
                     <number>0</number>
                    </property>
                    <property name="rightMargin">
                     <number>0</number>
                    </property>
                    <property name="bottomMargin">
                     <number>0</number>
                    </property>
                    <item>
                     <widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
                    </item>
                    <item>
                     <widget class="QWidget" name="widget_2" native="true">
                      <layout class="QVBoxLayout" name="verticalLayout_3">
                       <property name="spacing">
                        <number>3</number>
                       </property>
                       <property name="leftMargin">
                        <number>0</number>
                       </property>
                       <property name="topMargin">
                        <number>0</number>
                       </property>
                       <property name="rightMargin">
                        <number>0</number>
                       </property>
                       <property name="bottomMargin">
                        <number>0</number>
                       </property>
                       <item>
                        <widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
                       </item>
                       <item>
                        <widget class="QWidget" name="catalogWidget" native="true"/>
                       </item>
                      </layout>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>800</width>
                  <height>26</height>
                 </rect>
                </property>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>VisualizationWidget</class>
                <extends>QWidget</extends>
                <header location="global">visualization/VisualizationWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>SqpSidePane</class>
                <extends>QWidget</extends>
                <header location="global">sidepane/SqpSidePane.h</header>
                <container>1</container>
               </customwidget>
+              <customwidget>
+               <class>DataSourceWidget</class>
+               <extends>QWidget</extends>
+               <header location="global">DataSource/DataSourceWidget.h</header>
+               <container>1</container>
+              </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

core/include/DataSource/DataSourceController.h +1 -1

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
             class DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataSourceItem the structure of the data source
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
-                void dataSourceItemSet(const DataSourceItem &dataSourceItem);
+                void dataSourceItemSet(DataSourceItem &dataSourceItem);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/include/DataSource/DataSourceItem.h +8 -1

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             /**
+             * Possible types of an item
+             */
+            enum class DataSourceItemType { NODE, PRODUCT };
+            /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class DataSourceItem {
             public:
-                explicit DataSourceItem(QVector<QVariant> data = {});
+                explicit DataSourceItem(DataSourceItemType type, QVector<QVariant> data = {});
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to an index
                  * @param dataIndex the index to search
                  * @return the data found if index is valid, default QVariant otherwise
                  */
                 QVariant data(int dataIndex) const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
+                DataSourceItemType type() const noexcept;
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/DataSource/DataSourceItem.cpp +10 -4

             #include <DataSource/DataSourceItem.h>
             #include <QVector>
             struct DataSourceItem::DataSourceItemPrivate {
-                explicit DataSourceItemPrivate(QVector<QVariant> data)
+                explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
-                        : m_Parent{nullptr}, m_Children{}, m_Data{std::move(data)}
+                        : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
+                DataSourceItemType m_Type;
                 QVector<QVariant> m_Data;
             };
-            DataSourceItem::DataSourceItem(QVector<QVariant> data)
+            DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
-                    : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(data)}
+                    : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(int dataIndex) const noexcept
             {
                 return impl->m_Data.value(dataIndex);
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
+            DataSourceItemType DataSourceItem::type() const noexcept
+            {
+                return impl->m_Type;
+            }

core/tests/DataSource/TestDataSourceController.cpp +4 -2

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             class TestDataSourceController : public QObject {
                 Q_OBJECT
             private slots:
                 void testRegisterDataSource();
                 void testSetDataSourceItem();
             };
             void TestDataSourceController::testRegisterDataSource()
             {
                 DataSourceController dataSourceController{};
                 auto uid = dataSourceController.registerDataSource(QStringLiteral("Source1"));
                 QVERIFY(!uid.isNull());
             }
             void TestDataSourceController::testSetDataSourceItem()
             {
                 DataSourceController dataSourceController{};
                 // Spy to test controllers' signals
                 QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(const DataSourceItem &))};
                 // Create a data source item
                 auto source1Name = QStringLiteral("Source1");
                 auto source1Values = QVector<QVariant>{source1Name};
-                auto source1Item = std::make_unique<DataSourceItem>(std::move(source1Values));
+                auto source1Item
+                    = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, std::move(source1Values));
                 // Add data source item to the controller and check that a signal has been emitted after setting
                 // data source item in the controller
                 auto source1Uid = dataSourceController.registerDataSource(source1Name);
                 dataSourceController.setDataSourceItem(source1Uid, std::move(source1Item));
                 QCOMPARE(signalSpy.count(), 1);
                 // Try to a data source item with an unregistered uid and check that no signal has been emitted
                 auto unregisteredUid = QUuid::createUuid();
-                dataSourceController.setDataSourceItem(unregisteredUid, std::make_unique<DataSourceItem>());
+                dataSourceController.setDataSourceItem(
+                    unregisteredUid, std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT));
                 QCOMPARE(signalSpy.count(), 1);
             }
             QTEST_MAIN(TestDataSourceController)
             #include "TestDataSourceController.moc"

core/vera-exclusions/exclusions.txt +3 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             Common/spimpl\.h:\d+:.*
+            # Ignore false positive relative to two class definitions in a same file
+            DataSourceItem\.h:\d+:.*IPSIS_S01.*

formatting/vera-exclusions/exclusions.txt +4 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             .*IPSIS_S04_METHOD.*found: Q_DECLARE_LOGGING_CATEGORY.*
             .*IPSIS_S04_VARIABLE.*found: impl.*
             # Ignore false positive relative to 'noexcept' keyword
             .*IPSIS_S04_VARIABLE.*found: noexcept
             .*IPSIS_S06.*found: noexcept
+            # Ignore false positive relative to 'override' keyword
+            .*IPSIS_S04_VARIABLE.*found: override
+            .*IPSIS_S06.*found: override

gui/vera-exclusions/exclusions.txt +4 -1

-            # Ignore false positive relative to App macro
             \.h:\d+:.IPSIS_S04.*found: ui
             qcustomplot\.h:\d+:.IPSIS
             qcustomplot\.cpp:\d+:.IPSIS
+            # Ignore false positive relative to App macro
             SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
             SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp
+            # Ignore false positive relative to unnamed namespace
+            DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages