GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r115:c223a438568b

Merge branch 'feature/VariableModel' into develop

Alexandre Leroux -

r115:c223a438568b

parent child

Context file:

r115:c223a438568b

Collapse all files

core/include/Variable/Variable.h created 644 +20 0

@@ -0,0 +1,20
	1	#ifndef SCIQLOP_VARIABLE_H
	2	#define SCIQLOP_VARIABLE_H
	3
	4	#include <QString>
	5
	6	/**
	7	* @brief The Variable struct represents a variable in SciQlop.
	8	*/
	9	struct Variable {
	10	explicit Variable(const QString &name, const QString &unit, const QString &mission)
	11	: m_Name{name}, m_Unit{unit}, m_Mission{mission}
	12	{
	13	}
	14
	15	QString m_Name;
	16	QString m_Unit;
	17	QString m_Mission;
	18	};
	19
	20	#endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableController.h created 644 +39 0

@@ -0,0 +1,39
	1	#ifndef SCIQLOP_VARIABLECONTROLLER_H
	2	#define SCIQLOP_VARIABLECONTROLLER_H
	3
	4	#include <QLoggingCategory>
	5	#include <QObject>
	6
	7	#include <Common/spimpl.h>
	8
	9	class Variable;
	10	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
	11
	12	/**
	13	* @brief The VariableController class aims to handle the variables in SciQlop.
	14	*/
	15	class VariableController : public QObject {
	16	Q_OBJECT
	17	public:
	18	explicit VariableController(QObject *parent = 0);
	19	virtual ~VariableController();
	20
	21	/**
	22	* Creates a new variable
	23	* @param name the name of the new variable
	24	* @return the variable if it was created successfully, nullptr otherwise
	25	*/
	26	Variable *createVariable(const QString &name) noexcept;
	27
	28	public slots:
	29	void initialize();
	30	void finalize();
	31
	32	private:
	33	void waitForFinish();
	34
	35	class VariableControllerPrivate;
	36	spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
	37	};
	38
	39	#endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h created 644 +31 0

@@ -0,0 +1,31
	1	#ifndef SCIQLOP_VARIABLEMODEL_H
	2	#define SCIQLOP_VARIABLEMODEL_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7
	8	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
	9
	10	class Variable;
	11
	12	/**
	13	* @brief The VariableModel class aims to hold the variables that have been created in SciQlop
	14	*/
	15	class VariableModel {
	16	public:
	17	explicit VariableModel();
	18
	19	/**
	20	* Creates a new variable in the model
	21	* @param name the name of the new variable
	22	* @return the variable if it was created successfully, nullptr otherwise
	23	*/
	24	Variable *createVariable(const QString &name) noexcept;
	25
	26	private:
	27	class VariableModelPrivate;
	28	spimpl::unique_impl_ptr<VariableModelPrivate> impl;
	29	};
	30
	31	#endif // SCIQLOP_VARIABLEMODEL_H

core/src/Variable/VariableController.cpp created 644 +53 0

@@ -0,0 +1,53
	1	#include <Variable/VariableController.h>
	2	#include <Variable/VariableModel.h>
	3
	4	#include <QMutex>
	5	#include <QThread>
	6
	7	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
	8
	9	struct VariableController::VariableControllerPrivate {
	10	explicit VariableControllerPrivate()
	11	: m_WorkingMutex{}, m_VariableModel{std::make_unique<VariableModel>()}
	12	{
	13	}
	14
	15	QMutex m_WorkingMutex;
	16	std::unique_ptr<VariableModel> m_VariableModel;
	17	};
	18
	19	VariableController::VariableController(QObject *parent)
	20	: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>()}
	21	{
	22	qCDebug(LOG_VariableController())
	23	<< tr("VariableController construction") << QThread::currentThread();
	24	}
	25
	26	VariableController::~VariableController()
	27	{
	28	qCDebug(LOG_VariableController())
	29	<< tr("VariableController destruction") << QThread::currentThread();
	30	this->waitForFinish();
	31	}
	32
	33	Variable *VariableController::createVariable(const QString &name) noexcept
	34	{
	35	return impl->m_VariableModel->createVariable(name);
	36	}
	37
	38	void VariableController::initialize()
	39	{
	40	qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
	41	impl->m_WorkingMutex.lock();
	42	qCDebug(LOG_VariableController()) << tr("VariableController init END");
	43	}
	44
	45	void VariableController::finalize()
	46	{
	47	impl->m_WorkingMutex.unlock();
	48	}
	49
	50	void VariableController::waitForFinish()
	51	{
	52	QMutexLocker locker{&impl->m_WorkingMutex};
	53	}

core/src/Variable/VariableModel.cpp created 644 +24 0

@@ -0,0 +1,24
	1	#include <Variable/VariableModel.h>
	2
	3	#include <Variable/Variable.h>
	4
	5	Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
	6
	7	struct VariableModel::VariableModelPrivate {
	8	/// Variables created in SciQlop
	9	std::vector<std::unique_ptr<Variable> > m_Variables;
	10	};
	11
	12	VariableModel::VariableModel() : impl{spimpl::make_unique_impl<VariableModelPrivate>()}
	13	{
	14	}
	15
	16	Variable *VariableModel::createVariable(const QString &name) noexcept
	17	{
	18	/// @todo For the moment, the other data of the variable is initialized with default values
	19	auto variable
	20	= std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
	21	impl->m_Variables.push_back(std::move(variable));
	22
	23	return impl->m_Variables.back().get();
	24	}

gui/include/Variable/VariableInspectorWidget.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef SCIQLOP_VARIABLEINSPECTORWIDGET_H
	2	#define SCIQLOP_VARIABLEINSPECTORWIDGET_H
	3
	4	#include <QWidget>
	5
	6	namespace Ui {
	7	class VariableInspectorWidget;
	8	} // Ui
	9
	10	/**
	11	* @brief The VariableInspectorWidget class representes represents the variable inspector, from
	12	* which it is possible to view the loaded variables, handle them or trigger their display in
	13	* visualization
	14	*/
	15	class VariableInspectorWidget : public QWidget {
	16	Q_OBJECT
	17
	18	public:
	19	explicit VariableInspectorWidget(QWidget *parent = 0);
	20	virtual ~VariableInspectorWidget();
	21
	22	private:
	23	Ui::VariableInspectorWidget *ui;
	24	};
	25
	26	#endif // SCIQLOP_VARIABLEINSPECTORWIDGET_H

gui/src/Variable/VariableInspectorWidget.cpp created 644 +14 0

@@ -0,0 +1,14
	1	#include <Variable/VariableInspectorWidget.h>
	2
	3	#include <ui_VariableInspectorWidget.h>
	4
	5	VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
	6	: QWidget{parent}, ui{new Ui::VariableInspectorWidget}
	7	{
	8	ui->setupUi(this);
	9	}
	10
	11	VariableInspectorWidget::~VariableInspectorWidget()
	12	{
	13	delete ui;
	14	}

gui/ui/Variable/VariableInspectorWidget.ui created 644 +31 0

@@ -0,0 +1,31
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>VariableInspectorWidget</class>
	4	<widget class="QWidget" name="VariableInspectorWidget">
	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>Variables</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QTableView" name="tableView">
	19	<property name="sortingEnabled">
	20	<bool>true</bool>
	21	</property>
	22	<attribute name="horizontalHeaderStretchLastSection">
	23	<bool>true</bool>
	24	</attribute>
	25	</widget>
	26	</item>
	27	</layout>
	28	</widget>
	29	<resources/>
	30	<connections/>
	31	</ui>

app/ui/MainWindow.ui +8 -2

             <?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>0</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="QSplitter" name="splitter">
                   <property name="orientation">
                    <enum>Qt::Horizontal</enum>
                   </property>
                   <widget class="QWidget" name="leftMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout">
                     <property name="spacing">
                      <number>0</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="DataSourceWidget" name="dataSourceWidget" native="true"/>
                     </item>
                     <item>
                      <widget class="QWidget" name="dateTimeWidget" native="true"/>
                     </item>
                     <item>
-                     <widget class="QWidget" name="variableInspectorWidget" native="true"/>
+                     <widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
                     </item>
                    </layout>
                   </widget>
                   <widget class="SqpSidePane" name="leftInspectorSidePane" native="true"/>
                   <widget class="VisualizationWidget" name="view" native="true">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                   </widget>
                   <widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
                   <widget class="QWidget" name="rightMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout_3">
                     <property name="spacing">
                      <number>0</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="DataSourceWidget" name="catalogWidget" native="true"/>
                     </item>
                    </layout>
                   </widget>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>800</width>
-                 <height>28</height>
+                 <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>
+              <customwidget>
+               <class>VariableInspectorWidget</class>
+               <extends>QWidget</extends>
+               <header location="global">Variable/VariableInspectorWidget.h</header>
+               <container>1</container>
+              </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/include/DataSource/DataSourceWidget.h +5 -4

             #ifndef SCIQLOP_DATASOURCEWIDGET_H
             #define SCIQLOP_DATASOURCEWIDGET_H
-            #include <Common/spimpl.h>
             #include <QWidget>
+            namespace Ui {
+            class DataSourceWidget;
+            } // Ui
             class DataSourceItem;
             /**
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
             class DataSourceWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit DataSourceWidget(QWidget *parent = 0);
             public slots:
                 /**
                  * Adds a data source. An item associated to the data source is created and then added to the
                  * representation tree
                  * @param dataSource the data source to add. The pointer has to be not null
                  */
                 void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
-                class DataSourceWidgetPrivate;
+                Ui::DataSourceWidget *ui;
-                spimpl::unique_impl_ptr<DataSourceWidgetPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEWIDGET_H

gui/include/SqpApplication.h +2 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
+            class VariableController;
             class VisualizationController;
             /**
              * @brief The SqpApplication 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 load 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 SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() const noexcept;
+                VariableController &variableController() const noexcept;
                 VisualizationController &visualizationController() const noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/src/DataSource/DataSourceWidget.cpp +5 -16

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             namespace {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem{dataSource};
                 // Generates items for the children of the data source
                 for (auto i = 0; i < dataSource->childCount(); ++i) {
                     item->addChild(createTreeWidgetItem(dataSource->child(i)));
                 }
                 return item;
             }
             } // namespace
-            class DataSourceWidget::DataSourceWidgetPrivate {
+            DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
-            public:
-                explicit DataSourceWidgetPrivate(DataSourceWidget &widget)
-                        : m_Ui{std::make_unique<Ui::DataSourceWidget>()}
             {
-                    m_Ui->setupUi(&widget);
+                ui->setupUi(this);
                 // Set tree properties
-                    m_Ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
+                ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
-                    m_Ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
+                ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
-                std::unique_ptr<Ui::DataSourceWidget> m_Ui;
-            };
-            DataSourceWidget::DataSourceWidget(QWidget *parent)
-                    : QWidget{parent}, impl{spimpl::make_unique_impl<DataSourceWidgetPrivate>(*this)}
             }
             void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
             {
                 // Creates the item associated to the source and adds it to the tree widget. The tree widget
                 // takes the ownership of the item
                 if (dataSource) {
-                    impl->m_Ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
+                    ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
                 }
             }

gui/src/SqpApplication.cpp +19 0

             #include "SqpApplication.h"
             #include <DataSource/DataSourceController.h>
             #include <QThread>
+            #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
+                          m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                    m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
+                    m_VariableControllerThread.quit();
+                    m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
+                std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
+                QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
+                connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
+                        &VariableController::initialize);
+                connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
+                        &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
+                impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() const noexcept
             {
                 return *impl->m_DataSourceController;
             }
+            VariableController &SqpApplication::variableController() const noexcept
+            {
+                return *impl->m_VariableController;
+            }
             VisualizationController &SqpApplication::visualizationController() const noexcept
             {
                 return *impl->m_VisualizationController;
             }

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