HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r403:756d172725c6

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r403:756d172725c6

parent child

Context file:

r403:756d172725c6

Collapse all files

core/include/Network/NetworkController.h +4 -1

                 void finalize();
             public slots:
+                /// Execute request and call callback when the reply is finished. Identifier is attached to the
+                /// callback
                 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
+                /// Cancel the request of identifier
                 void onReplyCanceled(QUuid identifier);
             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
-                void replyDownloadProgress(QUuid identifier);
+                void replyDownloadProgress(QUuid identifier, double progress);
             private:
                 void waitForFinish();

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

                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
+                void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
                 void initialize();
                 void finalize();

core/include/Variable/VariableModel.h +7 0

             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
+            enum VariableRoles { ProgressRole = Qt::UserRole };
             class IDataSeries;
             class Variable;
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
+                void setDataProgress(std::shared_ptr<Variable> variable, double progress);
                 // /////////////////////////// //
                 // 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;

core/src/Network/NetworkController.cpp +6 -7

             void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                                        std::function<void(QNetworkReply *, QUuid)> callback)
             {
-                qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
+                qCInfo(LOG_NetworkController()) << tr("NetworkController registered")
                                                 << QThread::currentThread();
                 auto reply = impl->m_AccessManager->get(request);
                 auto onReplyFinished = [reply, this, identifier, callback]() {
-                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
+                    qCInfo(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
                                                     << QThread::currentThread();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
                     }
                 };
-                auto onReplyDownloadProgress = [reply, this]() {
+                auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
-                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyDownloadProgress")
+                    double progress = (bytesRead * 100.0) / totalBytes;
-                                                     << QThread::currentThread();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
-                        emit this->replyDownloadProgress(it->second);
+                        emit this->replyDownloadProgress(it->second, progress);
                     }
                 };
                 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
-                connect(reply, &QNetworkReply::downloadProgress, this, onReplyDownloadProgress);
+                connect(reply, &QNetworkReply::downloadProgress, this, onReplyProgress);
             }
             void NetworkController::initialize()

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

@@ -157,6 +157,17 void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
157	}	157	}
158	}	158	}
159		159
		160	void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
		161	{
		162	auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
		163
		164	auto end = impl->m_VariableToIdentifier.cend();
		165	auto it = std::find_if(impl->m_VariableToIdentifier.cbegin(), end, findReply);
		166	if (it != end) {
		167	impl->m_VariableModel->setDataProgress(it->first, progress);
		168	}
		169	}
		170
160		171
161	void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,	172	void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
162	const SqpDateTime &dateTime)	173	const SqpDateTime &dateTime)

core/src/Variable/VariableModel.cpp +44 -8

             #include <QDateTime>
             #include <QSize>
+            #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
+                std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
+                /// Return the row index of the variable. -1 if it's not found
+                int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                 }
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
+            void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
+            {
+                impl->m_VariableToProgress[variable] = progress;
+                auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
+                emit dataChanged(modelIndex, modelIndex);
+            }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
+                else if (role == VariableRoles::ProgressRole) {
+                    if (auto variable = impl->m_Variables.at(index.row())) {
+                        auto it = impl->m_VariableToProgress.find(variable);
+                        if (it != impl->m_VariableToProgress.cend()) {
+                            return it->second;
+                        }
+                    }
+                }
                 return QVariant{};
             }
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
-                    auto begin = std::cbegin(impl->m_Variables);
+                    auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
-                    auto end = std::cend(impl->m_Variables);
-                    auto it = std::find_if(begin, end, [updatedVariable](const auto &variable) {
+                    if (updatedVariableIndex > -1) {
-                        return variable.get() == updatedVariable;
+                        emit dataChanged(createIndex(updatedVariableIndex, 0),
-                    });
+                                         createIndex(updatedVariableIndex, columnCount() - 1));
+                    }
+                }
+            }
+            int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
+            {
+                auto begin = std::cbegin(m_Variables);
+                auto end = std::cend(m_Variables);
+                auto it
+                    = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
-                        auto updateVariableIndex = std::distance(begin, it);
+                    return std::distance(begin, it);
-                        emit dataChanged(createIndex(updateVariableIndex, 0),
-                                         createIndex(updateVariableIndex, columnCount() - 1));
                 }
+                else {
+                    return -1;
                 }
             }

gui/include/Variable/VariableInspectorWidget.h +4 0

             class Variable;
+            class QProgressBarItemDelegate;
             namespace Ui {
             class VariableInspectorWidget;
             } // Ui
             private:
                 Ui::VariableInspectorWidget *ui;
+                QProgressBarItemDelegate *m_ProgressBarItemDelegate;
             private slots:
                 /// Slot called when right clicking on an variable in the table (displays a menu)
                 void onTableMenuRequested(const QPoint &pos) noexcept;

gui/src/SqpApplication.cpp +5 0

                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
+                // Core connections:
+                // NetworkController <-> VariableController
+                connect(&sqpApp->networkController(), &NetworkController::replyDownloadProgress,
+                        &sqpApp->variableController(), &VariableController::onVariableRetrieveDataInProgress);
             }
             SqpApplication::~SqpApplication()

gui/src/Variable/VariableInspectorWidget.cpp +40 -1

@@ -6,14 +6,52
6	#include <ui_VariableInspectorWidget.h>	6	#include <ui_VariableInspectorWidget.h>
7		7
8	#include <QSortFilterProxyModel>	8	#include <QSortFilterProxyModel>
		9	#include <QStyledItemDelegate>
9	#include <QWidgetAction>	10	#include <QWidgetAction>
10		11
11	#include <SqpApplication.h>	12	#include <SqpApplication.h>
12		13
13	Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")	14	Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
14		15
		16
		17	class QProgressBarItemDelegate : public QStyledItemDelegate {
		18
		19	public:
		20	QProgressBarItemDelegate(QObject *parent) : QStyledItemDelegate{parent} {}
		21
		22	void paint(QPainter *painter, const QStyleOptionViewItem &option,
		23	const QModelIndex &index) const
		24	{
		25	auto data = index.data(Qt::DisplayRole);
		26	auto progressData = index.data(VariableRoles::ProgressRole);
		27	if (data.isValid() && progressData.isValid()) {
		28	auto name = data.value<QString>();
		29	auto progress = progressData.value<double>();
		30	if (progress >= 0) {
		31	auto progressBarOption = QStyleOptionProgressBar{};
		32	progressBarOption.rect = option.rect;
		33	progressBarOption.minimum = 0;
		34	progressBarOption.maximum = 100;
		35	progressBarOption.progress = progress;
		36	progressBarOption.text
		37	= QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
		38	progressBarOption.textVisible = true;
		39	progressBarOption.textAlignment = Qt::AlignCenter;
		40
		41	QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
		42	painter);
		43	}
		44	}
		45	else {
		46	QStyledItemDelegate::paint(painter, option, index);
		47	}
		48	}
		49	};
		50
15	VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)	51	VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
16	: QWidget{parent}, ui{new Ui::VariableInspectorWidget}	52	: QWidget{parent},
		53	ui{new Ui::VariableInspectorWidget},
		54	m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
17	{	55	{
18	ui->setupUi(this);	56	ui->setupUi(this);
19		57
@@ -30,6 +68,7 VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
30	SLOT(refresh()));	68	SLOT(refresh()));
31		69
32	ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());	70	ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
		71	ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
33		72
34	// Fixes column sizes	73	// Fixes column sizes
35	auto model = ui->tableView->model();	74	auto model = ui->tableView->model();

plugins/amda/src/AmdaResultParser.cpp +2 0

             #include <QFile>
             #include <QRegularExpression>
+            #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {

plugins/amda/tests/TestAmdaResultParser.cpp +2 -2

                            QVector<double>{-2.71850, -2.52150}};
                 // Invalid file
-                QTest::newRow("Invalid file (unexisting file)")
+                QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
-                    << QStringLiteral("UnexistingFile.txt") << ExpectedResults{};
+                                                                << ExpectedResults{};
             }
             void TestAmdaResultParser::testReadTxt()

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