HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1486:8539a975891c

Switched to cpp_utils package...

jeandet -

r1486:8539a975891c

parent child

Context file:

r1486:8539a975891c

subprojects/cpp_utils.wrap created 644 +5 0

@@ -0,0 +1,5
	1	[wrap-git]
	2	directory = cpp_utils
	3	url = https://github.com/jeandet/cpp_utils.git
	4	revision = master
	5

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 63c6ae3895dda76aabbc560a636a1f3d8d4d95bf		1	Subproject commit 29637e951955d1747d325407e2d833646c98f1c2

gui/src/Catalogue2/eventeditor.cpp +4 -4

             #include "Catalogue2/eventeditor.h"
             #include "ui_eventeditor.h"
             #include <Common/DateUtils.h>
-            #include <Common/StringUtils.h>
+            #include <containers/algorithms.hpp>
             EventEditor::EventEditor(QWidget* parent) : QWidget(parent), ui(new Ui::EventEditor)
             {
                 ui->setupUi(this);
             }
             EventEditor::~EventEditor()
             {
                 delete ui;
             }
             void EventEditor::setEvent(const CatalogueController::Event_ptr& event)
             {
                 _setEventName(event, mode::editable);
                 _setTags(event, mode::readonly);
                 _setProducts(event, mode::readonly);
                 _setDates(event->startTime(), event->stopTime(), mode::readonly);
             }
             void EventEditor::setProduct(
                 const CatalogueController::Product_t& product, const CatalogueController::Event_ptr& event)
             {
                 _setEventName(event, mode::readonly);
                 _setTags(event, mode::readonly);
                 _setDates(product.startTime, product.stopTime, mode::editable);
                 _setProducts(product, mode::readonly);
             }
             void EventEditor::_setEventName(const CatalogueController::Event_ptr& event, mode is_editable)
             {
                 this->ui->EventName->setText(QString::fromStdString(event->name));
                 this->ui->EventName->setEnabled(bool(is_editable));
             }
             void EventEditor::_setTags(const CatalogueController::Event_ptr& event, mode is_editable)
             {
-                this->ui->Tags->setText(StringUtils::join(event->tags, ", "));
+                this->ui->Tags->setText(QString::fromStdString(cpp_utils::containers::join(event->tags, ',')));
                 this->ui->Tags->setEnabled(bool(is_editable));
             }
             void EventEditor::_setProducts(const CatalogueController::Event_ptr& event, mode is_editable)
             {
                 QStringList products;
-                this->ui->Products->setText(StringUtils::join(event->products, ", ",
+                std::transform(std::cbegin(event->products),std::cend(event->products),std::begin(products),[](const auto& product) { return QString::fromStdString(product.name); });
-                    [](const auto& product) { return QString::fromStdString(product.name); }));
+                this->ui->Products->setText(cpp_utils::containers::join(products, QString(", ")));
                 this->ui->Products->setEnabled(bool(is_editable));
             }
             void EventEditor::_setProducts(const CatalogueController::Product_t& product, mode is_editable)
             {
                 this->ui->Products->setText(QString::fromStdString(product.name));
                 this->ui->Products->setEnabled(bool(is_editable));
             }
             void EventEditor::_setDates(double startDate, double stopDate, mode is_editable)
             {
                 this->ui->StartTime->setDateTime(DateUtils::dateTime(startDate));
                 this->ui->StopTime->setDateTime(DateUtils::dateTime(stopDate));
                 this->ui->StartTime->setEnabled(bool(is_editable));
                 this->ui->StopTime->setEnabled(bool(is_editable));
             }
             void EventEditor::_setDates(
                 std::optional<double> startDate, std::optional<double> stopDate, mode is_editable)
             {
                 if (startDate && stopDate)
                     _setDates(*startDate, *stopDate, is_editable);
                 else
                     _setDates(0., 0., is_editable);
             }

gui/src/Catalogue2/eventsmodel.cpp +3 -2

             /*
                 This file is part of SciQLop.
                 SciQLop 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 3 of the License, or
                 (at your option) any later version.
                 SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
             */
             #include "Catalogue2/eventsmodel.h"
-            #include <Common/containers.h>
             #include <SqpApplication.h>
+            #include <containers/algorithms.hpp>
             EventsModel::EventsModel(QObject* parent) : QAbstractItemModel(parent) {}
             EventsModel::ItemType EventsModel::type(const QModelIndex& index) const
             {
                 if (EventsModelItem* item = to_item(index))
                 {
                     return item->type;
                 }
                 return ItemType::None;
             }
             QVariant EventsModel::data(const QModelIndex& index, int role) const
             {
                 if (index.isValid())
                 {
                     return to_item(index)->data(index.column(), role);
                 }
                 return QVariant {};
             }
             QModelIndex EventsModel::index(int row, int column, const QModelIndex& parent) const
             {
                 if (!hasIndex(row, column, parent))
                 {
                     return QModelIndex();
                 }
                 switch (type(parent))
                 {
                     case ItemType::None: // is an event
                         return createIndex(row, column, _items[row].get());
                     case ItemType::Event: // is a product
                         return createIndex(row, column, to_item(parent)->children[row].get());
                     case ItemType::Product:
                         QModelIndex();
                 }
                 return QModelIndex();
             }
             QModelIndex EventsModel::parent(const QModelIndex& index) const
             {
                 auto item = to_item(index);
                 if (item->type == ItemType::Product)
                 {
-                    auto repoIndex = SciQLop::containers::index_of(_items, item->parent);
+                    auto repoIndex = cpp_utils::containers::index_of(_items, item->parent);
                     return createIndex(repoIndex, 0, item->parent);
                 }
                 return QModelIndex();
             }
             int EventsModel::rowCount(const QModelIndex& parent) const
             {
                 if (parent.column() > 0)
                 {
                     return 0;
                 }
                 switch (type(parent))
                 {
                     case ItemType::None:
                         return _items.size();
                     case ItemType::Event:
                         return to_item(parent)->children.size();
                     case ItemType::Product:
                         break;
                 }
                 return 0;
             }
             int EventsModel::columnCount(const QModelIndex& parent) const
             {
                 return static_cast<int>(EventsModel::Columns::NbColumn);
             }
             QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section < ColumnsNames.size())
                 {
                     return ColumnsNames[section];
                 }
                 return QVariant();
             }
             void EventsModel::sort(int column, Qt::SortOrder order)
             {
                 beginResetModel();
                 switch (static_cast<Columns>(column))
                 {
                     case EventsModel::Columns::Name:
                         std::sort(std::begin(_items), std::end(_items),
                             [inverse = order != Qt::SortOrder::AscendingOrder](
                                 const std::unique_ptr<EventsModelItem>& a,
                                 const std::unique_ptr<EventsModelItem>& b) {
                                 return (a->event()->name < b->event()->name) xor inverse;
                             });
                         break;
                     case EventsModel::Columns::TStart:
                         std::sort(std::begin(_items), std::end(_items),
                             [inverse = order != Qt::SortOrder::AscendingOrder](
                                 const std::unique_ptr<EventsModelItem>& a,
                                 const std::unique_ptr<EventsModelItem>& b) {
                                 if (auto t1 = a->event()->startTime(); auto t2 = b->event()->startTime())
                                 {
                                     if (t1 and t2)
                                         return bool((t1.value() < t2.value()) xor inverse);
                                 }
                                 return true;
                             });
                         break;
                     case EventsModel::Columns::TEnd:
                         std::sort(std::begin(_items), std::end(_items),
                             [inverse = order != Qt::SortOrder::AscendingOrder](
                                 const std::unique_ptr<EventsModelItem>& a,
                                 const std::unique_ptr<EventsModelItem>& b) {
                                 if (auto t1 = a->event()->stopTime(); auto t2 = b->event()->stopTime())
                                 {
                                     if (t1 and t2)
                                         return bool((t1.value() < t2.value()) xor inverse);
                                 }
                                 return true;
                             });
                         break;
                     case EventsModel::Columns::Product:
                         break;
                     case EventsModel::Columns::Tags:
                         break;
                     default:
                         break;
                 }
                 endResetModel();
             }

gui/src/Catalogue2/repositoriesmodel.cpp +2 -2

             /*
                 This file is part of SciQLop.
                 SciQLop 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 3 of the License, or
                 (at your option) any later version.
                 SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
             */
             #include <Catalogue2/repositoriesmodel.h>
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <SqpApplication.h>
             RepositoriesModel::RepositoriesModel(QObject* parent) : QAbstractItemModel(parent)
             {
                 refresh();
                 connect(&(sqpApp->catalogueController()), &CatalogueController::repositoryAdded, this,
                     [this](const QString&) { this->refresh(); });
                 connect(&(sqpApp->catalogueController()), &CatalogueController::catalogueAdded, this,
                     [this](const CatalogueController::Catalogue_ptr&, const QString&) { this->refresh(); });
             }
             RepositoriesModel::ItemType RepositoriesModel::type(const QModelIndex& index) const
             {
                 if (RepoModelItem* item = to_item(index))
                 {
                     return item->type;
                 }
                 return ItemType::None;
             }
             void RepositoriesModel::refresh()
             {
                 beginResetModel();
                 _items.clear();
                 _items.push_back(std::make_unique<RepoModelItem>("All"));
                 _items.push_back(std::make_unique<RepoModelItem>("Trash"));
                 auto repo_list = sqpApp->catalogueController().repositories();
                 std::transform(std::begin(repo_list), std::end(repo_list), std::back_inserter(_items),
                     [](const auto& repo_name) { return std::make_unique<RepoModelItem>(repo_name); });
                 endResetModel();
             }
             QVariant RepositoriesModel::data(const QModelIndex& index, int role) const
             {
                 if (index.isValid() && index.column() == 0)
                 {
                     return to_item(index)->data(role);
                 }
                 return QVariant {};
             }
             QModelIndex RepositoriesModel::index(int row, int column, const QModelIndex& parent) const
             {
                 if (!hasIndex(row, column, parent))
                 {
                     return QModelIndex();
                 }
                 switch (type(parent))
                 {
                     case RepositoriesModel::ItemType::None: // is a repo
                         return createIndex(row, column, _items[row].get());
                     case RepositoriesModel::ItemType::Repository: // is a catalogue
                         return createIndex(row, column, to_item(parent)->children[row].get());
                     case RepositoriesModel::ItemType::Catalogue:
                         return createIndex(row, column, new RepoModelItem());
                 }
                 return QModelIndex();
             }
             QModelIndex RepositoriesModel::parent(const QModelIndex& index) const
             {
                 auto item = to_item(index);
                 if (item->type == ItemType::Catalogue)
                 {
-                    auto repoIndex = SciQLop::containers::index_of(_items, item->parent);
+                    auto repoIndex = cpp_utils::containers::index_of(_items, item->parent);
                     return createIndex(repoIndex, 0, item->parent);
                 }
                 return QModelIndex();
             }
             int RepositoriesModel::rowCount(const QModelIndex& parent) const
             {
                 switch (type(parent))
                 {
                     case RepositoriesModel::ItemType::None:
                         return _items.size();
                     case RepositoriesModel::ItemType::Repository:
                         return to_item(parent)->children.size();
                     case RepositoriesModel::ItemType::Catalogue:
                         break;
                 }
                 return 0;
             }
             RepositoriesModel::RepoModelItem::RepoModelItem(const QString& repo)
                     : type { ItemType::Repository }, item { repo }, icon { ":/icones/database.png" }
             {
                 auto catalogues = sqpApp->catalogueController().catalogues(repo);
                 std::transform(std::begin(catalogues), std::end(catalogues), std::back_inserter(children),
                     [this](auto& catalogue) { return std::make_unique<RepoModelItem>(catalogue, this); });
             }
             QVariant RepositoriesModel::RepoModelItem::data(int role) const
             {
                 switch (role)
                 {
                     case Qt::EditRole:
                     case Qt::DisplayRole:
                         return text();
                     case Qt::DecorationRole:
                         return QVariant { icon };
                     default:
                         break;
                 }
                 return QVariant {};
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +1 -1

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/TimeSeriesUtils.h>
             #include <Data/VectorTimeSerie.h>
-            #include <Common/cpp_utils.h>
+            #include <cpp_utils.hpp>
             #include <Variable/Variable2.h>
             #include <algorithm>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace
             {
             class SqpDataContainer : public QCPGraphDataContainer
             {
             public:
                 void appendGraphData(const QCPGraphData& data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator
             {
                 static PlottablesMap createPlottables(QCustomPlot&, const std::shared_ptr<T>& dataSeries)
                 {
                     return {};
                 }
             };
             PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
             {
                 PlottablesMap result {};
                 // Creates {nbGraphs} QCPGraph to add to the plot
                 for (auto i = 0; i < nbGraphs; ++i)
                 {
                     auto graph = plot.addGraph();
                     result.insert({ i, graph });
                 }
                 plot.replot();
                 return result;
             }
             /**
              * Specialization of PlottablesCreator for scalars
              * @sa ScalarSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, 1);
                 }
             };
             /**
              * Specialization of PlottablesCreator for vectors
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, 3);
                 }
             };
             /**
              * Specialization of PlottablesCreator for MultiComponentTimeSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     return createGraphs(plot, dataSeries->size(1));
                 }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
                 {
                     PlottablesMap result {};
                     result.insert({ 0, new QCPColorMap { plot.xAxis, plot.yAxis } });
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater
             {
                 static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T&, PlottablesMap&, const DateTimeRange&, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                     {
                         if (serie->size())
                         {
                             maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
                             minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
                         }
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                             {
                                 std::for_each(
                                     std::begin(*serie), std::end(*serie), [&dataContainer](const auto& value) {
                                         dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
                                     });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                     {
                         std::for_each(
                             std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
                                 minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
                                 maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
                             });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                             {
                                 switch (plottable.first)
                                 {
                                     case 0:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().x));
                                             });
                                         break;
                                     case 1:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().y));
                                             });
                                         break;
                                     case 2:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().z));
                                             });
                                         break;
                                     default:
                                         break;
                                 }
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
             struct PlottablesUpdater<T,
                 typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
                     {
                         std::for_each(std::begin(*serie), std::end(*serie), [&minValue, &maxValue](auto& v) {
                             minValue = std::min(minValue, std::min_element(v.begin(), v.end())->v());
                             maxValue = std::max(maxValue, std::max_element(v.begin(), v.end())->v());
                         });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
                             {
                                 // TODO
                                 std::for_each(std::begin(*serie), std::end(*serie),
                                     [&dataContainer, component = plottable.first](const auto& value) {
                                         dataContainer->appendGraphData(
                                             QCPGraphData(value.t(), value[component]));
                                     });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             /*=============================================================*/
             // TODO move this to dedicated srcs
             /*=============================================================*/
             struct ColomapProperties
             {
                 int h_size_px;
                 int v_size_px;
                 double h_resolutuon;
                 double v_resolutuon;
             };
             inline ColomapProperties CMAxisAnalysis(const TimeSeriesUtils::axis_properties& xAxisProperties,
                 const TimeSeriesUtils::axis_properties& yAxisProperties)
             {
                 int colormap_h_size
                     = std::min(32000, static_cast<int>(xAxisProperties.range / xAxisProperties.max_resolution));
                 int colormap_v_size = static_cast<int>(yAxisProperties.range / yAxisProperties.max_resolution);
                 double colormap_h_resolution = xAxisProperties.range / static_cast<double>(colormap_h_size);
                 double colormap_v_resolution = yAxisProperties.range / static_cast<double>(colormap_v_size);
                 return ColomapProperties { colormap_h_size, colormap_v_size, colormap_h_resolution,
                     colormap_v_resolution };
             }
             template <bool condition, typename T, typename U>
             std::enable_if_t<condition, T> constexpr conditional_v(T first, U second)
             {
                 return first;
             }
             template <bool condition, typename T, typename U>
             std::enable_if_t<!condition, U> constexpr conditional_v(T first, U second)
             {
                 return second;
             }
             template <bool reversedAxis = true, bool reversedData = true>
             inline std::vector<std::pair<int, int>> build_access_pattern(const std::vector<double>& axis,
                 const TimeSeriesUtils::axis_properties& axisProperties,
                 const ColomapProperties& colormap_properties)
             {
                 std::vector<std::pair<int, int>> access_pattern;
                 for (int index = 0, axis_index = conditional_v<reversedAxis>(axis.size() - 1, 0),
                          data_index = conditional_v<reversedData>(axis.size() - 1, 0);
                      index < colormap_properties.v_size_px; index++)
                 {
                     double current_y = (axisProperties.max_resolution * index) + axisProperties.min;
                     if (current_y > axis[axis_index])
                     {
                         conditional_v<reversedAxis>(
                             [&axis_index]() { axis_index--; }, [&axis_index]() { axis_index++; })();
                         conditional_v<reversedData>(
                             [&data_index]() { data_index--; }, [&data_index]() { data_index++; })();
                     }
                     access_pattern.push_back({ index, data_index });
                 }
                 return access_pattern;
             }
             inline bool is_log(const std::vector<double>& axis)
             {
                 if (axis.size() > 2)
                 {
                     auto first = axis.front(), midle = axis[axis.size() / 2], last = axis.back();
                     auto error_linear = (midle - (last + first) / 2) / midle;
                     first = log10(first);
                     midle = log10(midle);
                     last = log10(last);
                     auto error_log = (midle - (last + first) / 2) / midle;
                     return error_log < error_linear;
                 }
                 return false;
             }
             template <typename accessPattern_t, typename colomapT, typename axProp_t, typename cmProp_t>
             inline void fill_data(SpectrogramTimeSerie* serie, colomapT* colormap,
                 const accessPattern_t& y_access_pattern, const axProp_t& xAxisProperties,
                 const cmProp_t& colormap_properties)
             {
                 auto line = serie->begin();
                 auto next_line = line + 1;
                 double current_time = xAxisProperties.min;
                 int x_index = 0;
                 auto x_min_resolution
                     = std::fmin(2. * serie->max_sampling, xAxisProperties.max_resolution * 100.);
                 std::vector<double> line_values(serie->size(1));
                 double avg_coef = 0.;
                 while (x_index < colormap_properties.h_size_px)
                 {
                     if (next_line != std::end(*serie) and current_time >= next_line->t())
                     {
                         line = next_line;
                         next_line++;
                     }
                     if ((current_time - xAxisProperties.min)
                         > (static_cast<double>(x_index + 1) * colormap_properties.h_resolutuon))
                     {
                         std::for_each(std::cbegin(y_access_pattern), std::cend(y_access_pattern),
                             [&colormap, &line_values, x_index, avg_coef](const auto& acc) {
                                 colormap->data()->setCell(
                                     x_index, acc.first, line_values[acc.second] / avg_coef);
                             });
                         std::fill(std::begin(line_values), std::end(line_values), 0.);
                         x_index++;
                         avg_coef = 0.;
                     }
                     if (line->t() + x_min_resolution > current_time)
                     {
                         {
                             std::transform(std::begin(*line), std::end(*line), std::cbegin(line_values),
                                 std::begin(line_values),
                                 [](const auto& input, auto output) { return input.v() + output; });
                         }
                         avg_coef += 1.;
                     }
                     else
                     {
                         for (int y_index = 0; y_index < colormap_properties.v_size_px; y_index++)
                         {
                             if (avg_coef > 0.)
                             {
                                 std::fill(std::begin(line_values), std::end(line_values), 0);
                             }
                         }
                     }
                     current_time += xAxisProperties.max_resolution * 0.9;
                 }
             }
             /*=============================================================*/
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     auto [minValue, maxValue] = dataSeries.axis_range(1);
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     if (plottables.empty())
                     {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't update spectrogram: no colormap has been associated");
                         return;
                     }
                     // Gets the colormap to update (normally there is only one colormap)
                     Q_ASSERT(plottables.size() == 1);
                     auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
                     Q_ASSERT(colormap != nullptr);
                     auto plot = colormap->parentPlot();
                     auto [minValue, maxValue] = dataSeries.axis_range(1);
                     plot->yAxis->setRange(QCPRange { minValue, maxValue });
                     if (auto serie = dynamic_cast<SpectrogramTimeSerie*>(&dataSeries))
                     {
                         if (serie->size(0) > 2)
                         {
                             if (serie->y_is_log)
                                 colormap->setDataScaleType(QCPAxis::stLogarithmic);
                             else
                                 colormap->setDataScaleType(QCPAxis::stLinear);
                             const auto& xAxis = serie->axis(0);
                             auto yAxis = serie->axis(1); // copy for in place reverse order
                             auto y_is_log = is_log(yAxis);
                             std::reverse(std::begin(yAxis), std::end(yAxis));
                             auto xAxisProperties = TimeSeriesUtils::axis_analysis<TimeSeriesUtils::IsLinear,
                                 TimeSeriesUtils::CheckMedian>(xAxis, serie->min_sampling);
                             auto yAxisProperties = TimeSeriesUtils::axis_analysis<TimeSeriesUtils::IsLog,
                                 TimeSeriesUtils::DontCheckMedian>(yAxis);
                             auto colormap_properties = CMAxisAnalysis(xAxisProperties, yAxisProperties);
                             colormap->data()->setSize(
                                 colormap_properties.h_size_px, colormap_properties.v_size_px);
                             colormap->data()->setRange(
                                 QCPRange { xAxisProperties.min, xAxisProperties.max }, { minValue, maxValue });
                             auto y_access_pattern = build_access_pattern<false, true>(
                                 yAxis, yAxisProperties, colormap_properties);
                             fill_data(serie, colormap, y_access_pattern, xAxisProperties, colormap_properties);
                         }
                         colormap->rescaleDataRange(true);
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper
             {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot& plot) const = 0;
                 virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
                 virtual void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update
              * plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}
                 PlottablesMap create(QCustomPlot& plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(plot, m_DataSeries);
                 }
                 void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 std::shared_ptr<T> m_DataSeries;
             };
             /// Creates IPlottablesHelper according to the type of data series a variable holds
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
             {
                 switch (variable->type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
                             std::dynamic_pointer_cast<ScalarTimeSerie>(variable->data()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
                             std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable->data()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
                             std::dynamic_pointer_cast<VectorTimeSerie>(variable->data()));
                     case DataSeriesType::MULTICOMPONENT:
                         return std::make_unique<PlottablesHelper<MultiComponentTimeSerie>>(
                             std::dynamic_pointer_cast<MultiComponentTimeSerie>(variable->data()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap {};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(
                 PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
             {
                 auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +3 -2

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationCursorItem.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Actions/ActionsGuiController.h>
             #include <Actions/FilteringAction.h>
             #include <Common/MimeTypesDef.h>
-            #include <Common/containers.h>
+            #include <cpp_utils_qt/cpp_utils_qt.hpp>
+            #include <containers/algorithms.hpp>
             #include <Data/DateTimeRangeHelper.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace
             {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
             /// Speed of a step of a wheel event for a pan, in percentage of the axis range
             const auto PAN_SPEED = 5;
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable multi selection of selection zones
             const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
             /// Format of the dates appearing in the label of a cursor
             const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate
             {
                 explicit VisualizationGraphWidgetPrivate(const QString& name)
                         : m_Name { name }
                         , m_Flags { GraphFlag::EnableAll }
                         , m_IsCalibration { false }
                         , m_RenderingDelegate { nullptr }
                 {
                     m_plot = new QCustomPlot();
                     // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                     m_plot->setPlottingHint(QCP::phFastPolylines, true);
                 }
                 void updateData(
                     PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable2>, PlottablesMap> m_VariableToPlotMultiMap;
                 GraphFlags m_Flags;
                 bool m_IsCalibration;
                 QCustomPlot* m_plot;
                 QPoint m_lastMousePos;
                 QCPRange m_lastXRange;
                 QCPRange m_lastYRange;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 QCPItemRect* m_DrawingZoomRect = nullptr;
                 QStack<QPair<QCPRange, QCPRange>> m_ZoomStack;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
                 VisualizationSelectionZoneItem* m_DrawingZone = nullptr;
                 VisualizationSelectionZoneItem* m_HoveredZone = nullptr;
                 QVector<VisualizationSelectionZoneItem*> m_SelectionZones;
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
                 bool m_VariableAutoRangeOnInit = true;
                 inline void enterPlotDrag(const QPoint& position)
                 {
                     m_lastMousePos = m_plot->mapFromParent(position);
                     m_lastXRange = m_plot->xAxis->range();
                     m_lastYRange = m_plot->yAxis->range();
                 }
                 inline bool isDrawingZoomRect() { return m_DrawingZoomRect != nullptr; }
                 void updateZoomRect(const QPoint& newPos)
                 {
                     QPointF pos { m_plot->xAxis->pixelToCoord(newPos.x()),
                         m_plot->yAxis->pixelToCoord(newPos.y()) };
                     m_DrawingZoomRect->bottomRight->setCoords(pos);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void applyZoomRect()
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange { m_DrawingZoomRect->topLeft->coords().x(),
                         m_DrawingZoomRect->bottomRight->coords().x() };
                     auto newAxisYRange = QCPRange { m_DrawingZoomRect->topLeft->coords().y(),
                         m_DrawingZoomRect->bottomRight->coords().y() };
                     removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0))
                     {
                         m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 inline bool isDrawingZoneRect() { return m_DrawingZone != nullptr; }
                 void updateZoneRect(const QPoint& newPos)
                 {
                     m_DrawingZone->setEnd(m_plot->xAxis->pixelToCoord(newPos.x()));
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void startDrawingRect(const QPoint& pos)
                 {
                     removeDrawingRect();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZoomRect = new QCPItemRect { m_plot };
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect()
                 {
                     if (m_DrawingZoomRect)
                     {
                         m_plot->removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void selectZone(const QPoint& pos)
                 {
                     auto zoneAtPos = selectionZoneAt(pos);
                     setSelectionZonesEditionEnabled(
                         sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 }
                 void startDrawingZone(const QPoint& pos)
                 {
                     endDrawingZone();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZone = new VisualizationSelectionZoneItem { m_plot };
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone()
                 {
                     if (m_DrawingZone)
                     {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0)
                         {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
                         else
                         {
                             m_plot->removeItem(m_DrawingZone);
                         }
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void moveSelectionZone(const QPoint& destination)
                 {
                     /*
                      * I give up on this for now
                      * TODO implement this, the difficulty is that selection zones have their own
                      * event handling code which seems to rely on QCP GUI event handling propagation
                      * which was a realy bad design choice.
                      */
                 }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
                     for (auto s : m_SelectionZones)
                     {
                         s->setEditionEnabled(value);
                     }
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem* zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem* selectionZoneAt(const QPoint& pos) const
                 {
                     VisualizationSelectionZoneItem* selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
                     for (auto zone : m_SelectionZones)
                     {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
                             && distanceToZone >= 0 && distanceToZone < m_plot->selectionTolerance())
                         {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
                 QVector<VisualizationSelectionZoneItem*> selectionZonesAt(
                     const QPoint& pos, const QCustomPlot& plot) const
                 {
                     QVector<VisualizationSelectionZoneItem*> zones;
                     for (auto zone : m_SelectionZones)
                     {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance())
                         {
                             zones << zone;
                         }
                     }
                     return zones;
                 }
                 void moveSelectionZoneOnTop(VisualizationSelectionZoneItem* zone, QCustomPlot& plot)
                 {
                     if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone)
                     {
                         zone->moveToTop();
                         m_SelectionZones.removeAll(zone);
                         m_SelectionZones.append(zone);
                     }
                 }
                 QPointF posToAxisPos(const QPoint& pos) const
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     return QPointF { axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y()) };
                 }
                 bool pointIsInAxisRect(const QPointF& axisPoint, QCustomPlot& plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
                 }
                 inline QCPRange _pixDistanceToRange(double pos1, double pos2, QCPAxis* axis)
                 {
                     if (axis->scaleType() == QCPAxis::stLinear)
                     {
                         auto diff = axis->pixelToCoord(pos1) - axis->pixelToCoord(pos2);
                         return QCPRange { axis->range().lower + diff, axis->range().upper + diff };
                     }
                     else
                     {
                         auto diff = axis->pixelToCoord(pos1) / axis->pixelToCoord(pos2);
                         return QCPRange { axis->range().lower * diff, axis->range().upper * diff };
                     }
                 }
                 void setRange(const DateTimeRange& newRange, bool updateVar = true)
                 {
                     this->m_plot->xAxis->setRange(newRange.m_TStart, newRange.m_TEnd);
                     if (updateVar)
                     {
                         for (auto it = m_VariableToPlotMultiMap.begin(), end = m_VariableToPlotMultiMap.end();
                              it != end; it = m_VariableToPlotMultiMap.upper_bound(it->first))
                         {
                             sqpApp->variableController().asyncChangeRange(it->first, newRange);
                         }
                     }
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void setRange(const QCPRange& newRange)
                 {
                     auto graphRange = DateTimeRange { newRange.lower, newRange.upper };
                     setRange(graphRange);
                 }
                 void rescaleY() { m_plot->yAxis->rescale(true); }
                 std::tuple<double, double> moveGraph(const QPoint& destination)
                 {
                     auto currentPos = m_plot->mapFromParent(destination);
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     auto oldXRange = xAxis->range();
                     auto oldYRange = yAxis->range();
                     double dx = xAxis->pixelToCoord(m_lastMousePos.x()) - xAxis->pixelToCoord(currentPos.x());
                     xAxis->setRange(m_lastXRange.lower + dx, m_lastXRange.upper + dx);
                     if (yAxis->scaleType() == QCPAxis::stLinear)
                     {
                         double dy
                             = yAxis->pixelToCoord(m_lastMousePos.y()) - yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower + dy, m_lastYRange.upper + dy);
                     }
                     else
                     {
                         double dy
                             = yAxis->pixelToCoord(m_lastMousePos.y()) / yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower * dy, m_lastYRange.upper * dy);
                     }
                     auto newXRange = xAxis->range();
                     auto newYRange = yAxis->range();
                     setRange(xAxis->range());
                     // m_lastMousePos = currentPos;
                     return { newXRange.lower - oldXRange.lower, newYRange.lower - oldYRange.lower };
                 }
                 void zoom(double factor, int center, Qt::Orientation orientation)
                 {
                     QCPAxis* axis = m_plot->axisRect()->rangeZoomAxis(orientation);
                     axis->scaleRange(factor, axis->pixelToCoord(center));
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void transform(const DateTimeRangeTransformation& tranformation)
                 {
                     auto graphRange = m_plot->xAxis->range();
                     DateTimeRange range { graphRange.lower, graphRange.upper };
                     range = range.transform(tranformation);
                     setRange(range);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double dx, double dy)
                 {
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     xAxis->setRange(QCPRange(xAxis->range().lower + dx, xAxis->range().upper + dx));
                     yAxis->setRange(QCPRange(yAxis->range().lower + dy, yAxis->range().upper + dy));
                     setRange(xAxis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double factor, Qt::Orientation orientation)
                 {
                     auto oldRange = m_plot->xAxis->range();
                     QCPAxis* axis = m_plot->axisRect()->rangeDragAxis(orientation);
                     if (m_plot->xAxis->scaleType() == QCPAxis::stLinear)
                     {
                         double rg = (axis->range().upper - axis->range().lower) * (factor / 10);
                         axis->setRange(axis->range().lower + (rg), axis->range().upper + (rg));
                     }
                     else if (m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic)
                     {
                         int start = 0, stop = 0;
                         double diff = 0.;
                         if (factor > 0.0)
                         {
                             stop = m_plot->width() * factor / 10;
                             start = 2 * m_plot->width() * factor / 10;
                         }
                         if (factor < 0.0)
                         {
                             factor *= -1.0;
                             start = m_plot->width() * factor / 10;
                             stop = 2 * m_plot->width() * factor / 10;
                         }
                         diff = axis->pixelToCoord(start) / axis->pixelToCoord(stop);
                         axis->setRange(m_plot->axisRect()->rangeDragAxis(orientation)->range().lower * diff,
                             m_plot->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
                     }
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString& name, QWidget* parent)
                     : VisualizationDragWidget { parent }
                     , ui { new Ui::VisualizationGraphWidget }
                     , impl { spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name) }
             {
                 ui->setupUi(this);
                 this->layout()->addWidget(impl->m_plot);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 // Init the cursors
                 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
                 this->setFocusPolicy(Qt::WheelFocus);
                 this->setMouseTracking(true);
                 impl->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
                 impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
                 impl->m_plot->setParent(this);
                 connect(&sqpApp->variableController(), &VariableController2::variableDeleted, this,
                     &VisualizationGraphWidget::variableDeleted);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget* VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget*>(parent))
                 {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget*>(parent);
             }
             VisualizationWidget* VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationWidget*>(parent))
                 {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationWidget*>(parent);
             }
             void VisualizationGraphWidget::setFlags(GraphFlags flags)
             {
                 impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable2> variable, DateTimeRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *impl->m_plot);
                 // Sets graph properties
                 impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
                 impl->m_VariableToPlotMultiMap.insert({ variable, std::move(createdPlottables) });
                 setGraphRange(range);
                 // If the variable already has its data loaded, load its units and its range in the graph
                 if (variable->data() != nullptr)
                 {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                 }
                 else
                 {
                     auto context = new QObject { this };
                     connect(
                         variable.get(), &Variable2::updated, context, [this, variable, context, range](QUuid) {
                             this->impl->m_RenderingDelegate->setAxesUnits(*variable);
                             this->impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                             delete context;
                         });
                 }
                 //TODO this is bad! when variable is moved to another graph it still fires
                 // even if this has been deleted
                 connect(variable.get(), &Variable2::updated, this, &VisualizationGraphWidget::variableUpdated);
                 this->onUpdateVarDisplaying(variable, range); // My bullshit
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable2> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend())
                 {
                     emit variableAboutToBeRemoved(variable);
                     auto& plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;)
                     {
                         impl->m_plot->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             std::vector<std::shared_ptr<Variable2>> VisualizationGraphWidget::variables() const
             {
                 auto variables = std::vector<std::shared_ptr<Variable2>> {};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it)
                 {
                     variables.push_back(it->first);
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable2> variable)
             {
                 if (!variable)
                 {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *impl->m_plot);
             }
             DateTimeRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = impl->m_plot->xAxis->range();
                 return DateTimeRange { graphRange.lower, graphRange.upper };
             }
             void VisualizationGraphWidget::setGraphRange(
                 const DateTimeRange& range, bool updateVar, bool forward)
             {
                 impl->setRange(range, updateVar);
                 if (forward)
                 {
                     emit this->setrange_sig(this->graphRange(), true, false);
                 }
             }
             void VisualizationGraphWidget::setAutoRangeOnVariableInitialization(bool value)
             {
                 impl->m_VariableAutoRangeOnInit = value;
             }
             QVector<DateTimeRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<DateTimeRange> ranges;
                 for (auto zone : impl->m_SelectionZones)
                 {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<DateTimeRange>& ranges)
             {
                 for (const auto& range : ranges)
                 {
                     // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
                     impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             VisualizationSelectionZoneItem* VisualizationGraphWidget::addSelectionZone(
                 const QString& name, const DateTimeRange& range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
                 zone->setName(name);
                 zone->setRange(range.m_TStart, range.m_TEnd);
                 impl->addSelectionZone(zone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
                 return zone;
             }
             void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem* selectionZone)
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
                 if (impl->m_HoveredZone == selectionZone)
                 {
                     impl->m_HoveredZone = nullptr;
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_SelectionZones.removeAll(selectionZone);
                 plot().removeItem(selectionZone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::undoZoom()
             {
                 auto zoom = impl->m_ZoomStack.pop();
                 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                 axisX->setRange(zoom.first);
                 axisY->setRange(zoom.second);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::zoom(
                 double factor, int center, Qt::Orientation orientation, bool forward)
             {
                 impl->zoom(factor, center, orientation);
                 if (forward && orientation == Qt::Horizontal)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double factor, Qt::Orientation orientation, bool forward)
             {
                 impl->move(factor, orientation);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double dx, double dy, bool forward)
             {
                 impl->move(dx, dy);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::transform(
                 const DateTimeRangeTransformation& tranformation, bool forward)
             {
                 impl->transform(tranformation);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor* visitor)
             {
                 if (visitor)
                 {
                     visitor->visit(this);
                 }
                 else
                 {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(Variable2& variable) const
             {
                 auto isSpectrogram
                     = [](auto& variable) { return variable.type() == DataSeriesType::SPECTROGRAM; };
                 // - A spectrogram series can't be dropped on graph with existing plottables
                 // - No data series can be dropped on graph with existing spectrogram series
                 return isSpectrogram(variable)
                     ? impl->m_VariableToPlotMultiMap.empty()
                     : std::none_of(impl->m_VariableToPlotMultiMap.cbegin(),
                           impl->m_VariableToPlotMultiMap.cend(),
                           [isSpectrogram](const auto& entry) { return isSpectrogram(*entry.first); });
             }
             bool VisualizationGraphWidget::contains(Variable2& variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto& entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData* VisualizationGraphWidget::mimeData(const QPoint& position) const
             {
                 auto mimeData = new QMimeData;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor)
                 {
                     mimeData->setData(MIME_TYPE_TIME_RANGE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                     mimeData->setData(MIME_TYPE_SELECTION_ZONE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                 }
                 else
                 {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray {});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint& dragPosition)
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor)
                 {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
                     auto zoneSize = QSizeF { qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
                         qAbs(zoneBottomRight.y() - zoneTopLeft.y()) }
                                         .toSize();
                     auto pixmap = QPixmap(zoneSize);
                     render(&pixmap, QPoint(), QRegion { QRect { zoneTopLeft.toPoint(), zoneSize } });
                     return pixmap;
                 }
                 return QPixmap();
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted)
                 {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else
                 {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::addVerticalCursor(double time)
             {
                 impl->m_VerticalCursor->setPosition(time);
                 impl->m_VerticalCursor->setVisible(true);
                 auto text
                     = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
             {
                 impl->m_VerticalCursor->setAbsolutePosition(position);
                 impl->m_VerticalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto text
                     = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::removeVerticalCursor()
             {
                 impl->m_VerticalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::addHorizontalCursor(double value)
             {
                 impl->m_HorizontalCursor->setPosition(value);
                 impl->m_HorizontalCursor->setVisible(true);
                 impl->m_HorizontalCursor->setLabelText(QString::number(value));
             }
             void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
             {
                 impl->m_HorizontalCursor->setAbsolutePosition(position);
                 impl->m_HorizontalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
                 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
             }
             void VisualizationGraphWidget::removeHorizontalCursor()
             {
                 impl->m_HorizontalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent* event)
             {
                 Q_UNUSED(event);
                 for (auto i : impl->m_SelectionZones)
                 {
                     parentVisualizationWidget()->selectionZoneManager().setSelected(i, false);
                 }
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto& variableEntry : impl->m_VariableToPlotMultiMap)
                 {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent* event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent* event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
                 if (auto parentZone = parentZoneWidget())
                 {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
                 else
                 {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
                 if (impl->m_HoveredZone)
                 {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             }
             void VisualizationGraphWidget::wheelEvent(QWheelEvent* event)
             {
                 double factor;
                 double wheelSteps = event->delta() / 120.0; // a single step delta is +/-120 usually
                 if (event->modifiers() == Qt::ControlModifier)
                 {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeVerCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
                         zoom(factor, event->pos().y(), Qt::Vertical);
                     }
                 }
                 else if (event->modifiers() == Qt::ShiftModifier)
                 {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeHorCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
                         zoom(factor, event->pos().x(), Qt::Horizontal);
                     }
                 }
                 else
                 {
                     move(wheelSteps, Qt::Horizontal);
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mouseMoveEvent(QMouseEvent* event)
             {
                 if (impl->isDrawingZoomRect())
                 {
                     impl->updateZoomRect(event->pos());
                 }
                 else if (impl->isDrawingZoneRect())
                 {
                     impl->updateZoneRect(event->pos());
                 }
                 else if (event->buttons() == Qt::LeftButton)
                 {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None)
                     {
                         auto [dx, dy] = impl->moveGraph(event->pos());
                         emit this->setrange_sig(this->graphRange(), true, false);
                     }
                     else if (sqpApp->plotsInteractionMode()
                         == SqpApplication::PlotsInteractionMode::SelectionZones)
                     {
                         auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                         if (auto item = impl->m_plot->itemAt(posInPlot))
                         {
                             if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                             {
                                 QMouseEvent e { QEvent::MouseMove, posInPlot, event->button(), event->buttons(),
                                     event->modifiers() };
                                 sqpApp->sendEvent(this->impl->m_plot, &e);
                                 this->impl->m_plot->replot(QCustomPlot::rpImmediateRefresh);
                             }
                         }
                     }
                 }
                 else
                 {
                     impl->m_RenderingDelegate->updateTooltip(event);
                 }
                 // event->accept();
                 QWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::mouseReleaseEvent(QMouseEvent* event)
             {
                 if (impl->isDrawingZoomRect())
                 {
                     auto oldRange = this->graphRange();
                     impl->applyZoomRect();
                     auto newRange = this->graphRange();
                     if (auto tf = DateTimeRangeHelper::computeTransformation(oldRange, newRange))
                         emit this->transform_sig(tf.value(), false);
                 }
                 else if (impl->isDrawingZoneRect())
                 {
                     impl->endDrawingZone();
                 }
                 else
                 {
                     setCursor(Qt::ArrowCursor);
                 }
                 auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                 if (auto item = impl->m_plot->itemAt(posInPlot))
                 {
                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                     {
                         QMouseEvent e { QEvent::MouseButtonRelease, posInPlot, event->button(),
                             event->buttons(), event->modifiers() };
                         sqpApp->sendEvent(this->impl->m_plot, &e);
                     }
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mousePressEvent(QMouseEvent* event)
             {
                 if (event->button() == Qt::RightButton)
                 {
                     onGraphMenuRequested(event->pos());
                 }
                 else
                 {
                     auto selectedZone = impl->selectionZoneAt(event->pos());
                     switch (sqpApp->plotsInteractionMode())
                     {
                         case SqpApplication::PlotsInteractionMode::DragAndDrop:
                             break;
                         case SqpApplication::PlotsInteractionMode::SelectionZones:
                             impl->setSelectionZonesEditionEnabled(true);
                             if ((event->modifiers() == Qt::ControlModifier) && (selectedZone != nullptr))
                             {
                                 auto alreadySelectedZones
                                     = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                                 selectedZone->setAssociatedEditedZones(alreadySelectedZones);
-                                if (SciQLop::containers::contains(alreadySelectedZones, selectedZone))
+                                if (cpp_utils::containers::contains(alreadySelectedZones, selectedZone))
                                 {
                                     alreadySelectedZones.removeOne(selectedZone);
                                 }
                                 else
                                 {
                                     alreadySelectedZones.append(selectedZone);
                                 }
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     alreadySelectedZones);
                             }
                             else
                             {
                                 if (!selectedZone)
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                     impl->startDrawingZone(event->pos());
                                 }
                                 else
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().select(
                                         { selectedZone });
                                 }
                             }
                             {
                                 auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                                 if (auto item = impl->m_plot->itemAt(posInPlot))
                                 {
                                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                                     {
                                         QMouseEvent e { QEvent::MouseButtonPress, posInPlot, event->button(),
                                             event->buttons(), event->modifiers() };
                                         sqpApp->sendEvent(this->impl->m_plot, &e);
                                     }
                                 }
                             }
                             break;
                         case SqpApplication::PlotsInteractionMode::ZoomBox:
                             impl->startDrawingRect(event->pos());
                             break;
                         default:
                             if (auto item = impl->m_plot->itemAt(event->pos()))
                             {
                                 emit impl->m_plot->itemClick(item, event);
                                 if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                                 {
                                     setCursor(Qt::ClosedHandCursor);
                                     impl->enterPlotDrag(event->pos());
                                 }
                             }
                             else
                             {
                                 setCursor(Qt::ClosedHandCursor);
                                 impl->enterPlotDrag(event->pos());
                             }
                     }
                 }
                 // event->accept();
                 QWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::mouseDoubleClickEvent(QMouseEvent* event)
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::keyReleaseEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_Control:
                         event->accept();
                         break;
                     case Qt::Key_Shift:
                         event->accept();
                         break;
                     default:
                         QWidget::keyReleaseEvent(event);
                         break;
                 }
                 setCursor(Qt::ArrowCursor);
                 // event->accept();
             }
             void VisualizationGraphWidget::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_Control:
                         setCursor(Qt::CrossCursor);
                         break;
                     case Qt::Key_Shift:
                         break;
                     case Qt::Key_M:
                         impl->rescaleY();
                         impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                         break;
                     case Qt::Key_Left:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(-0.1, Qt::Horizontal);
                         }
                         else
                         {
                             zoom(2, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Right:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(0.1, Qt::Horizontal);
                         }
                         else
                         {
                             zoom(0.5, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Up:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(0.1, Qt::Vertical);
                         }
                         else
                         {
                             zoom(0.5, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     case Qt::Key_Down:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(-0.1, Qt::Vertical);
                         }
                         else
                         {
                             zoom(2, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     default:
                         QWidget::keyPressEvent(event);
                         break;
                 }
             }
             QCustomPlot& VisualizationGraphWidget::plot() const noexcept
             {
                 return *impl->m_plot;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint& pos) noexcept
             {
                 QMenu graphMenu {};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first))
                 {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                         [this, var = it->first]() { removeVariable(var); });
                 }
                 if (!impl->m_ZoomStack.isEmpty())
                 {
                     if (!graphMenu.isEmpty())
                     {
                         graphMenu.addSeparator();
                     }
                     graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
                 }
                 // Selection Zone Actions
                 auto selectionZoneItem = impl->selectionZoneAt(pos);
                 if (selectionZoneItem)
                 {
                     auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                     selectedItems.removeAll(selectionZoneItem);
                     selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
                     auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
                     if (!zoneActions.isEmpty() && !graphMenu.isEmpty())
                     {
                         graphMenu.addSeparator();
                     }
                     QHash<QString, QMenu*> subMenus;
                     QHash<QString, bool> subMenusEnabled;
                     QHash<QString, FilteringAction*> filteredMenu;
                     for (auto zoneAction : zoneActions)
                     {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         QString menuPath;
                         for (auto subMenuName : zoneAction->subMenuList())
                         {
                             menuPath += '/';
                             menuPath += subMenuName;
                             if (!subMenus.contains(menuPath))
                             {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[menuPath] = menu;
                                 subMenusEnabled[menuPath] = isEnabled;
                             }
                             else
                             {
                                 menu = subMenus.value(menuPath);
                                 if (isEnabled)
                                 {
                                     // The sub menu is enabled if at least one of its actions is enabled
                                     subMenusEnabled[menuPath] = true;
                                 }
                             }
                         }
                         FilteringAction* filterAction = nullptr;
                         if (sqpApp->actionsGuiController().isMenuFiltered(zoneAction->subMenuList()))
                         {
                             filterAction = filteredMenu.value(menuPath);
                             if (!filterAction)
                             {
                                 filterAction = new FilteringAction { this };
                                 filteredMenu[menuPath] = filterAction;
                                 menu->addAction(filterAction);
                             }
                         }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                             [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
                         if (filterAction && zoneAction->isFilteringAllowed())
                         {
                             filterAction->addActionToFilter(action);
                         }
                     }
                     for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it)
                     {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
                 if (!graphMenu.isEmpty())
                 {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent* event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent* event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->updateTooltip(event);
                 auto axisPos = impl->posToAxisPos(event->pos());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect)
                 {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 else if (impl->m_DrawingZone)
                 {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
                 if (auto parentZone = parentZoneWidget())
                 {
                     if (impl->pointIsInAxisRect(axisPos, plot()))
                     {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
                     else
                     {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones)
                 {
                     // Sets the appropriate cursor shape
                     auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
                     setCursor(cursorShape);
                     // Manages the hovered zone
                     if (selectionZoneItemUnderCursor != impl->m_HoveredZone)
                     {
                         if (impl->m_HoveredZone)
                         {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         impl->m_HoveredZone = selectionZoneItemUnderCursor;
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 else
                 {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
                     if (impl->m_HoveredZone)
                     {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_HasMovedMouse = true;
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent* event) noexcept
             {
                 // Processes event only if the wheel occurs on axis rect
                 if (!dynamic_cast<QCPAxisRect*>(impl->m_plot->layoutElementAt(event->posF())))
                 {
                     return;
                 }
                 auto value = event->angleDelta().x() + event->angleDelta().y();
                 if (value != 0)
                 {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
                     impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
                     auto zoomOrientations = QFlags<Qt::Orientation> {};
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
                     impl->m_plot->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY)
                     {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                         auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
                         axis->setRange(axis->range() + diff);
                         if (plot().noAntialiasingOnDrag())
                         {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                         // plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent* event) noexcept
             {
                 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
                 if (!isDragDropClick && isLeftClick)
                 {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox)
                     {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr)
                     {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos());
                         if (!zoneAtPos)
                         {
                             impl->startDrawingZone(event->pos());
                         }
                     }
                 }
                 // Allows zone edition only in selection zone mode without drag&drop
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
                 if (isSelectionZoneMode)
                 {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
                         && !isMultiSelectionClick)
                     {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             { selectionZoneItemUnderCursor });
                     }
                     else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick)
                     {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
                     else
                     {
                         // No selection change
                     }
                     if (selectionZoneItemUnderCursor && isLeftClick)
                     {
                         selectionZoneItemUnderCursor->setAssociatedEditedZones(
                             parentVisualizationWidget()->selectionZoneManager().selectedItems());
                     }
                 }
                 impl->m_HasMovedMouse = false;
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent* event) noexcept
             {
                 if (impl->m_DrawingZoomRect)
                 {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange { impl->m_DrawingZoomRect->topLeft->coords().x(),
                         impl->m_DrawingZoomRect->bottomRight->coords().x() };
                     auto newAxisYRange = QCPRange { impl->m_DrawingZoomRect->topLeft->coords().y(),
                         impl->m_DrawingZoomRect->bottomRight->coords().y() };
                     impl->removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0))
                     {
                         impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 impl->endDrawingZone();
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode)
                 {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
                         && !impl->m_HasMovedMouse)
                     {
                         auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
                         if (zonesUnderCursor.count() > 1)
                         {
                             // There are multiple zones under the mouse.
                             // Performs the selection with a selection dialog.
                             VisualizationMultiZoneSelectionDialog dialog { this };
                             dialog.setZones(zonesUnderCursor);
                             dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
                             dialog.activateWindow();
                             dialog.raise();
                             if (dialog.exec() == QDialog::Accepted)
                             {
                                 auto selection = dialog.selectedZones();
                                 if (!isMultiSelectionClick)
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                 }
                                 for (auto it = selection.cbegin(); it != selection.cend(); ++it)
                                 {
                                     auto zone = it.key();
                                     auto isSelected = it.value();
                                     parentVisualizationWidget()->selectionZoneManager().setSelected(
                                         zone, isSelected);
                                     if (isSelected)
                                     {
                                         // Puts the zone on top of the stack so it can be moved or resized
                                         impl->moveSelectionZoneOnTop(zone, plot());
                                     }
                                 }
                             }
                         }
                         else
                         {
                             if (!isMultiSelectionClick)
                             {
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     { selectionZoneItemUnderCursor });
                                 impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
                             }
                             else
                             {
                                 parentVisualizationWidget()->selectionZoneManager().setSelected(
                                     selectionZoneItemUnderCursor,
                                     !selectionZoneItemUnderCursor->selected()
                                         || event->button() == Qt::RightButton);
                             }
                         }
                     }
                     else
                     {
                         // No selection change
                     }
                 }
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = impl->m_plot->xAxis->range();
                 auto dateTime = DateTimeRange { graphRange.lower, graphRange.upper };
                 for (auto& variableEntry : impl->m_VariableToPlotMultiMap)
                 {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range()))
                     {
                         impl->updateData(variableEntry.second, variable, variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(
                 std::shared_ptr<Variable2> variable, const DateTimeRange& range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end())
                 {
                     impl->updateData(it->second, variable, range);
                 }
             }
             void VisualizationGraphWidget::variableUpdated(QUuid id)
             {
                 for (auto& [var, plotables] : impl->m_VariableToPlotMultiMap)
                 {
                     if (var->ID() == id)
                     {
                         impl->updateData(plotables, var, this->graphRange());
                     }
                 }
             }
             void VisualizationGraphWidget::variableDeleted(const std::shared_ptr<Variable2>& variable)
             {
                 this->removeVariable(variable);
             }

gui/tests/GUITestUtils/GUITestUtils.h +8 -8

             #ifndef GUITESTUTILS_H
             #define GUITESTUTILS_H
-            #include <Common/cpp_utils.h>
+            #include <types/detectors.hpp>
             #include <QCoreApplication>
             #include <QCursor>
             #include <QDesktopWidget>
             #include <QMouseEvent>
             #include <QPoint>
             #include <QtTest>
             #include <SqpApplication.h>
             #include <Variable/VariableController2.h>
             #include <qcustomplot.h>
             template <typename T>
             QPoint center(T* widget)
             {
                 return QPoint { widget->width() / 2, widget->height() / 2 };
             }
-            HAS_METHOD(viewport)
+            HAS_METHOD(has_viewport, viewport)
             template <typename T>
             static inline constexpr bool is_QWidgetOrDerived = std::is_base_of<QWidget, T>::value;
             template <typename T>
             using viewport_type = decltype(std::declval<T>().viewport());
-            HAS_METHOD(topLevelItem)
+            HAS_METHOD(has_topLevelItem, topLevelItem)
             template <typename T>
             void mouseMove(T* widget, QPoint pos, Qt::MouseButton mouseModifier)
             {
                 QCursor::setPos(widget->mapToGlobal(pos));
                 QMouseEvent event(QEvent::MouseMove, pos, Qt::NoButton, mouseModifier, Qt::NoModifier);
-                if constexpr (has_viewport<T>)
+                if constexpr (has_viewport_v<T>)
                 {
                     if constexpr (is_QWidgetOrDerived<viewport_type<T>>)
                     {
                         qApp->sendEvent(widget->viewport(), &event);
                     }
                     else
                     {
                         qApp->sendEvent(widget, &event);
                     }
                 }
                 else
                 {
                     qApp->sendEvent(widget, &event);
                 }
                 qApp->processEvents();
             }
             template <typename T>
             void setMouseTracking(T* widget)
             {
-                if constexpr (has_viewport<T>)
+                if constexpr (has_viewport_v<T>)
                 {
                     if constexpr (is_QWidgetOrDerived<viewport_type<T>>)
                     {
                         widget->viewport()->setMouseTracking(true);
                     }
                     else
                     {
                         widget->setMouseTracking(true);
                     }
                 }
                 else
                 {
                     widget->setMouseTracking(true);
                 }
             }
             template <typename T, typename T2>
             auto getItem(T* widget, T2 itemIndex)
             {
-                if constexpr (has_topLevelItem<T>)
+                if constexpr (has_topLevelItem_v<T>)
                 {
                     return widget->topLevelItem(itemIndex);
                 }
                 else
                 {
                     return widget->item(itemIndex);
                 }
             }
             #define SELECT_ITEM(widget, itemIndex, item)                                                       \
                 auto item = getItem(widget, itemIndex);                                                        \
                 {                                                                                              \
                     auto itemCenterPos = widget->visualItemRect(item).center();                                \
                     QTest::mouseClick(widget->viewport(), Qt::LeftButton, Qt::NoModifier, itemCenterPos);      \
                     QVERIFY(widget->selectedItems().size() > 0);                                               \
                     QVERIFY(widget->selectedItems().contains(item));                                           \
                 }
             #define GET_CHILD_WIDGET_FOR_GUI_TESTS(parent, child, childType, childName)                        \
                 childType* child = parent.findChild<childType*>(childName);                                    \
                 QVERIFY(child != Q_NULLPTR);                                                                   \
                 setMouseTracking(child);
             template <typename T1, typename T2, typename T3, typename T4 = void>
             void dragnDropItem(T1* sourceWidget, T2* destWidget, T3* item, T4* destItem = Q_NULLPTR)
             {
                 auto itemCenterPos = sourceWidget->visualItemRect(item).center();
-                if constexpr (has_viewport<T1>)
+                if constexpr (has_viewport_v<T1>)
                 {
                     QTest::mousePress(sourceWidget->viewport(), Qt::LeftButton, Qt::NoModifier, itemCenterPos);
                 }
                 else
                 {
                     QTest::mousePress(sourceWidget, Qt::LeftButton, Qt::NoModifier, itemCenterPos);
                 }
                 mouseMove(sourceWidget, itemCenterPos, Qt::LeftButton);
                 itemCenterPos += QPoint(0, -10);
                 QTimer::singleShot(100, [destWidget, destItem]() {
                     mouseMove(destWidget, destWidget->rect().center(), Qt::LeftButton);
                     mouseMove(destWidget, destWidget->rect().center() + QPoint(0, -10), Qt::LeftButton);
                     if constexpr (!std::is_same_v<void, T4>)
                     {
                         auto destItemCenterPos = destWidget->visualItemRect(destItem).center();
                         QTest::mouseRelease(destWidget, Qt::LeftButton, Qt::NoModifier, destItemCenterPos);
                     }
-                    else if constexpr (has_viewport<T2>)
+                    else if constexpr (has_viewport_v<T2>)
                     {
                         QTest::mouseRelease(destWidget->viewport(), Qt::LeftButton);
                     }
                     else
                     {
                         QTest::mouseRelease(destWidget, Qt::LeftButton);
                     }
                     QTest::mouseRelease(destWidget->viewport(), Qt::LeftButton);
                 });
                 mouseMove(sourceWidget, itemCenterPos, Qt::LeftButton);
             }
             template <typename T>
             void scroll_graph(T* w, int dx)
             {
                 auto cent = center(w);
                 QTest::mousePress(w, Qt::LeftButton, Qt::NoModifier, cent, 1);
                 mouseMove(w, { cent.x() + dx, cent.y() }, Qt::LeftButton);
                 QTest::mouseRelease(w, Qt::LeftButton);
             }
             ALIAS_TEMPLATE_FUNCTION(isReady, static_cast<SqpApplication*>(qApp)->variableController().isReady)
             void waitForVar(std::shared_ptr<Variable2> var)
             {
                 while (!isReady(var))
                     QCoreApplication::processEvents();
             }
             template <typename T>
             bool prepare_gui_test(T* w)
             {
                 w->setGeometry(QRect(
                     QPoint(QApplication::desktop()->geometry().center() - QPoint(250, 250)), QSize(500, 500)));
                 w->show();
                 qApp->setActiveWindow(w);
                 return QTest::qWaitForWindowActive(w);
             }
             #define GET_CHILD_WIDGET_FOR_GUI_TESTS(parent, child, childType, childName)                        \
                 childType* child = parent.findChild<childType*>(childName);                                    \
                 QVERIFY(child != Q_NULLPTR);                                                                   \
                 setMouseTracking(child);
             #endif

gui/tests/catalogue/browser/main.cpp +1 -1

             #include <QMainWindow>
             #include <QObject>
             #include <QScreen>
             #include <QString>
             #include <QWheelEvent>
             #include <QtTest>
             #include <cstdlib>
-            #include <Common/cpp_utils.h>
+            #include <cpp_utils.hpp>
             #include <SqpApplication.h>
             #include <GUITestUtils.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue2/browser.h>
             template <int EventsCount = 1000>
             auto build_CatalogueBrowser_test()
             {
                 sqpApp->catalogueController().add("test");
                 sqpApp->catalogueController().add("stuff");
                 sqpApp->catalogueController().add("default");
                 sqpApp->catalogueController().add("new catalogue", "default");
                 auto catalogue = sqpApp->catalogueController().add("new catalogue2", "default");
                 for (auto _ : std::array<char, EventsCount>())
                 {
                     (void)_;
                     static int i = 0;
                     auto event = CatalogueController::make_event_ptr();
                     event->name = std::string("Event ") + std::to_string(i++);
                     event->tags = { "tag1", "tag2" };
                     event->products = { CatalogueController::Event_t::Product_t {
                                             std::string("Product2") + std::to_string(rand() % 30),
                                             static_cast<double>(1532357932 + rand() % 100),
                                             static_cast<double>(1532358932 + rand() % 100) },
                         CatalogueController::Event_t::Product_t {
                             std::string("Product2") + std::to_string(rand() % 30),
                             static_cast<double>(1532357932 + rand() % 200),
                             static_cast<double>(1532358932 + rand() % 200) },
                         CatalogueController::Event_t::Product_t {
                             std::string("Product2") + std::to_string(rand() % 30),
                             static_cast<double>(1532357932 + rand() % 70),
                             static_cast<double>(1532358932 + rand() % 70) } };
                     catalogue->add(event);
                 }
                 return std::make_unique<CataloguesBrowser>();
             }
             class A_CatalogueBrowser : public QObject
             {
                 Q_OBJECT
             public:
                 explicit A_CatalogueBrowser(QObject* parent = Q_NULLPTR) : QObject(parent) {}
             private slots:
                 void can_sort_events()
                 {
                     auto w = build_CatalogueBrowser_test();
                     QVERIFY(prepare_gui_test(w.get()));
                     // GET_CHILD_WIDGET_FOR_GUI_TESTS((*w.get()),,,)
                     for (int i = 0; i < 1000000; i++)
                     {
                         QThread::usleep(100);
                         QCoreApplication::processEvents();
                     }
                 }
             };
             QT_BEGIN_NAMESPACE
             QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS
             QT_END_NAMESPACE
             int main(int argc, char* argv[])
             {
                 Q_INIT_RESOURCE(sqpguiresources);
                 SqpApplication app { argc, argv };
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 QTEST_DISABLE_KEYPAD_NAVIGATION;
                 QTEST_ADD_GPU_BLACKLIST_SUPPORT;
                 A_CatalogueBrowser tc;
                 QTEST_SET_MAIN_SOURCE_PATH;
                 return QTest::qExec(&tc, argc, argv);
             }
             #include "main.moc"

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