HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r158:fd6bf22088a5

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r158:fd6bf22088a5

parent child

Context file:

r158:fd6bf22088a5

core/include/Variable/VariableController.h +4 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class Variable;
+            class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 /**
                  * Creates a new variable
                  * @param name the name of the new variable
                  * @return the variable if it was created successfully, nullptr otherwise
                  */
                 Variable *createVariable(const QString &name) noexcept;
+                VariableModel *variableModel() noexcept;
             public slots:
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h +12 -2

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
             #include <Common/spimpl.h>
+            #include <QAbstractTableModel>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
-            class VariableModel {
+            class VariableModel : public QAbstractTableModel {
             public:
-                explicit VariableModel();
+                explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @return the variable if it was created successfully, nullptr otherwise
                  */
                 Variable *createVariable(const QString &name) noexcept;
+                // /////////////////////////// //
+                // QAbstractTableModel methods //
+                // /////////////////////////// //
+                virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
+                virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
+                virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+                virtual QVariant headerData(int section, Qt::Orientation orientation,
+                                            int role = Qt::DisplayRole) const override;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLEMODEL_H

core/src/Variable/VariableController.cpp +5 0

             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <QMutex>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate()
                         : m_WorkingMutex{}, m_VariableModel{std::make_unique<VariableModel>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 std::unique_ptr<VariableModel> m_VariableModel;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>()}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             Variable *VariableController::createVariable(const QString &name) noexcept
             {
                 return impl->m_VariableModel->createVariable(name);
             }
+            VariableModel *VariableController::variableModel() noexcept
+            {
+                return impl->m_VariableModel.get();
+            }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableModel.cpp +93 -2

@@ -1,24 +1,115
1	#include <Variable/VariableModel.h>	1	#include <Variable/VariableModel.h>
2		2
3	#include <Variable/Variable.h>	3	#include <Variable/Variable.h>
4		4
5	Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")	5	Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
6		6
		7	namespace {
		8
		9	// Column indexes
		10	const auto NAME_COLUMN = 0;
		11	const auto UNIT_COLUMN = 1;
		12	const auto MISSION_COLUMN = 2;
		13	const auto NB_COLUMNS = 3;
		14
		15	} // namespace
		16
7	struct VariableModel::VariableModelPrivate {	17	struct VariableModel::VariableModelPrivate {
8	/// Variables created in SciQlop	18	/// Variables created in SciQlop
9	std::vector<std::unique_ptr<Variable> > m_Variables;	19	std::vector<std::unique_ptr<Variable> > m_Variables;
10	};	20	};
11		21
12	VariableModel::VariableModel() : impl{spimpl::make_unique_impl<VariableModelPrivate>()}	22	VariableModel::VariableModel(QObject *parent)
		23	: QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
13	{	24	{
14	}	25	}
15		26
16	Variable *VariableModel::createVariable(const QString &name) noexcept	27	Variable *VariableModel::createVariable(const QString &name) noexcept
17	{	28	{
		29	auto insertIndex = rowCount();
		30	beginInsertRows({}, insertIndex, insertIndex);
		31
18	/// @todo For the moment, the other data of the variable is initialized with default values	32	/// @todo For the moment, the other data of the variable is initialized with default values
19	auto variable	33	auto variable
20	= std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));	34	= std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
21	impl->m_Variables.push_back(std::move(variable));	35	impl->m_Variables.push_back(std::move(variable));
22		36
23	return impl->m_Variables.back().get();	37	endInsertRows();
		38
		39	return impl->m_Variables.at(insertIndex).get();
		40	}
		41
		42	int VariableModel::columnCount(const QModelIndex &parent) const
		43	{
		44	Q_UNUSED(parent);
		45
		46	return NB_COLUMNS;
		47	}
		48
		49	int VariableModel::rowCount(const QModelIndex &parent) const
		50	{
		51	Q_UNUSED(parent);
		52
		53	return impl->m_Variables.size();
		54	}
		55
		56	QVariant VariableModel::data(const QModelIndex &index, int role) const
		57	{
		58	if (!index.isValid()) {
		59	return QVariant{};
		60	}
		61
		62	if (index.row() < 0 \|\| index.row() >= rowCount()) {
		63	return QVariant{};
		64	}
		65
		66	if (role == Qt::DisplayRole) {
		67	if (auto variable = impl->m_Variables.at(index.row()).get()) {
		68	switch (index.column()) {
		69	case NAME_COLUMN:
		70	return variable->m_Name;
		71	case UNIT_COLUMN:
		72	return variable->m_Unit;
		73	case MISSION_COLUMN:
		74	return variable->m_Mission;
		75	default:
		76	// No action
		77	break;
		78	}
		79
		80	qWarning(LOG_VariableModel())
		81	<< tr("Can't get data (unknown column %1)").arg(index.column());
		82	}
		83	else {
		84	qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
		85	}
		86	}
		87
		88	return QVariant{};
		89	}
		90
		91	QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
		92	{
		93	if (role != Qt::DisplayRole) {
		94	return QVariant{};
		95	}
		96
		97	if (orientation == Qt::Horizontal) {
		98	switch (section) {
		99	case NAME_COLUMN:
		100	return tr("Name");
		101	case UNIT_COLUMN:
		102	return tr("Unit");
		103	case MISSION_COLUMN:
		104	return tr("Mission");
		105	default:
		106	// No action
		107	break;
		108	}
		109
		110	qWarning(LOG_VariableModel())
		111	<< tr("Can't get header data (unknown column %1)").arg(section);
		112	}
		113
		114	return QVariant{};
24	}	115	}

gui/src/Variable/VariableInspectorWidget.cpp +12 0

+            #include <Variable/VariableController.h>
             #include <Variable/VariableInspectorWidget.h>
+            #include <Variable/VariableModel.h>
             #include <ui_VariableInspectorWidget.h>
+            #include <QSortFilterProxyModel>
+            #include <SqpApplication.h>
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VariableInspectorWidget}
             {
                 ui->setupUi(this);
+                // Sets model for table
+                auto sortFilterModel = new QSortFilterProxyModel{this};
+                sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
+                ui->tableView->setModel(sortFilterModel);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }

gui/src/Visualization/VisualizationWidget.cpp +6 0

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 addTabViewButton->setAutoRaise(true);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
+                auto width = ui->tabWidget->cornerWidget()->width();
+                auto height = ui->tabWidget->cornerWidget()->height();
+                addTabViewButton->setMinimumHeight(height);
+                addTabViewButton->setMinimumWidth(width);
+                ui->tabWidget->setMinimumHeight(height);
+                ui->tabWidget->setMinimumWidth(width);
                 auto addTabView = [&]() {
                     auto index = ui->tabWidget->addTab(new VisualizationTabWidget(ui->tabWidget),
                                                        QString("View %1").arg(ui->tabWidget->count() + 1));
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [&](int index) {
                     ui->tabWidget->removeTab(index);
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
             }
             VisualizationWidget::~VisualizationWidget()
             {
                 delete ui;
             }
             void VisualizationWidget::addTab(VisualizationTabWidget *tabWidget)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
             VisualizationTabWidget *VisualizationWidget::createTab()
             {
             }
             void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
             void VisualizationWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }

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