HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1347:17e0dafec10c

Made core module a git submodule, ready to start switching to new...

jeandet -

r1347:17e0dafec10c

parent child

Context file:

r1347:17e0dafec10c

core created 160000 +1 0

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

.gitmodules +3 -6

@@ -1,9 +1,6
1	[submodule "external/CatalogueAPI"]
2	path = external/CatalogueAPI
3	url = https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/CatalogueAPI
4	[submodule "external/libcatalogs"]
5	path = external/libcatalogs
6	url = https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/SciQLOP_Repos/libcatalogs
7	[submodule "external/pybind11"]	1	[submodule "external/pybind11"]
8	path = external/pybind11	2	path = external/pybind11
9	url = https://github.com/pybind/pybind11	3	url = https://github.com/pybind/pybind11
		4	[submodule "core"]
		5	path = core
		6	url = https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore

CMakeLists.txt +1 -16

             cmake_minimum_required(VERSION 3.6)
             project(SciQLOP CXX)
             include(GNUInstallDirs)
             SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake")
             OPTION (CPPCHECK "Analyzes the source code with cppcheck" OFF)
             OPTION (CLANG_TIDY "Analyzes the source code with Clang Tidy" OFF)
             OPTION (IWYU "Analyzes the source code with Include What You Use" OFF)
-            set(CMAKE_CXX_STANDARD 14)
+            set(CMAKE_CXX_STANDARD 17)
             set(CMAKE_AUTOMOC ON)
             #https://gitlab.kitware.com/cmake/cmake/issues/15227
             #set(CMAKE_AUTOUIC ON)
             if(POLICY CMP0071)
                 cmake_policy(SET CMP0071 OLD)
             endif()
             set(CMAKE_AUTORCC ON)
             set(CMAKE_INCLUDE_CURRENT_DIR ON)
             if(NOT DEFINED CMAKE_INSTALL_RPATH_USE_LINK_PATH)
               set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
             endif()
             if(NOT DEFINED CMAKE_MACOSX_RPATH)
               set(CMAKE_MACOSX_RPATH TRUE)
             endif()
             if(NOT CMAKE_BUILD_TYPE)
               set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
             endif()
             find_package(Qt5 COMPONENTS Core Widgets Network PrintSupport Svg Test REQUIRED)
             IF(CPPCHECK)
                 set(CMAKE_CXX_CPPCHECK "cppcheck;--enable=warning,style")
             ENDIF(CPPCHECK)
             IF(CLANG_TIDY)
                 set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-style=file;-checks=*")
             ENDIF(CLANG_TIDY)
             IF(IWYU)
                 set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "include-what-you-use")
             ENDIF(IWYU)
             enable_testing()
-            find_package(catalogs CONFIG QUIET)
-            if (NOT CatalogueAPI_FOUND)
-                execute_process(COMMAND git submodule init external/libcatalogs WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-                execute_process(COMMAND git submodule update external/libcatalogs WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-                add_subdirectory(external/libcatalogs)
-            endif()
-            find_package(pybind11 CONFIG QUIET)
-            if (NOT pybind11_FOUND)
-                execute_process(COMMAND git submodule init external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-                execute_process(COMMAND git submodule update external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-                add_subdirectory(external/pybind11)
-            endif()
             add_subdirectory(core)
             add_subdirectory(gui)
             add_subdirectory(app)
             add_subdirectory(plugins)
             add_subdirectory(docs)

gui/include/TimeWidget/TimeWidget.h +1 -1

             #ifndef SCIQLOP_TIMEWIDGET_H
             #define SCIQLOP_TIMEWIDGET_H
             #include <QWidget>
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <Common/spimpl.h>
             namespace Ui {
             class TimeWidget;
             } // Ui
             class TimeWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit TimeWidget(QWidget *parent = 0);
                 virtual ~TimeWidget();
                 void setTimeRange(DateTimeRange time);
                 DateTimeRange timeRange() const;
             signals:
                 /// Signal emitted when the time parameters has beed updated
                 void timeUpdated(DateTimeRange time);
             public slots:
                 /// slot called when time parameters update has ben requested
                 void onTimeUpdateRequested();
             protected:
                 void dragEnterEvent(QDragEnterEvent *event) override;
                 void dragLeaveEvent(QDragLeaveEvent *event) override;
                 void dropEvent(QDropEvent *event) override;
                 void mousePressEvent(QMouseEvent *event) override;
                 void mouseMoveEvent(QMouseEvent *event) override;
             private:
                 Ui::TimeWidget *ui;
                 class TimeWidgetPrivate;
                 spimpl::unique_impl_ptr<TimeWidgetPrivate> impl;
             };
             #endif // SCIQLOP_ SQPSIDEPANE_H

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

             #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #include "Visualization/VisualizationDefs.h"
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <QLoggingCategory>
             #include <QVector>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
             class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
              * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
             struct VisualizationGraphHelper {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
                 static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
                 static void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                        const DateTimeRange &dateTime);
                 static void setYAxisRange(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

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

             #ifndef SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #define SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #include <Common/spimpl.h>
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <Visualization/qcustomplot.h>
             class VisualizationGraphWidget;
             class VisualizationSelectionZoneItem : public QCPItemRect {
                 Q_OBJECT
             signals:
                 /// Signal emitted when the zone range is edited manually
                 void rangeEdited(const DateTimeRange &range);
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);
                 virtual ~VisualizationSelectionZoneItem();
                 VisualizationGraphWidget *parentGraphWidget() const noexcept;
                 void setName(const QString &name);
                 QString name() const;
                 DateTimeRange range() const;
                 void setRange(double tstart, double tend);
                 void setStart(double tstart);
                 void setEnd(double tend);
                 void setColor(const QColor &color);
                 void setEditionEnabled(bool value);
                 bool isEditionEnabled() const;
                 /// Moves the item at the top of its QCPLayer. It will then receive the mouse events if multiple
                 /// items are stacked on top of each others.
                 void moveToTop();
                 Qt::CursorShape curshorShapeForPosition(const QPoint &position) const;
                 void setHovered(bool value);
                 /// Sets the zones which should be moved or reisized together with this zone
                 void setAssociatedEditedZones(const QVector<VisualizationSelectionZoneItem *> &associatedZones);
                 /// Align the specified zones with this one, vertically with the left border
                 bool alignZonesVerticallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                 bool allowResize);
                 /// Align the specified zones with this one, vertically with the right border
                 bool alignZonesVerticallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                  bool allowResize);
                 /// Align the specified zones with this one, temporally with the left border
                 bool alignZonesTemporallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                 bool allowResize);
                 /// Align the specified zones with this one, temporally with the right border
                 bool alignZonesTemporallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                  bool allowResize);
             protected:
                 void mousePressEvent(QMouseEvent *event, const QVariant &details) override;
                 void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void resizeLeft(double pixelDiff);
                 void resizeRight(double pixelDiff);
                 void move(double pixelDiff);
             private:
                 class VisualizationSelectionZoneItemPrivate;
                 spimpl::unique_impl_ptr<VisualizationSelectionZoneItemPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H

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

             #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
             #define SCIQLOP_VISUALIZATIONWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <QLoggingCategory>
             #include <QWidget>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             class QMenu;
             class Variable;
             class VisualizationTabWidget;
             class VisualizationSelectionZoneManager;
             namespace Ui {
             class VisualizationWidget;
             } // namespace Ui
             class VisualizationWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationWidget(QWidget *parent = 0);
                 virtual ~VisualizationWidget();
                 /// Returns the class which manage the selection of selection zone across the visualization
                 VisualizationSelectionZoneManager &selectionZoneManager() const;
                 VisualizationTabWidget *currentTabWidget() const;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
             public slots:
                 /**
                  * Attaches to a menu the menu relative to the visualization of variables
                  * @param menu the parent menu of the generated menu
                  * @param variables the variables for which to generate the menu
                  */
                 void attachVariableMenu(QMenu *menu,
                                         const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                 /// Slot called when a variable is about to be deleted from SciQlop
                 void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
                 void onRangeChanged(std::shared_ptr<Variable> variable, const DateTimeRange &range) noexcept;
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 Ui::VisualizationWidget *ui;
                 class VisualizationWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationWidgetPrivate> impl;
             };
             #endif // VISUALIZATIONWIDGET_H

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

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
-            #include "Data/SqpRange.h"
+            #include "Data/DateTimeRange.h"
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // namespace Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Sets the range of the zone, only works if there is at least one graph in the zone
                 /// Note: calibrations between graphs are lost.
                 void setZoneRange(const DateTimeRange &range);
                 /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /// Inserts a graph widget
                 void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variable the variable for which to create the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
                 /**
                  * Creates a graph using a list of variables. The variables will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variables List of variables to be added to the graph
                  * @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,
                                                       int index);
                 /// Returns the first graph in the zone or nullptr if there is no graph inside
                 VisualizationGraphWidget *firstGraph() const;
                 /// Closes all graphes inside the zone
                 void closeAllGraphs();
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData(const QPoint &position) const override;
                 bool isDragAllowed() const override;
                 void notifyMouseMoveInGraph(const QPointF &graphPosition, const QPointF &plotPosition,
                                             VisualizationGraphWidget *graphWidget);
                 void notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget);
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 Ui::VisualizationZoneWidget *ui;
                 class VisualizationZoneWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             private slots:
                 void onVariableAdded(std::shared_ptr<Variable> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
                 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
                 void dropMimeData(int index, const QMimeData *mimeData);
                 void dropMimeDataOnGraph(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/include/Visualization/operations/RescaleAxeOperation.h +1 -1

             #ifndef SCIQLOP_RESCALEAXEOPERATION_H
             #define SCIQLOP_RESCALEAXEOPERATION_H
             #include "Visualization/IVisualizationWidgetVisitor.h"
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <memory>
             class Variable;
             Q_DECLARE_LOGGING_CATEGORY(LOG_RescaleAxeOperation)
             /**
              * @brief The RescaleAxeOperation class defines an operation that traverses all of visualization
              * widgets to remove a variable if they contain it
              */
             class RescaleAxeOperation : public IVisualizationWidgetVisitor {
             public:
                 /**
                  * Ctor
                  * @param variable the variable to remove from widgets
                  */
                 explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const DateTimeRange &range);
                 void visitEnter(VisualizationWidget *widget) override final;
                 void visitLeave(VisualizationWidget *widget) override final;
                 void visitEnter(VisualizationTabWidget *tabWidget) override final;
                 void visitLeave(VisualizationTabWidget *tabWidget) override final;
                 void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
                 void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
                 void visit(VisualizationGraphWidget *graphWidget) override final;
             private:
                 class RescaleAxeOperationPrivate;
                 spimpl::unique_impl_ptr<RescaleAxeOperationPrivate> impl;
             };
             #endif // SCIQLOP_RESCALEAXEOPERATION_H

gui/src/Catalogue/CatalogueEventsModel.cpp +1 -1

             #include "Catalogue/CatalogueEventsModel.h"
             #include <Catalogue/CatalogueController.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <list>
             #include <unordered_map>
             #include <QHash>
             #include <QMimeData>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsModel, "CatalogueEventsModel")
             const auto EVENT_ITEM_TYPE = 1;
             const auto EVENT_PRODUCT_ITEM_TYPE = 2;
             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
                 std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
                 QVector<std::shared_ptr<DBCatalogue> > m_SourceCatalogue;
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"),  tr("TEnd"),
                                        tr("Tags"),  tr("Product"), tr("")};
                 }
                 QVariant sortData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     if (col == (int)CatalogueEventsModel::Column::Validation) {
                         auto hasChanges = sqpApp->catalogueController().eventHasChanges(event);
                         return hasChanges ? true : QVariant();
                     }
                     return eventData(col, event);
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return event->getName();
                         case CatalogueEventsModel::Column::TStart:
                             return nbEventProducts(event) > 0
                                        ? DateUtils::dateTime(event->getTStart())
                                              .toString(DATETIME_FORMAT_ONE_LINE)
                                        : QVariant{};
                         case CatalogueEventsModel::Column::TEnd:
                             return nbEventProducts(event) > 0
                                        ? DateUtils::dateTime(event->getTEnd())
                                              .toString(DATETIME_FORMAT_ONE_LINE)
                                        : QVariant{};
                         case CatalogueEventsModel::Column::Product: {
                             auto eventProducts = event->getEventProducts();
                             QStringList eventProductList;
                             for (auto evtProduct : eventProducts) {
                                 eventProductList << evtProduct.getProductId();
                             }
                             return eventProductList.join(";");
                         }
                         case CatalogueEventsModel::Column::Tags: {
                             QString tagList;
                             auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void parseEventProduct(const std::shared_ptr<DBEvent> &event)
                 {
                     for (auto product : event->getEventProducts()) {
                         m_EventProducts[event.get()].append(std::make_shared<DBEventProduct>(product));
                     }
                 }
                 int nbEventProducts(const std::shared_ptr<DBEvent> &event) const
                 {
                     auto eventProductsIt = m_EventProducts.find(event.get());
                     if (eventProductsIt != m_EventProducts.cend()) {
                         return m_EventProducts.at(event.get()).count();
                     }
                     else {
                         return 0;
                     }
                 }
                 QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::TStart:
                             return DateUtils::dateTime(eventProduct->getTStart())
                                 .toString(DATETIME_FORMAT_ONE_LINE);
                         case CatalogueEventsModel::Column::TEnd:
                             return DateUtils::dateTime(eventProduct->getTEnd())
                                 .toString(DATETIME_FORMAT_ONE_LINE);
                         case CatalogueEventsModel::Column::Product:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::Tags:
                             return QString();
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void refreshChildrenOfIndex(CatalogueEventsModel *model, const QModelIndex &index) const
                 {
                     auto childCount = model->rowCount(index);
                     auto colCount = model->columnCount();
                     emit model->dataChanged(model->index(0, 0, index),
                                             model->index(childCount, colCount, index));
                 }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
             void CatalogueEventsModel::setSourceCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 impl->m_SourceCatalogue = catalogues;
             }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 impl->m_EventProducts.clear();
                 for (auto event : events) {
                     impl->parseEventProduct(event);
                 }
                 endResetModel();
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) {
                     return impl->m_Events.value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     return getEvent(index.parent());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEventProduct>
             CatalogueEventsModel::getEventProduct(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     auto event = static_cast<DBEvent *>(index.internalPointer());
                     return impl->m_EventProducts.at(event).value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 beginInsertRows(QModelIndex(), impl->m_Events.count(), impl->m_Events.count());
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
                 // Also refreshes its children event products
                 auto eventIndex = index(impl->m_Events.count(), 0);
                 impl->refreshChildrenOfIndex(this, eventIndex);
             }
             void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto index = impl->m_Events.indexOf(event);
                 if (index >= 0) {
                     beginRemoveRows(QModelIndex(), index, index);
                     impl->m_Events.removeAt(index);
                     impl->m_EventProducts.erase(event.get());
                     endRemoveRows();
                 }
             }
             QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const
             {
                 return impl->m_Events;
             }
             void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event,
                                                     bool refreshEventProducts)
             {
                 auto eventIndex = indexOf(event);
                 if (eventIndex.isValid()) {
                     if (refreshEventProducts) {
                         // Reparse the associated event products
                         auto nbEventProducts = impl->nbEventProducts(event);
                         auto newNbOfEventProducts = event->getEventProducts().size();
                         if (newNbOfEventProducts < nbEventProducts) {
                             beginRemoveRows(eventIndex, newNbOfEventProducts, nbEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endRemoveRows();
                         }
                         else if (newNbOfEventProducts > nbEventProducts) {
                             beginInsertRows(eventIndex, nbEventProducts, newNbOfEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endInsertRows();
                         }
                         else { // newNbOfEventProducts == nbEventProducts
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                         }
                     }
                     // Refreshes the event line
                     auto colCount = columnCount();
                     emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
                     // Also refreshes its children event products
                     impl->refreshChildrenOfIndex(this, eventIndex);
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsModel()) << "refreshEvent: event not found.";
                 }
             }
             QModelIndex CatalogueEventsModel::indexOf(const std::shared_ptr<DBEvent> &event) const
             {
                 auto row = impl->m_Events.indexOf(event);
                 if (row >= 0) {
                     return index(row, 0);
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
             {
                 if (!hasIndex(row, column, parent)) {
                     return QModelIndex();
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return createIndex(row, column);
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return createIndex(row, column, event.get());
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
             {
                 switch (itemTypeOf(index)) {
                     case CatalogueEventsModel::ItemType::EventProduct: {
                         auto parentEvent = static_cast<DBEvent *>(index.internalPointer());
                         auto it
                             = std::find_if(impl->m_Events.cbegin(), impl->m_Events.cend(),
                                            [parentEvent](auto event) { return event.get() == parentEvent; });
                         if (it != impl->m_Events.cend()) {
                             return createIndex(it - impl->m_Events.cbegin(), 0);
                         }
                         else {
                             return QModelIndex();
                         }
                     }
                     case CatalogueEventsModel::ItemType::Root:
                         break;
                     case CatalogueEventsModel::ItemType::Event:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
             {
                 if (parent.column() > 0) {
                     return 0;
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return impl->m_Events.count();
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return impl->m_EventProducts[event.get()].count();
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return 0;
             }
             int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
             {
                 return static_cast<int>(CatalogueEventsModel::Column::NbColumn);
             }
             Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
             QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
                     auto type = itemTypeOf(index);
                     if (type == CatalogueEventsModel::ItemType::Event) {
                         auto event = getEvent(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventData(index.column(), event);
                                 break;
                         }
                     }
                     else if (type == CatalogueEventsModel::ItemType::EventProduct) {
                         auto product = getEventProduct(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventProductData(index.column(), product);
                                 break;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                     return impl->columnNames().value(section);
                 }
                 return QVariant();
             }
             void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
             {
                 beginResetModel();
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
                               auto data1 = impl->sortData(column, e1);
                               auto data2 = impl->sortData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
                 endResetModel();
                 emit modelSorted();
             }
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 bool isFirst = true;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
                 DateTimeRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto type = itemTypeOf(index);
                         if (type == ItemType::Event) {
                             auto event = getEvent(index);
                             eventList << event;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = event->getTStart();
                                 firstTimeRange.m_TEnd = event->getTEnd();
                             }
                         }
                         else if (type == ItemType::EventProduct) {
                             auto product = getEventProduct(index);
                             eventProductList << product;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = product->getTStart();
                                 firstTimeRange.m_TEnd = product->getTEnd();
                             }
                         }
                     }
                 }
                 if (!eventList.isEmpty() && eventProductList.isEmpty()) {
                     auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList);
                     mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
                     auto sourceCataloguesEncodedData
                         = sqpApp->catalogueController().mimeDataForCatalogues(impl->m_SourceCatalogue);
                     mimeData->setData(MIME_TYPE_SOURCE_CATALOGUE_LIST, sourceCataloguesEncodedData);
                 }
                 if (eventList.count() + eventProductList.count() == 1) {
                     // No time range MIME data if multiple events are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return ItemType::Root;
                 }
                 else if (index.internalPointer() == nullptr) {
                     return ItemType::Event;
                 }
                 else {
                     return ItemType::EventProduct;
                 }
             }

gui/src/TimeWidget/TimeWidget.cpp +1 0

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QDropEvent>
             #include <QMimeData>
+            #include <QStyle>
             struct TimeWidget::TimeWidgetPrivate {
                 explicit TimeWidgetPrivate() {}
                 QPoint m_DragStartPosition;
             };
             TimeWidget::TimeWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::TimeWidget},
                       impl{spimpl::make_unique_impl<TimeWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));
                 // Connection
                 connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),
                         &TimeController::onTimeNotify);
                 // Initialisation
                 auto endDateTime = QDateTime::currentDateTimeUtc();
                 auto startDateTime = endDateTime.addSecs(-3600); // one hour before
                 ui->startDateTimeEdit->setDateTime(startDateTime);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
                 auto dateTime = DateTimeRange{DateUtils::secondsSinceEpoch(startDateTime),
                                          DateUtils::secondsSinceEpoch(endDateTime)};
                 sqpApp->timeController().setDateTimeRange(dateTime);
             }
             TimeWidget::~TimeWidget()
             {
                 delete ui;
             }
             void TimeWidget::setTimeRange(DateTimeRange time)
             {
                 auto startDateTime = DateUtils::dateTime(time.m_TStart);
                 auto endDateTime = DateUtils::dateTime(time.m_TEnd);
                 ui->startDateTimeEdit->setDateTime(startDateTime);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
             }
             DateTimeRange TimeWidget::timeRange() const
             {
                 return DateTimeRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
                                 DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
             }
             void TimeWidget::onTimeUpdateRequested()
             {
                 auto dateTime = timeRange();
                 emit timeUpdated(std::move(dateTime));
             }
             void TimeWidget::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     event->acceptProposedAction();
                     setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
                 }
                 else {
                     event->ignore();
                 }
             }
             void TimeWidget::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 setStyleSheet(QString{});
             }
             void TimeWidget::dropEvent(QDropEvent *event)
             {
                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
                     auto timeRange = TimeController::timeRangeForMimeData(mimeData);
                     setTimeRange(timeRange);
                 }
                 else {
                     event->ignore();
                 }
                 setStyleSheet(QString{});
             }
             void TimeWidget::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                     impl->m_DragStartPosition = event->pos();
                 }
                 QWidget::mousePressEvent(event);
             }
             void TimeWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 if (!(event->buttons() & Qt::LeftButton)) {
                     return;
                 }
                 if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
                     < QApplication::startDragDistance()) {
                     return;
                 }
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{this};
                 auto mimeData = new QMimeData;
                 auto timeData = TimeController::mimeDataForTimeRange(timeRange());
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap{":/icones/time.png"};
                 drag->setPixmap(pixmap.scaledToWidth(22));
                 sqpApp->dragDropGuiController().resetDragAndDrop();
                 // Note: The exec() is blocking on windows but not on linux and macOS
                 drag->exec(Qt::MoveAction | Qt::CopyAction);
                 QWidget::mouseMoveEvent(event);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +2 -1

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
+            #include <QStyle>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(QLayout &layout)
             {
                 QSet<QString> existingNames;
                 processGraphs(
                     layout, [&existingNames](auto &graphWidget) { existingNames.insert(graphWidget.name()); });
                 int zoneNum = 1;
                 QString name;
                 do {
                     name = QObject::tr("Graph ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
                 return name;
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
                 void dropProducts(const QVariantList &productsData, int index,
                                   VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
                     if (!mimeData) {
                         return false;
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variablesForMimeData(
                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
                         if (variables.count() != 1) {
                             return false;
                         }
                         auto variable = variables.first();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                     return true;
                 };
                 ui->dragDropContainer->setAcceptDragWidgetFunction(acceptDragWidgetFun);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::setZoneRange(const DateTimeRange &range)
             {
                 if (auto graph = firstGraph()) {
                     graph->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("setZoneRange:Cannot set the range of an empty zone.");
                 }
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
                                                                  const DateTimeRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::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: {
                                     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: {
                                     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: {
                                     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: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     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);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = DateTimeRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *VisualizationZoneWidget::firstGraph() const
             {
                 VisualizationGraphWidget *firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     if (auto visualizationGraphWidget
                         = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
                 return firstGraph;
             }
             void VisualizationZoneWidget::closeAllGraphs()
             {
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = this->firstGraph()) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
                                                                  const QPointF &plotPosition,
                                                                  VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
                                                                     VisualizationGraphWidget &processedGraph) {
                     switch (sqpApp->plotsCursorMode()) {
                         case SqpApplication::PlotsCursorMode::Vertical:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                             break;
                         case SqpApplication::PlotsCursorMode::Temporal:
                             processedGraph.addVerticalCursor(plotPosition.x());
                             processedGraph.removeHorizontalCursor();
                             break;
                         case SqpApplication::PlotsCursorMode::Horizontal:
                             processedGraph.removeVerticalCursor();
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::Cross:
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.removeVerticalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::NoCursor:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.removeVerticalCursor();
                             break;
                     }
                 });
             }
             void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
                     processedGraph.removeHorizontalCursor();
                     processedGraph.removeVerticalCursor();
                 });
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject{this};
                     connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
                             [this, graphWidget, context](auto variable) {
                                 graphWidget->addVariable(variable, graphWidget->graphRange());
                                 delete context; // removes the connection
                             },
                             Qt::QueuedConnection);
                     auto productData = products.first().toHash();
                     QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                               Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // 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)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && 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();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<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) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
                 const QVariantList &productsData, int index, VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (productsData.count() != 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");
                     return;
                 }
                 auto context = new QObject{zoneWidget};
                 connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
                         [this, index, zoneWidget, context](auto variable) {
                             zoneWidget->createGraph(variable, index);
                             delete context; // removes the connection
                         },
                         Qt::QueuedConnection);
                 auto productData = productsData.first().toHash();
                 QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                           Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
             }

plugins/amda/tests/FuzzingDefs.h +1 -1

             #ifndef SCIQLOP_FUZZINGDEFS_H
             #define SCIQLOP_FUZZINGDEFS_H
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <QString>
             #include <QUuid>
             #include <QVariantHash>
             #include <memory>
             #include <set>
             // /////// //
             // Aliases //
             // /////// //
             using MetadataPool = std::vector<QVariantHash>;
             Q_DECLARE_METATYPE(MetadataPool)
             using Properties = QVariantHash;
             // ///////// //
             // Constants //
             // ///////// //
             /// Timeout set for data acquisition for an operation (in ms)
             extern const QString ACQUISITION_TIMEOUT_PROPERTY;
             /// Max number of operations to generate
             extern const QString NB_MAX_OPERATIONS_PROPERTY;
             /// Max number of sync groups to create through operations
             extern const QString NB_MAX_SYNC_GROUPS_PROPERTY;
             /// Max number of variables to manipulate through operations
             extern const QString NB_MAX_VARIABLES_PROPERTY;
             /// Set of operations available for the test
             extern const QString AVAILABLE_OPERATIONS_PROPERTY;
             /// Tolerance used for variable's cache (in ratio)
             extern const QString CACHE_TOLERANCE_PROPERTY;
             /// Range with which the timecontroller is initialized
             extern const QString INITIAL_RANGE_PROPERTY;
             /// Max range that an operation can reach
             extern const QString MAX_RANGE_PROPERTY;
             /// Set of metadata that can be associated to a variable
             extern const QString METADATA_POOL_PROPERTY;
             /// Provider used to retrieve data
             extern const QString PROVIDER_PROPERTY;
             /// Min/max times left for an operation to execute
             extern const QString OPERATION_DELAY_BOUNDS_PROPERTY;
             /// Validators used to validate an operation
             extern const QString VALIDATORS_PROPERTY;
             /// Min/max number of operations to execute before calling validation of the current test's state
             extern const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY;
             // /////// //
             // Structs //
             // /////// //
             class Variable;
             struct VariableState {
                 std::shared_ptr<Variable> m_Variable{nullptr};
                 DateTimeRange m_Range{INVALID_RANGE};
             };
             using VariableId = int;
             using VariablesPool = std::map<VariableId, VariableState>;
             /**
              * Defines a synchronization group for a fuzzing state. A group reports the variables synchronized
              * with each other, and the current range of the group (i.e. range of the last synchronized variable
              * that has been moved)
              */
             struct SyncGroup {
                 std::set<VariableId> m_Variables{};
                 DateTimeRange m_Range{INVALID_RANGE};
             };
             using SyncGroupId = QUuid;
             using SyncGroupsPool = std::map<SyncGroupId, SyncGroup>;
             /**
              * Defines a current state during a fuzzing state. It contains all the variables manipulated during
              * the test, as well as the synchronization status of these variables.
              */
             struct FuzzingState {
                 const SyncGroup &syncGroup(SyncGroupId id) const;
                 SyncGroup &syncGroup(SyncGroupId id);
                 const VariableState &variableState(VariableId id) const;
                 VariableState &variableState(VariableId id);
                 /// @return the identifier of the synchronization group in which the variable passed in
                 /// parameter is located. If the variable is not in any group, returns an invalid identifier
                 SyncGroupId syncGroupId(VariableId variableId) const;
                 /// @return the set of synchronization group identifiers
                 std::vector<SyncGroupId> syncGroupsIds() const;
                 /// Updates fuzzing state according to a variable synchronization
                 /// @param variableId the variable that is synchronized
                 /// @param syncGroupId the synchronization group
                 void synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
                 /// Updates fuzzing state according to a variable desynchronization
                 /// @param variableId the variable that is desynchronized
                 /// @param syncGroupId the synchronization group from which to remove the variable
                 void desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
                 /// Updates the range of a variable and all variables to which it is synchronized
                 /// @param the variable for which to affect the range
                 /// @param the range to affect
                 void updateRanges(VariableId variableId, const DateTimeRange &newRange);
                 VariablesPool m_VariablesPool;
                 SyncGroupsPool m_SyncGroupsPool;
             };
             #endif // SCIQLOP_FUZZINGDEFS_H

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SciQLOP Software
             --  Copyright (C) 2018, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include <string>
             #include <sstream>
             #include <memory>
             #include <pybind11/pybind11.h>
             #include <pybind11/operators.h>
             #include <pybind11/embed.h>
             #include <pybind11/numpy.h>
             #include <pybind11/chrono.h>
             #include <SqpApplication.h>
             #include <Variable/VariableController.h>
             #include <Time/TimeController.h>
-            #include <Data/SqpRange.h>
+            #include <Data/DateTimeRange.h>
             #include <Data/DataSeriesType.h>
             #include <Common/DateUtils.h>
             #include <Variable/Variable.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <AmdaProvider.h>
             #include <AmdaResultParser.h>
             //#include <QDate>
             //#include <QTime>
             //#include <QUuid>
             //#include <QString>
             #include <QFile>
             #include <pywrappers_common.h>
             #include <CoreWrappers.h>
             #include "PyTestAmdaWrapper.h"
             using namespace std::chrono;
             PYBIND11_MODULE(pytestamda, m){
                 int argc = 0;
                 char ** argv=nullptr;
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 static SqpApplication app(argc, argv);
                 auto qtmod = py::module::import("sciqlopqt");
                 auto sciqlopmod = py::module::import("pysciqlopcore");
                 m.doc() = "hello";
                 py::class_<VariableController>(m, "VariableController")
                         .def_static("createVariable",[](const QString &name,
                                     std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
                     return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
                 })
                         .def_static("hasPendingDownloads",
                                     [](){return sqpApp->variableController().hasPendingDownloads();}
                                     )
                         .def_static("addSynchronizationGroup",
                                     [](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}
                                     )
                         .def_static("removeSynchronizationGroup",
                             [](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}
                             )
                         .def_static("synchronizeVar",
                             [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}
                             )
                         .def_static("deSynchronizeVar",
                             [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}
                             )
                         .def_static("deleteVariable",
                                     [](std::shared_ptr<Variable> variable){
                     sqpApp->variableController().deleteVariable(variable);}
                                     )
                         .def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){
                     sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
                 })
                         .def_static("wait_for_downloads",[](){
                     while (sqpApp->variableController().hasPendingDownloads()) {
                         usleep(100);
                     }
                 });
                 py::class_<TimeController>(m,"TimeController")
                         .def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});
                 auto amda_provider = std::make_shared<AmdaProvider>();
                 m.def("amda_provider",[amda_provider](){return amda_provider;}, py::return_value_policy::copy);
                 py::class_<AmdaProvider, std::shared_ptr<AmdaProvider>, IDataProvider>(m, "AmdaProvider");
                 py::class_<AmdaResultParser>(m, "AmdaResultParser")
                         .def_static("readTxt", AmdaResultParser::readTxt)
                         .def("readScalarTxt", [](const QString& path){
                     return std::dynamic_pointer_cast<ScalarSeries>(AmdaResultParser::readTxt(path, DataSeriesType::SCALAR));
                 }, py::return_value_policy::copy);
             }

core/CMakeLists.txt removed 0 -131

NO CONTENT: file was removed

core/include/Catalogue/CatalogueController.h removed 0 -93

NO CONTENT: file was removed

core/include/Common/DateUtils.h removed 0 -23

NO CONTENT: file was removed

core/include/Common/MetaTypes.h removed 0 -46

NO CONTENT: file was removed

core/include/Common/MimeTypesDef.h removed 0 -22

NO CONTENT: file was removed

core/include/Common/Numeric.h removed 0 -18

NO CONTENT: file was removed

core/include/Common/SignalWaiter.h removed 0 -38

NO CONTENT: file was removed

core/include/Common/SortUtils.h removed 0 -139

NO CONTENT: file was removed

core/include/Common/StringUtils.h removed 0 -35

NO CONTENT: file was removed

core/include/Common/spimpl.h removed 0 -460

NO CONTENT: file was removed

core/include/CoreGlobal.h removed 0 -12

NO CONTENT: file was removed

core/include/Data/AcquisitionDataPacket.h removed 0 -25

NO CONTENT: file was removed

core/include/Data/AcquisitionRequest.h removed 0 -40

NO CONTENT: file was removed

core/include/Data/ArrayData.h removed 0 -373

NO CONTENT: file was removed

core/include/Data/ArrayDataIterator.h removed 0 -74

NO CONTENT: file was removed

core/include/Data/DataProviderParameters.h removed 0 -18

NO CONTENT: file was removed

core/include/Data/DataSeries.h removed 0 -507

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (507 lines changed) Show them Hide them

core/include/Data/DataSeriesIterator.h removed 0 -81

NO CONTENT: file was removed

core/include/Data/DataSeriesMergeHelper.h removed 0 -83

NO CONTENT: file was removed

core/include/Data/DataSeriesType.h removed 0 -26

NO CONTENT: file was removed

core/include/Data/DataSeriesUtils.h removed 0 -317

NO CONTENT: file was removed

core/include/Data/IDataProvider.h removed 0 -81

NO CONTENT: file was removed

core/include/Data/IDataSeries.h removed 0 -102

NO CONTENT: file was removed

core/include/Data/OptionalAxis.h removed 0 -66

NO CONTENT: file was removed

core/include/Data/ScalarSeries.h removed 0 -27

NO CONTENT: file was removed

core/include/Data/SpectrogramSeries.h removed 0 -40

NO CONTENT: file was removed

core/include/Data/SqpIterator.h removed 0 -112

NO CONTENT: file was removed

core/include/Data/SqpRange.h removed 0 -68

NO CONTENT: file was removed

core/include/Data/Unit.h removed 0 -27

NO CONTENT: file was removed

core/include/Data/VariableRequest.h removed 0 -26

NO CONTENT: file was removed

core/include/Data/VectorSeries.h removed 0 -34

NO CONTENT: file was removed

core/include/DataSource/DataSourceController.h removed 0 -106

NO CONTENT: file was removed

core/include/DataSource/DataSourceItem.h removed 0 -164

NO CONTENT: file was removed

core/include/DataSource/DataSourceItemAction.h removed 0 -54

NO CONTENT: file was removed

core/include/DataSource/DataSourceItemMergeHelper.h removed 0 -15

NO CONTENT: file was removed

core/include/Network/Downloader.h removed 0 -72

NO CONTENT: file was removed

core/include/Network/NetworkController.h removed 0 -53

NO CONTENT: file was removed

core/include/Network/Response.h removed 0 -25

NO CONTENT: file was removed

core/include/Plugin/IPlugin.h removed 0 -20

NO CONTENT: file was removed

core/include/PluginManager/PluginManager.h removed 0 -41

NO CONTENT: file was removed

core/include/Settings/ISqpSettingsBindable.h removed 0 -21

NO CONTENT: file was removed

core/include/Settings/SqpSettingsDefs.h removed 0 -22

NO CONTENT: file was removed

core/include/Time/TimeController.h removed 0 -48

NO CONTENT: file was removed

core/include/Variable/Variable.h removed 0 -95

NO CONTENT: file was removed

core/include/Variable/VariableAcquisitionWorker.h removed 0 -66

NO CONTENT: file was removed

core/include/Variable/VariableCacheController.h removed 0 -45

NO CONTENT: file was removed

core/include/Variable/VariableCacheStrategy.h removed 0 -32

NO CONTENT: file was removed

core/include/Variable/VariableCacheStrategyFactory.h removed 0 -46

NO CONTENT: file was removed

core/include/Variable/VariableController.h removed 0 -147

NO CONTENT: file was removed

core/include/Variable/VariableController2.h removed 0 -32

NO CONTENT: file was removed

core/include/Variable/VariableModel.h removed 0 -111

NO CONTENT: file was removed

core/include/Variable/VariableSingleThresholdCacheStrategy.h removed 0 -32

NO CONTENT: file was removed

core/include/Variable/VariableSynchronizationGroup.h removed 0 -39

NO CONTENT: file was removed

core/include/Visualization/VisualizationController.h removed 0 -51

NO CONTENT: file was removed

core/meson.build removed 0 -75

NO CONTENT: file was removed

core/resources/Version.cpp.in removed 0 -78

NO CONTENT: file was removed

core/resources/Version.h.in removed 0 -98

NO CONTENT: file was removed

core/src/Catalogue/CatalogueController.cpp removed 0 -574

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (574 lines changed) Show them Hide them

core/src/Common/DateUtils.cpp removed 0 -13

NO CONTENT: file was removed

core/src/Common/MimeTypesDef.cpp removed 0 -10

NO CONTENT: file was removed

core/src/Common/SignalWaiter.cpp removed 0 -36

NO CONTENT: file was removed

core/src/Common/StringUtils.cpp removed 0 -30

NO CONTENT: file was removed

core/src/Data/ArrayDataIterator.cpp removed 0 -77

NO CONTENT: file was removed

core/src/Data/DataSeriesIterator.cpp removed 0 -88

NO CONTENT: file was removed

core/src/Data/DataSeriesUtils.cpp removed 0 -194

NO CONTENT: file was removed

core/src/Data/OptionalAxis.cpp removed 0 -107

NO CONTENT: file was removed

core/src/Data/ScalarSeries.cpp removed 0 -31

NO CONTENT: file was removed

core/src/Data/SpectrogramSeries.cpp removed 0 -50

NO CONTENT: file was removed

core/src/Data/VectorSeries.cpp removed 0 -83

NO CONTENT: file was removed

core/src/DataSource/DataSourceController.cpp removed 0 -197

NO CONTENT: file was removed

core/src/DataSource/DataSourceItem.cpp removed 0 -205

NO CONTENT: file was removed

core/src/DataSource/DataSourceItemAction.cpp removed 0 -49

NO CONTENT: file was removed

core/src/DataSource/DataSourceItemMergeHelper.cpp removed 0 -55

NO CONTENT: file was removed

core/src/Network/Downloader.cpp removed 0 -123

NO CONTENT: file was removed

core/src/Network/NetworkController.cpp removed 0 -148

NO CONTENT: file was removed

core/src/PluginManager/PluginManager.cpp removed 0 -137

NO CONTENT: file was removed

core/src/Settings/SqpSettingsDefs.cpp removed 0 -18

NO CONTENT: file was removed

core/src/Time/TimeController.cpp removed 0 -51

NO CONTENT: file was removed

core/src/Variable/Variable.cpp removed 0 -430

NO CONTENT: file was removed

core/src/Variable/VariableAcquisitionWorker.cpp removed 0 -416

NO CONTENT: file was removed

core/src/Variable/VariableCacheController.cpp removed 0 -225

NO CONTENT: file was removed

core/src/Variable/VariableController.cpp removed 0 -1103

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (1103 lines changed) Show them Hide them

core/src/Variable/VariableController2.cpp removed 0 -1

NO CONTENT: file was removed

core/src/Variable/VariableModel.cpp removed 0 -393

NO CONTENT: file was removed

core/src/Variable/VariableSynchronizationGroup.cpp removed 0 -38

NO CONTENT: file was removed

core/src/Visualization/VisualizationController.cpp removed 0 -48

NO CONTENT: file was removed

core/src/pybind11_wrappers/CoreWrappers.cpp removed 0 -126

NO CONTENT: file was removed

core/src/pybind11_wrappers/CoreWrappers.h removed 0 -54

NO CONTENT: file was removed

core/src/pybind11_wrappers/QtWrappers.cpp removed 0 -33

NO CONTENT: file was removed

core/src/pybind11_wrappers/QtWrappers.h removed 0 -19

NO CONTENT: file was removed

core/src/pybind11_wrappers/pywrappers_common.h removed 0 -18

NO CONTENT: file was removed

core/tests-resources/TestDataSeriesUtils/TestThresholds.txt removed 0 -600

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (600 lines changed) Show them Hide them

core/tests/CMakeLists.txt removed 0 -37

NO CONTENT: file was removed

core/tests/Common/TestStringUtils.cpp removed 0 -50

NO CONTENT: file was removed

core/tests/Data/DataSeriesBuilders.cpp removed 0 -90

NO CONTENT: file was removed

core/tests/Data/DataSeriesBuilders.h removed 0 -74

NO CONTENT: file was removed

core/tests/Data/DataSeriesTestsUtils.cpp removed 0 -24

NO CONTENT: file was removed

core/tests/Data/DataSeriesTestsUtils.h removed 0 -373

NO CONTENT: file was removed

core/tests/Data/TestDataSeriesUtils.cpp removed 0 -206

NO CONTENT: file was removed

core/tests/Data/TestOneDimArrayData.cpp removed 0 -181

NO CONTENT: file was removed

core/tests/Data/TestOptionalAxis.cpp removed 0 -113

NO CONTENT: file was removed

core/tests/Data/TestScalarSeries.cpp removed 0 -426

NO CONTENT: file was removed

core/tests/Data/TestSpectrogramSeries.cpp removed 0 -198

NO CONTENT: file was removed

core/tests/Data/TestTwoDimArrayData.cpp removed 0 -240

NO CONTENT: file was removed

core/tests/Data/TestVectorSeries.cpp removed 0 -90

NO CONTENT: file was removed

core/tests/DataSource/DataSourceItemBuilder.cpp removed 0 -73

NO CONTENT: file was removed

core/tests/DataSource/DataSourceItemBuilder.h removed 0 -45

NO CONTENT: file was removed

core/tests/DataSource/TestDataSourceController.cpp removed 0 -49

NO CONTENT: file was removed

core/tests/DataSource/TestDataSourceItem.cpp removed 0 -207

NO CONTENT: file was removed

core/tests/Network/TestDownloader.cpp removed 0 -82

NO CONTENT: file was removed

core/tests/Variable/TestVariable.cpp removed 0 -409

NO CONTENT: file was removed

core/tests/Variable/TestVariableCacheController.cpp removed 0 -333

NO CONTENT: file was removed

core/tests/Variable/TestVariableController.cpp removed 0 -74

NO CONTENT: file was removed

core/tests/Variable/TestVariableController2.cpp removed 0 -30

NO CONTENT: file was removed

core/tests/Variable/TestVariableSync.cpp removed 0 -508

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (508 lines changed) Show them Hide them

core/tests/meson.build removed 0 -36

NO CONTENT: file was removed

core/vera-exclusions/exclusions.txt removed 0 -52

NO CONTENT: file was removed

external/CatalogueAPI removed 0 -1

NO CONTENT: file was removed

external/libcatalogs removed 0 -1

NO CONTENT: file was removed

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