HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1437:614fe4639a50

Updated meson build defs...

jeandet -

r1437:614fe4639a50

parent child

Context file:

r1437:614fe4639a50

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 7c86e13f8a6242eb5fe07f0da91a96a4cf68b5bf		1	Subproject commit bf13292f0caf950333841131d023ed7cd96a97a2

gui/meson.build +5 -4

             gui_moc_headers = [
              './include/Common/VisualizationDef.h',
              './include/Common/ColorUtils.h',
              './include/DragAndDrop/DragDropGuiController.h',
              './include/DragAndDrop/DragDropTabSwitcher.h',
              './include/DragAndDrop/DragDropScroller.h',
              './include/Settings/SqpSettingsDialog.h',
              './include/Settings/SqpSettingsGeneralWidget.h',
              './include/DataSource/DataSourceTreeWidgetHelper.h',
              './include/DataSource/DataSourceTreeWidget.h',
              './include/DataSource/DataSourceTreeWidgetItem.h',
              './include/DataSource/DataSourceWidget.h',
              './include/Catalogue2/repositoriestreeview.h',
              './include/Catalogue2/browser.h',
              './include/Catalogue2/eventeditor.h',
              './include/Catalogue2/eventsmodel.h',
              './include/Catalogue2/eventstreeview.h',
              './include/Catalogue2/repositoriesmodel.h',
              './include/TimeWidget/TimeWidget.h',
              './include/SqpApplication.h',
              './include/SidePane/SqpSidePane.h',
              './include/Variable/RenameVariableDialog.h',
              './include/Variable/VariableInspectorWidget.h',
              './include/Variable/VariableInspectorTableView.h',
              './include/Variable/VariableMenuHeaderWidget.h',
              './include/Visualization/VisualizationDragWidget.h',
              './include/Visualization/VisualizationZoneWidget.h',
              './include/Visualization/operations/GenerateVariableMenuOperation.h',
              './include/Visualization/operations/RescaleAxeOperation.h',
              './include/Visualization/operations/RemoveVariableOperation.h',
              './include/Visualization/operations/MenuBuilder.h',
              './include/Visualization/operations/FindVariableOperation.h',
              './include/Visualization/VisualizationDefs.h',
              './include/Visualization/IVisualizationWidgetVisitor.h',
              './include/Visualization/SqpColorScale.h',
              './include/Visualization/VisualizationGraphRenderingDelegate.h',
              './include/Visualization/VisualizationGraphWidget.h',
              './include/Visualization/MacScrollBarStyle.h',
              './include/Visualization/IVisualizationWidget.h',
              './include/Visualization/qcustomplot.h',
              './include/Visualization/IGraphSynchronizer.h',
              './include/Visualization/QCPColorMapIterator.h',
              './include/Visualization/VisualizationActionManager.h',
              './include/Visualization/VisualizationTabWidget.h',
              './include/Visualization/IVariableContainer.h',
              './include/Visualization/AxisRenderingUtils.h',
              './include/Visualization/VisualizationMultiZoneSelectionDialog.h',
              './include/Visualization/VisualizationCursorItem.h',
              './include/Visualization/VisualizationWidget.h',
              './include/Visualization/PlottablesRenderingUtils.h',
              './include/Visualization/VisualizationSelectionZoneManager.h',
              './include/Visualization/QCustomPlotSynchronizer.h',
              './include/Visualization/VisualizationSelectionZoneItem.h',
              './include/Visualization/VisualizationDragDropContainer.h',
              './include/Visualization/ColorScaleEditor.h',
              './include/Visualization/VisualizationGraphHelper.h',
              './include/Actions/ActionsGuiController.h',
              './include/Actions/FilteringAction.h',
              './include/Actions/SelectionZoneAction.h'
+             ]
             gui_ui_files = [
              './ui/Settings/SqpSettingsGeneralWidget.ui',
              './ui/Settings/SqpSettingsDialog.ui',
              './ui/DataSource/DataSourceWidget.ui',
              './ui/Catalogue2/browser.ui',
              './ui/Catalogue2/eventeditor.ui',
              './ui/TimeWidget/TimeWidget.ui',
              './ui/SidePane/SqpSidePane.ui',
              './ui/Variable/RenameVariableDialog.ui',
              './ui/Variable/VariableInspectorWidget.ui',
              './ui/Variable/VariableMenuHeaderWidget.ui',
              './ui/Visualization/ColorScaleEditor.ui',
              './ui/Visualization/VisualizationZoneWidget.ui',
              './ui/Visualization/VisualizationMultiZoneSelectionDialog.ui',
              './ui/Visualization/VisualizationGraphWidget.ui',
              './ui/Visualization/VisualizationWidget.ui',
              './ui/Visualization/VisualizationTabWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : [
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@',
                              '@EXTRA_ARGS@'])
             rcc_files = rcc_gen.process(gui_qresources, extra_args : ['-name', 'sqpguiresources'])
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files)
             gui_sources = [
-              './src/Common/ColorUtils.cpp',
+             './src/Common/ColorUtils.cpp',
              './src/Common/VisualizationDef.cpp',
              './src/SqpApplication.cpp',
              './src/DragAndDrop/DragDropTabSwitcher.cpp',
              './src/DragAndDrop/DragDropScroller.cpp',
              './src/DragAndDrop/DragDropGuiController.cpp',
              './src/Settings/SqpSettingsGeneralWidget.cpp',
              './src/Settings/SqpSettingsDialog.cpp',
              './src/DataSource/DataSourceTreeWidgetItem.cpp',
              './src/DataSource/DataSourceTreeWidgetHelper.cpp',
              './src/DataSource/DataSourceWidget.cpp',
              './src/DataSource/DataSourceTreeWidget.cpp',
              './src/Catalogue2/eventstreeview.cpp',
              './src/Catalogue2/eventeditor.cpp',
              './src/Catalogue2/repositoriestreeview.cpp',
              './src/Catalogue2/browser.cpp',
              './src/Catalogue2/eventsmodel.cpp',
              './src/Catalogue2/repositoriesmodel.cpp',
              './src/TimeWidget/TimeWidget.cpp',
              './src/SidePane/SqpSidePane.cpp',
              './src/Variable/VariableInspectorTableView.cpp',
              './src/Variable/VariableInspectorWidget.cpp',
              './src/Variable/RenameVariableDialog.cpp',
              './src/Variable/VariableMenuHeaderWidget.cpp',
              './src/Visualization/VisualizationGraphWidget.cpp',
              './src/Visualization/PlottablesRenderingUtils.cpp',
              './src/Visualization/AxisRenderingUtils.cpp',
              './src/Visualization/VisualizationWidget.cpp',
              './src/Visualization/qcustomplot.cpp',
              './src/Visualization/VisualizationDragWidget.cpp',
              './src/Visualization/VisualizationActionManager.cpp',
              './src/Visualization/MacScrollBarStyle.cpp',
              './src/Visualization/VisualizationSelectionZoneManager.cpp',
              './src/Visualization/operations/FindVariableOperation.cpp',
              './src/Visualization/operations/RescaleAxeOperation.cpp',
              './src/Visualization/operations/MenuBuilder.cpp',
              './src/Visualization/operations/GenerateVariableMenuOperation.cpp',
              './src/Visualization/operations/RemoveVariableOperation.cpp',
              './src/Visualization/VisualizationSelectionZoneItem.cpp',
              './src/Visualization/VisualizationCursorItem.cpp',
              './src/Visualization/QCPColorMapIterator.cpp',
              './src/Visualization/QCustomPlotSynchronizer.cpp',
              './src/Visualization/ColorScaleEditor.cpp',
              './src/Visualization/VisualizationMultiZoneSelectionDialog.cpp',
              './src/Visualization/VisualizationTabWidget.cpp',
              './src/Visualization/VisualizationGraphHelper.cpp',
              './src/Visualization/VisualizationGraphRenderingDelegate.cpp',
              './src/Visualization/VisualizationDragDropContainer.cpp',
              './src/Visualization/VisualizationZoneWidget.cpp',
              './src/Visualization/SqpColorScale.cpp',
              './src/Actions/FilteringAction.cpp',
              './src/Actions/SelectionZoneAction.cpp',
-             './src/Actions/ActionsGuiController.cpp',
+             './src/Actions/ActionsGuiController.cpp'
+             ]
             gui_inc = include_directories(['include', 'include/Visualization'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    rcc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

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

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <Variable/Variable2.h>
             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](const 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();
                         }
                     }
                 }
             };
             /**
              * 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)
                 {
                     // TODO
                     //        double min, max;
                     //        std::tie(min, max) = dataSeries.yBounds();
                     //        if (!std::isnan(min) && !std::isnan(max))
                     //        {
                     //            plot.yAxis->setRange(QCPRange { min, max });
                     //        }
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // TODO
                     //        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);
                     //        dataSeries.lockRead();
                     //        // Processing spectrogram data for display in QCustomPlot
                     //        auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     //        // Computes logarithmic y-axis resolution for the spectrogram
                     //        auto yData = its.first->y();
                     //        auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
                     //        // Generates mesh for colormap
                     //        auto mesh = DataSeriesUtils::regularMesh(its.first, its.second,
                     //            DataSeriesUtils::Resolution { dataSeries.xResolution() }, yResolution);
                     //        dataSeries.unlock();
                     //        colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
                     //        if (!mesh.isEmpty())
                     //        {
                     //            colormap->data()->setRange(QCPRange { mesh.m_XMin, mesh.xMax() },
                     //                // y-axis range is converted to linear values
                     //                QCPRange { std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax()) });
                     //            // Sets values
                     //            auto index = 0;
                     //            for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it,
                     //            ++index)
                     //            {
                     //                auto xIndex = index % mesh.m_NbX;
                     //                auto yIndex = index / mesh.m_NbX;
                     //                colormap->data()->setCell(xIndex, yIndex, *it);
                     //                // Makes the NaN values to be transparent in the colormap
                     //                if (std::isnan(*it))
                     //                {
                     //                    colormap->data()->setAlpha(xIndex, yIndex, 0);
                     //                }
                     //            }
                     //        }
                     //        // Rescales axes
                     //        auto plot = colormap->parentPlot();
                     //        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);
             }

plugins/python_providers/include/python_interpreter.h 0 -1

-            #include <Data/DateTimeRange.h>
             #include <TimeSeries.h>
             #include <functional>
             #include <iostream>
             #include <memory>
             class PythonInterpreter
             {
             public:
                 using provider_funct_t = std::function<std::shared_ptr<TimeSeries::ITimeSerie>(
                     std::vector<std::tuple<std::string, std::string>>&, double, double)>;
                 using product_t = std::tuple<std::string, std::vector<std::string>,
                     std::vector<std::pair<std::string, std::string>>>;
                 PythonInterpreter();
                 void add_register_callback(
                     std::function<void(const std::vector<product_t>&, provider_funct_t)> callback);
                 ~PythonInterpreter();
                 void eval(const std::string& file);
                 void release();
             private:
             };

plugins/python_providers/meson.build +12 -1

             pybind11_dep = dependency('pybind11', required : true, fallback:['pybind11','pybind11_dep'])
             python_providers_moc_headers = [
               'include/python_providers.h'
             ]
             python_providers_sources = [
               'src/python_providers.cpp'
             ]
             python_providers_inc = include_directories(['include'])
             gen = generator(moc,
                             output  : 'moc_@BASENAME@.cpp',
                             arguments : ['@INPUT@',
                              '-DSCIQLOP_PLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/python_providers/resources/python_providers.json"',
                              '-I', meson.current_source_dir()+'/include',
                              '-I', meson.current_source_dir()+'/../../core/include/',
                              '-o', '@OUTPUT@'])
             python_providers_moc_files = gen.process(python_providers_moc_headers)
-            cpp_args = ['-DPYTHON_PROVIDERS_LIB','-DQT_PLUGIN', '-DQT_NO_KEYWORDS']
+            cpp_args = ['-DPYTHON_PROVIDERS_LIB','-DQT_PLUGIN']
             if(get_option('default_library')=='static')
                 cpp_args += ['-DQT_STATICPLUGIN']
             endif
+            sciqlop_python_interpreter = library('python_interpreter',
+                                                 ['src/python_interpreter.cpp'],
+                                                 include_directories : [python_providers_inc],
+                                                 dependencies : [pybind11_dep, sciqlop_core],
+                                                 cpp_args : ['-DQT_NO_KEYWORDS'],
+                                                 install : true,
+                                                 install_dir : join_paths(get_option('libdir'), 'SciQLop')
+                                                 )
             sciqlop_python_providers = library('pythonproviders',
                                    python_providers_sources,
                                    python_providers_moc_files,
                                    cpp_args : cpp_args,
                                    include_directories : [python_providers_inc],
+                                   link_with : [sciqlop_python_interpreter],
                                    dependencies : [sciqlop_core, sciqlop_gui, pybind11_dep],
                                    install : true,
                                    install_dir : join_paths(get_option('libdir'), 'SciQLop')
                                    )

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