HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1348:ea7d1a66f4ab

All the codebase is modified to build with new Variable Controller...

jeandet -

r1348:ea7d1a66f4ab

parent child

Context file:

r1348:ea7d1a66f4ab

CMakeLists.txt +7 -1

             enable_testing()
-            add_subdirectory(core)
+            find_package(core CONFIG QUIET)
+            if (NOT sciqlopcore_FOUND)
+                execute_process(COMMAND git submodule init core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+                execute_process(COMMAND git submodule update core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+                add_subdirectory(core)
+            endif()
             add_subdirectory(gui)
             add_subdirectory(app)
             add_subdirectory(plugins)

app/src/MainWindow.cpp +2 -2

                 // /////////// //
                 // Controllers / controllers connections
-                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->variableController(),
+            //    connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->variableController(),
-                        SLOT(onDateTimeOnSelection(DateTimeRange)));
+            //            SLOT(onDateTimeOnSelection(DateTimeRange)));
                 // Widgets / controllers connections

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 5a50815a763fb421298a06a6d0380b8f5364e7cd		1	Subproject commit 5f4f9560990ba00394322fa1d06d4a30feaf7075

gui/include/SqpApplication.h +7 -2

             class NetworkController;
             class TimeController;
             class VariableController;
+            class VariableController2;
+            class VariableModel2;
             class VisualizationController;
             class DragDropGuiController;
             class ActionsGuiController;
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
-                virtual ~SqpApplication();
+                 ~SqpApplication() override;
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
                 NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
-                VariableController &variableController() noexcept;
+                VariableController2 &variableController() noexcept;
+                std::shared_ptr<VariableController2> variableControllerOwner() noexcept;
+                //@TODO there should not be any global model it's just GUI impl detail
+            //    VariableModel2 &variableModel() noexcept;
                 VisualizationController &visualizationController() noexcept;
                 CatalogueController &catalogueController() noexcept;

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

             #include <memory>
+            #include <Variable/VariableModel2.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableInspectorWidget)
             class Variable;
                 Ui::VariableInspectorWidget *ui;
                 QProgressBarItemDelegate *m_ProgressBarItemDelegate;
+                VariableModel2* m_model;
             private slots:
                 /// Slot called when right clicking on an variable in the table (displays a menu)

gui/include/Visualization/VisualizationGraphWidget.h +1 -1

                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// Returns the list of all variables used in the graph
-                QList<std::shared_ptr<Variable> > variables() const;
+                std::vector<std::shared_ptr<Variable> > variables() const;
                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);

gui/include/Visualization/VisualizationTabWidget.h +1 -1

                  * @param index The index where the zone should be inserted in the layout
                  * @return the pointer to the created zone
                  */
-                VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
+                VisualizationZoneWidget *createZone(const std::vector<std::shared_ptr<Variable> > &variables,
                                                     int index);
                 /**

gui/include/Visualization/VisualizationZoneWidget.h +1 -1

                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
-                VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
+                VisualizationGraphWidget *createGraph( std::vector<std::shared_ptr<Variable> > variables,
                                                       int index);
                 /// Returns the first graph in the zone or nullptr if there is no graph inside

gui/src/Catalogue/CatalogueEventsWidget.cpp +5 -6

             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
                     // Closes the previous graph and delete the asociated variables
                     for (auto graph : m_CustomGraphs) {
                         graph->close();
-                        auto variables = graph->variables().toVector();
+                        auto variables = graph->variables();
+                        for(const auto& variable:variables)
-                        QMetaObject::invokeMethod(&sqpApp->variableController(), "deleteVariables",
+                            sqpApp->variableController().deleteVariable(variable);
-                                                  Qt::QueuedConnection,
-                                                  Q_ARG(QVector<std::shared_ptr<Variable> >, variables));
                     }
                     m_CustomGraphs.clear();
                         auto context = new QObject{catalogueEventWidget};
                         QObject::connect(
-                            &sqpApp->variableController(), &VariableController::variableAdded, context,
+                            &sqpApp->variableController(), &VariableController2::variableAdded, context,
                             [this, catalogueEventWidget, zone, context, event, range, productRange,
                              productId](auto variable) {

gui/src/DragAndDrop/DragDropGuiController.cpp +4 -4

             #include "DataSource/DataSourceController.h"
             #include "Variable/Variable.h"
-            #include "Variable/VariableController.h"
+            #include "Variable/VariableController2.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                    auto variables = sqpApp->variableController().variablesForMimeData(
+                    auto variables = sqpApp->variableController().variables(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
-                    if (variables.count() == 1) {
+                    if (variables.size() == 1) {
-                        auto variable = variables.first();
+                        auto variable = variables[0];
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph

gui/src/SqpApplication.cpp +52 -57

             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
+            #include <Variable/VariableModel2.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
-                        : m_DataSourceController{std::make_unique<DataSourceController>()},
+                        : m_VariableController{std::make_shared<VariableController2>()},
-                          m_VariableController{std::make_unique<VariableController>()},
+                          m_VariableModel{m_VariableController},
-                          m_TimeController{std::make_unique<TimeController>()},
-                          m_NetworkController{std::make_unique<NetworkController>()},
-                          m_VisualizationController{std::make_unique<VisualizationController>()},
-                          m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
-                          m_CatalogueController{std::make_unique<CatalogueController>()},
-                          m_ActionsGuiController{std::make_unique<ActionsGuiController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
-                    connect(m_DataSourceController.get(),
+                    connect(&m_DataSourceController,
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
-                    connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
+            //        connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
-                            m_DataSourceController.get(), &DataSourceController::requestVariable);
+            //                m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
-                    connect(m_VariableController.get(),
+            //        connect(m_VariableController.get(),
-                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
+            //                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
-                            m_VisualizationController.get(),
+            //                m_VisualizationController.get(),
-                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
+            //                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
-                    connect(m_VariableController.get(),
+            //        connect(m_VariableController.get(),
-                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
+            //                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
-                            m_VisualizationController.get(),
+            //                m_VisualizationController.get(),
-                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
+            //                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
-                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                    m_DataSourceController.moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
-                    m_NetworkController->moveToThread(&m_NetworkControllerThread);
+                    m_NetworkController.moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
-                    m_VariableController->moveToThread(&m_VariableControllerThread);
+                    m_VisualizationController.moveToThread(&m_VisualizationControllerThread);
-                    m_VariableControllerThread.setObjectName("VariableControllerThread");
-                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
-                    m_VariableControllerThread.quit();
-                    m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
-                std::unique_ptr<DataSourceController> m_DataSourceController;
+                DataSourceController m_DataSourceController;
-                std::unique_ptr<VariableController> m_VariableController;
+                std::shared_ptr<VariableController2> m_VariableController;
-                std::unique_ptr<TimeController> m_TimeController;
+                TimeController m_TimeController;
-                std::unique_ptr<NetworkController> m_NetworkController;
+                NetworkController m_NetworkController;
-                std::unique_ptr<VisualizationController> m_VisualizationController;
+                VisualizationController m_VisualizationController;
-                std::unique_ptr<CatalogueController> m_CatalogueController;
+                CatalogueController m_CatalogueController;
+                VariableModel2 m_VariableModel;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
-                QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
-                std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
+                DragDropGuiController m_DragDropGuiController;
-                std::unique_ptr<ActionsGuiController> m_ActionsGuiController;
+                ActionsGuiController m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
-                        impl->m_DataSourceController.get(), &DataSourceController::initialize);
+                        &impl->m_DataSourceController, &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
-                        impl->m_DataSourceController.get(), &DataSourceController::finalize);
+                        &impl->m_DataSourceController, &DataSourceController::finalize);
-                connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
+                connect(&impl->m_NetworkControllerThread, &QThread::started, &impl->m_NetworkController,
                         &NetworkController::initialize);
-                connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
+                connect(&impl->m_NetworkControllerThread, &QThread::finished, &impl->m_NetworkController,
                         &NetworkController::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);
+                        &impl->m_VisualizationController, &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
-                        impl->m_VisualizationController.get(), &VisualizationController::finalize);
+                        &impl->m_VisualizationController, &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
-                impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
-                impl->m_CatalogueController->initialize();
+                impl->m_CatalogueController.initialize();
             }
             SqpApplication::~SqpApplication()
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
-                return *impl->m_DataSourceController;
+                return impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
-                return *impl->m_NetworkController;
+                return impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
-                return *impl->m_TimeController;
+                return impl->m_TimeController;
             }
-            VariableController &SqpApplication::variableController() noexcept
+            VariableController2 &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
+            std::shared_ptr<VariableController2> SqpApplication::variableControllerOwner() noexcept
+            {
+                return impl->m_VariableController;
+            }
+            //VariableModel2 &SqpApplication::variableModel() noexcept
+            //{
+            //    return impl->m_VariableModel;
+            //}
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
-                return *impl->m_VisualizationController;
+                return impl->m_VisualizationController;
             }
             CatalogueController &SqpApplication::catalogueController() noexcept
             {
-                return *impl->m_CatalogueController;
+                return impl->m_CatalogueController;
             }
             DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
             {
-                return *impl->m_DragDropGuiController;
+                return impl->m_DragDropGuiController;
             }
             ActionsGuiController &SqpApplication::actionsGuiController() noexcept
             {
-                return *impl->m_ActionsGuiController;
+                return impl->m_ActionsGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const

gui/src/Variable/VariableInspectorWidget.cpp +14 -13

             #include <Variable/RenameVariableDialog.h>
             #include <Variable/Variable.h>
-            #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
-            #include <Variable/VariableModel.h>
+            #include <Variable/VariableModel2.h>
             #include <ui_VariableInspectorWidget.h>
                             if (clickX > x && clickX < x + w) {
                                 if (clickY > y && clickY < y + h) {
-                                    auto variableModel = sqpApp->variableController().variableModel();
+                                    //auto& variableModel = sqpApp->variableModel();
-                                    variableModel->abortProgress(index);
+                                    //variableModel->abortProgress(index);
                                 }
                                 return true;
                             }
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
-                auto variableModel = sqpApp->variableController().variableModel();
+                m_model = new VariableModel2(sqpApp->variableControllerOwner());
-                ui->tableView->setModel(variableModel);
+                ui->tableView->setModel(m_model);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
-                connect(variableModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
+                connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
                         SLOT(refresh()));
-                ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
+                //ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
-                auto model = sqpApp->variableController().variableModel();
+                auto& vc = sqpApp->variableController();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
-                    if (auto selectedVariable = model->variable(selectedRow.row())) {
+                    if (auto selectedVariable = vc[selectedRow.row()]) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                         tableMenu.addAction(tr("Duplicate"), duplicateFun);
-                        auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), &model, this ]()
+                        auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), this ]()
                         {
                             if (auto var = varW.lock()) {
                                 // Generates forbidden names (names associated to existing variables)
-                                auto allVariables = model->variables();
+                                auto allVariables = sqpApp->variableController().variables();
                                 auto forbiddenNames = QVector<QString>(allVariables.size());
                                 std::transform(allVariables.cbegin(), allVariables.cend(),
                                                forbiddenNames.begin(),
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
-                        sqpApp->variableController().deleteVariables(selectedVariables);
+                        for(const auto& var:selectedVariables)
+                            sqpApp->variableController().deleteVariable(var);
                     };
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);

gui/src/Visualization/VisualizationGraphWidget.cpp +8 -7

                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
-                connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+                //@TODO implement this :)
-                        &VariableController::onRequestDataLoading);
+            //    connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+            //            &VariableController::onRequestDataLoading);
-                connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
+            //    connect(&sqpApp->variableController(), &VariableController2::updateVarDisplaying, this,
-                        &VisualizationGraphWidget::onUpdateVarDisplaying);
+            //            &VisualizationGraphWidget::onUpdateVarDisplaying);
                 // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                 plot().setPlottingHint(QCP::phFastPolylines, true);
                 ui->widget->replot();
             }
-            QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
+            std::vector<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
-                auto variables = QList<std::shared_ptr<Variable> >{};
+                auto variables = std::vector<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
-                    variables << it->first;
+                    variables.push_back (it->first);
                 }
                 return variables;

gui/src/Visualization/VisualizationTabWidget.cpp +8 -8

             #include "Visualization/MacScrollBarStyle.h"
             #include "DataSource/DataSourceController.h"
-            #include "Variable/VariableController.h"
+            #include "Variable/VariableController2.h"
             #include "Common/MimeTypesDef.h"
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
-                void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
+                void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
                 void dropProducts(const QVariantList &productsMetaData, int index,
                                   VisualizationTabWidget *tabWidget);
             }
             VisualizationZoneWidget *
-            VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
+            VisualizationTabWidget::createZone(const std::vector<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                    auto variables = sqpApp->variableController().variablesForMimeData(
+                    auto variables = sqpApp->variableController().variables(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 const auto &variables = graphWidget->variables();
-                if (!variables.isEmpty()) {
+                if (!variables.empty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
-                const QList<std::shared_ptr<Variable> > &variables, int index,
+                const std::vector<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (variables.count() > 1) {
+                if (variables.size() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                 }
                 auto context = new QObject{tabWidget};
-                connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+                connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, index, tabWidget, context](auto variable) {
                             tabWidget->createZone({variable}, index);
                             delete context; // removes the connection

gui/src/Visualization/VisualizationZoneWidget.cpp +23 -53

             #include "Common/VisualizationDef.h"
             #include <Data/DateTimeRange.h>
+            #include <Data/DateTimeRangeHelper.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
-            #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <Visualization/operations/FindVariableOperation.h>
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
-                void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
+                void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
                 void dropProducts(const QVariantList &productsData, int index,
                                   VisualizationZoneWidget *zoneWidget);
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                        auto variables = sqpApp->variableController().variablesForMimeData(
+                        auto variables = sqpApp->variableController().variables(
                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
-                        if (variables.count() != 1) {
+                        if (variables.size() != 1) {
                             return false;
                         }
-                        auto variable = variables.first();
+                        auto variable = variables.front();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                 auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
                                                                  const DateTimeRange &oldGraphRange) {
-                    auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
+                    auto zoomType = DateTimeRangeHelper::getTransformationType(oldGraphRange, graphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
-                                case AcquisitionZoomType::ZoomIn: {
+                                case TransformationType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                                           << deltaLeft;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                                           << deltaRight;
-                                    qCDebug(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
-                                case AcquisitionZoomType::ZoomOut: {
+                                case TransformationType::ZoomOut: {
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                                           << deltaLeft;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                                           << deltaRight;
-                                    qCDebug(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
-                                case AcquisitionZoomType::PanRight: {
+                                case TransformationType::PanRight: {
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
-                                    qCDebug(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
-                                case AcquisitionZoomType::PanLeft: {
+                                case TransformationType::PanLeft: {
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
-                                case AcquisitionZoomType::Unknown: {
+                                case TransformationType::Unknown: {
-                                    qCDebug(LOG_VisualizationZoneWidget())
-                                        << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     break;
                             }
                             graphChild->setFlags(GraphFlag::DisableAll);
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                                   << graphChild->graphRange();
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                                   << graphChildRange;
-                            qCDebug(LOG_VisualizationZoneWidget())
-                                << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->setFlags(GraphFlag::EnableAll);
                         }
             }
             VisualizationGraphWidget *
-            VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
+            VisualizationZoneWidget::createGraph(const std::vector<std::shared_ptr<Variable> > variables, int index)
             {
-                if (variables.isEmpty()) {
+                if (variables.empty()) {
                     return nullptr;
                 }
-                auto graphWidget = createGraph(variables.first(), index);
+                auto graphWidget = createGraph(variables.front(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                    auto variables = sqpApp->variableController().variablesForMimeData(
+                    auto variables = sqpApp->variableController().variables(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                    auto variables = sqpApp->variableController().variablesForMimeData(
+                    auto variables = sqpApp->variableController().variables(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject{this};
-                    connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+                    connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                             [this, graphWidget, context](auto variable) {
                                 graphWidget->addVariable(variable, graphWidget->graphRange());
                                 delete context; // removes the connection
                 const auto &variables = graphWidget->variables();
-                if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
+                if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.empty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
-                    if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
+                    if (variables.empty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
-                const QList<std::shared_ptr<Variable> > &variables, int index,
+                const std::vector<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (variables.count() > 1) {
+                if (variables.size() > 1) {
-                    qCWarning(LOG_VisualizationZoneWidget())
-                        << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
-                              "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }
                 }
                 auto context = new QObject{zoneWidget};
-                connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+                connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, index, zoneWidget, context](auto variable) {
                             zoneWidget->createGraph(variable, index);
                             delete context; // removes the connection

plugins/amda/tests/PyTestAmdaWrapper.cpp +33 -33

@@ -30,7 +30,7
30	#include <pybind11/chrono.h>	30	#include <pybind11/chrono.h>
31		31
32	#include <SqpApplication.h>	32	#include <SqpApplication.h>
33	#include <Variable/VariableController.h>	33	#include <Variable/VariableController2.h>
34	#include <Time/TimeController.h>	34	#include <Time/TimeController.h>
35	#include <Data/DateTimeRange.h>	35	#include <Data/DateTimeRange.h>
36	#include <Data/DataSeriesType.h>	36	#include <Data/DataSeriesType.h>
@@ -73,38 +73,38 PYBIND11_MODULE(pytestamda, m){
73		73
74	m.doc() = "hello";	74	m.doc() = "hello";
75		75
76	py::class_<VariableController>(m, "VariableController")	76	// py::class_<VariableController>(m, "VariableController")
77	.def_static("createVariable",[](const QString &name,	77	// .def_static("createVariable",[](const QString &name,
78	std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){	78	// std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
79	return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);	79	// return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
80	})	80	// })
81	.def_static("hasPendingDownloads",	81	// .def_static("hasPendingDownloads",
82	[](){return sqpApp->variableController().hasPendingDownloads();}	82	// [](){return sqpApp->variableController().hasPendingDownloads();}
83	)	83	// )
84	.def_static("addSynchronizationGroup",	84	// .def_static("addSynchronizationGroup",
85	[](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}	85	// [](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}
86	)	86	// )
87	.def_static("removeSynchronizationGroup",	87	// .def_static("removeSynchronizationGroup",
88	[](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}	88	// [](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}
89	)	89	// )
90	.def_static("synchronizeVar",	90	// .def_static("synchronizeVar",
91	[](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}	91	// [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}
92	)	92	// )
93	.def_static("deSynchronizeVar",	93	// .def_static("deSynchronizeVar",
94	[](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}	94	// [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}
95	)	95	// )
96	.def_static("deleteVariable",	96	// .def_static("deleteVariable",
97	[](std::shared_ptr<Variable> variable){	97	// [](std::shared_ptr<Variable> variable){
98	sqpApp->variableController().deleteVariable(variable);}	98	// sqpApp->variableController().deleteVariable(variable);}
99	)	99	// )
100	.def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){	100	// .def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){
101	sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);	101	// sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
102	})	102	// })
103	.def_static("wait_for_downloads",[](){	103	// .def_static("wait_for_downloads",[](){
104	while (sqpApp->variableController().hasPendingDownloads()) {	104	// while (sqpApp->variableController().hasPendingDownloads()) {
105	usleep(100);	105	// usleep(100);
106	}	106	// }
107	});	107	// });
108		108
109	py::class_<TimeController>(m,"TimeController")	109	py::class_<TimeController>(m,"TimeController")
110	.def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});	110	.def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});

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

             #include <Data/ScalarSeries.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
-            #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <QObject>
             #include <QtTest>
                 QFETCH(std::vector<DateTimeRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
-                    sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+                    sqpApp->variableController().changeRange({variable}, operation);
                     QTest::qWait(OPERATION_DELAY);
                     validateVariable(variable, operation);

plugins/amda/tests/TestAmdaFuzzing.cpp +6 -6

             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
-            #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <QLoggingCategory>
             #include <QObject>
              */
             class FuzzingTest {
             public:
-                explicit FuzzingTest(VariableController &variableController, Properties properties)
+                explicit FuzzingTest(VariableController2 &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_FuzzingState{}
                     // Inits sync groups and registers them into the variable controller
                     for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
                         auto syncGroupId = SyncGroupId::createUuid();
-                        variableController.onAddSynchronizationGroupId(syncGroupId);
+                        //variableController.onAddSynchronizationGroupId(syncGroupId);
                         m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
                     }
                 }
                             auto waitAcquisition = nextValidationCounter == 0
                                                    || operationsPool().at(fuzzingOperation).m_WaitAcquisition;
-                            fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
+            //                fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
-                                                      m_Properties);
+            //                                          m_Properties);
                             if (waitAcquisition) {
                                 qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
                 DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
-                VariableController &m_VariableController;
+                VariableController2 &m_VariableController;
                 Properties m_Properties;
                 FuzzingState m_FuzzingState;
             };

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +3 -3

             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
-            #include <Variable/VariableController.h>
+            #include <Variable/VariableController2.h>
             #include <QObject>
             #include <QtTest>
                 QFETCH(std::vector<DateTimeRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
-                    sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+                    sqpApp->variableController().changeRange(variable, operation);
                     QTest::qWait(operationDelay);
                     validateVariable(variable, operation);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
-                    sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+                    sqpApp->variableController().changeRange(variable, operation);
                 }
                 QTest::qWait(operationDelay);
                 validateVariable(variable, operations.back());

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