GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r670:94000392d1e8

Adds button on plot overlay to show/hide x-axis properties

Alexandre Leroux -

r670:94000392d1e8

parent child

Context file:

r670:94000392d1e8

Collapse all files

gui/resources/icones/down.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/up.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/include/Visualization/VisualizationGraphRenderingDelegate.h +4 0

             #ifndef SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
             #define SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
             #include <Common/spimpl.h>
             class QCustomPlot;
             class QMouseEvent;
+            class Unit;
             class VisualizationGraphWidget;
             class VisualizationGraphRenderingDelegate {
             public:
                 /// Ctor
                 /// @param graphWidget the graph widget to which the delegate is associated
                 /// @remarks the graph widget must exist throughout the life cycle of the delegate
                 explicit VisualizationGraphRenderingDelegate(VisualizationGraphWidget &graphWidget);
                 void onMouseMove(QMouseEvent *event) noexcept;
+                /// Sets properties of the plot's axes
+                void setAxesProperties(const Unit &xAxisUnit, const Unit &valuesUnit) noexcept;
                 /// Shows or hides graph overlay (name, close button, etc.)
                 void showGraphOverlay(bool show) noexcept;
             private:
                 class VisualizationGraphRenderingDelegatePrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphRenderingDelegatePrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H

gui/resources/sqpguiresources.qrc +2 0

             <RCC>
                 <qresource prefix="/">
             		<file>icones/dataSourceComponent.png</file>
             		<file>icones/dataSourceNode.png</file>
             		<file>icones/dataSourceProduct.png</file>
             		<file>icones/dataSourceRoot.png</file>
             		<file>icones/delete.png</file>
+                    <file>icones/down.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
                     <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
                     <file>icones/unplot.png</file>
+                    <file>icones/up.png</file>
                 </qresource>
             </RCC>

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

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
-            /// Format for datetimes on a axis
-            const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
-            /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
-            /// non-time data
-            QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
-                if (isTimeAxis) {
-                    auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
-                    dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
-                    dateTicker->setDateTimeSpec(Qt::UTC);
-                    return dateTicker;
-                else {
-                    // default ticker
-                    return QSharedPointer<QCPAxisTicker>::create();
-            /// Sets axes properties according to the properties of a data series. Not thread safe
-            template <int Dim>
-            void setAxesProperties(const DataSeries<Dim> &dataSeries, QCustomPlot &plot) noexcept
-                /// @todo : for the moment, no control is performed on the axes: the units and the tickers
-                /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
-                auto setAxisProperties = [](auto axis, const auto &unit) {
-                    // label (unit name)
-                    axis->setLabel(unit.m_Name);
-                    // ticker (depending on the type of unit)
-                    axis->setTicker(axisTicker(unit.m_TimeUnit));
-                };
-                setAxisProperties(plot.xAxis, dataSeries.xAxisUnit());
-                setAxisProperties(plot.yAxis, dataSeries.valuesUnit());
             /**
              * 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(T &, QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                     return {};
                 }
             };
             /**
              * Specialization of PlottablesCreator for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     // Gets the number of components of the data series
                     dataSeries.lockRead();
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     dataSeries.unlock();
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plot.addGraph();
                         graph->setPen(QPen{colors.at(i)});
                         result.insert({i, graph});
                     }
-                    // Axes properties
-                    dataSeries.lockRead();
-                    setAxesProperties(dataSeries, plot);
-                    dataSeries.unlock();
                     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 updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
                     qCCritical(LOG_DataSeries())
                         << 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<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
                     for (const auto &plottable : plottables) {
                         if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             graph->setData(dataContainer);
                             dataContainers.insert({plottable.first, dataContainer});
                         }
                     }
                     dataSeries.lockRead();
                     // - Gets the data of the series included in the current range
                     // - Updates each plottable by adding, for each data item, a point that takes x-axis data
                     // and value data. The correct value is retrieved according to the index of the component
                     auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
                         for (const auto &dataContainer : dataContainers) {
                             auto componentIndex = dataContainer.first;
                             dataContainer.second->appendGraphData(
                                 QCPGraphData(it->x(), it->value(componentIndex)));
                         }
                     }
                     dataSeries.unlock();
                     if (!plottables.empty()) {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes) {
                             plot->rescaleAxes();
                         }
                         plot->replot();
                     }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
                 virtual void update(PlottablesMap &plottables, const SqpRange &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(T &dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
                     PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
                 }
                 T &m_DataSeries;
             };
             /// Creates IPlottablesHelper according to a data series
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     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::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +107 -1

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/DateUtils.h>
+            #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             namespace {
+            /// Name of the axes layer in QCustomPlot
+            const auto AXES_LAYER = QStringLiteral("axes");
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
+            /// Format for datetimes on a axis
+            const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
+            /// Icon used to show x-axis properties
+            const auto HIDE_AXIS_ICON_PATH = QStringLiteral(":/icones/down.png");
             /// Name of the overlay layer in QCustomPlot
             const auto OVERLAY_LAYER = QStringLiteral("overlay");
+            /// Pixmap used to show x-axis properties
+            const auto SHOW_AXIS_ICON_PATH = QStringLiteral(":/icones/up.png");
             const auto TOOLTIP_FORMAT = QStringLiteral("key: %1\nvalue: %2");
             /// Offset used to shift the tooltip of the mouse
             const auto TOOLTIP_OFFSET = QPoint{20, 20};
             /// Tooltip display rectangle (the tooltip is hidden when the mouse leaves this rectangle)
             const auto TOOLTIP_RECT = QRect{10, 10, 10, 10};
             /// Timeout after which the tooltip is displayed
             const auto TOOLTIP_TIMEOUT = 500;
+            /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
+            /// non-time data
+            QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
+            {
+                if (isTimeAxis) {
+                    auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
+                    dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
+                    dateTicker->setDateTimeSpec(Qt::UTC);
+                    return dateTicker;
+                }
+                else {
+                    // default ticker
+                    return QSharedPointer<QCPAxisTicker>::create();
+                }
+            }
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
                     return QString::number(value);
                 }
             }
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsCircle);
                 tracer.setSize(3);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
             }
+            QPixmap pixmap(const QString &iconPath) noexcept
+            {
+                return QIcon{iconPath}.pixmap(QSize{16, 16});
+            }
             void initClosePixmapStyle(QCPItemPixmap &pixmap) noexcept
             {
                 // Icon
                 pixmap.setPixmap(
                     sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton).pixmap(QSize{16, 16}));
                 // Position
                 pixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 pixmap.topLeft->setCoords(1, 0);
                 pixmap.setClipToAxisRect(false);
                 // Can be selected
                 pixmap.setSelectable(true);
             }
+            void initXAxisPixmapStyle(QCPItemPixmap &itemPixmap) noexcept
+            {
+                // Icon
+                itemPixmap.setPixmap(pixmap(HIDE_AXIS_ICON_PATH));
+                // Position
+                itemPixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
+                itemPixmap.topLeft->setCoords(0, 1);
+                itemPixmap.setClipToAxisRect(false);
+                // Can be selected
+                itemPixmap.setSelectable(true);
+            }
             void initTitleTextStyle(QCPItemText &text) noexcept
             {
                 // Font and background styles
                 text.setColor(Qt::gray);
                 text.setBrush(Qt::white);
                 // Position
                 text.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 text.position->setType(QCPItemPosition::ptAxisRectRatio);
                 text.position->setCoords(0.5, 0);
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget &graphWidget)
                         : m_Plot{graphWidget.plot()},
                           m_PointTracer{new QCPItemTracer{&m_Plot}},
                           m_TracerTimer{},
                           m_ClosePixmap{new QCPItemPixmap{&m_Plot}},
-                          m_TitleText{new QCPItemText{&m_Plot}}
+                          m_TitleText{new QCPItemText{&m_Plot}},
+                          m_XAxisPixmap{new QCPItemPixmap{&m_Plot}},
+                          m_ShowXAxis{true},
+                          m_XAxisLabel{}
                 {
                     initPointTracerStyle(*m_PointTracer);
                     m_TracerTimer.setInterval(TOOLTIP_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                     // Inits "close button" in plot overlay
                     m_ClosePixmap->setLayer(OVERLAY_LAYER);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
                     QObject::connect(m_ClosePixmap, &QCPItemPixmap::selectionChanged,
                                      [&graphWidget](bool selected) {
                                          if (selected) {
                                              graphWidget.close();
                                          }
                                      });
                     // Inits graph name in plot overlay
                     m_TitleText->setLayer(OVERLAY_LAYER);
                     m_TitleText->setText(graphWidget.name());
                     initTitleTextStyle(*m_TitleText);
+                    // Inits "show x-axis button" in plot overlay
+                    m_XAxisPixmap->setLayer(OVERLAY_LAYER);
+                    initXAxisPixmapStyle(*m_XAxisPixmap);
+                    // Connects pixmap selection to graph x-axis showing/hiding
+                    QObject::connect(m_XAxisPixmap, &QCPItemPixmap::selectionChanged, [this]() {
+                        if (m_XAxisPixmap->selected()) {
+                            // Changes the selection state and refreshes the x-axis
+                            m_ShowXAxis = !m_ShowXAxis;
+                            updateXAxisState();
+                            m_Plot.layer(AXES_LAYER)->replot();
+                            // Deselects the x-axis pixmap and updates icon
+                            m_XAxisPixmap->setSelected(false);
+                            m_XAxisPixmap->setPixmap(
+                                pixmap(m_ShowXAxis ? HIDE_AXIS_ICON_PATH : SHOW_AXIS_ICON_PATH));
+                            m_Plot.layer(OVERLAY_LAYER)->replot();
+                        }
+                    });
+                }
+                /// Updates state of x-axis according to the current selection of x-axis pixmap
+                /// @remarks the method doesn't call plot refresh
+                void updateXAxisState() noexcept
+                {
+                    m_Plot.xAxis->setTickLabels(m_ShowXAxis);
+                    m_Plot.xAxis->setLabel(m_ShowXAxis ? m_XAxisLabel : QString{});
                 }
                 QCustomPlot &m_Plot;
                 QCPItemTracer *m_PointTracer;
                 QTimer m_TracerTimer;
                 QCPItemPixmap *m_ClosePixmap; /// Graph's close button
                 QCPItemText *m_TitleText;     /// Graph's title
+                QCPItemPixmap *m_XAxisPixmap;
+                bool m_ShowXAxis; /// X-axis properties are shown or hidden
+                QString m_XAxisLabel;
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
                 VisualizationGraphWidget &graphWidget)
                     : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(graphWidget)}
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 // Reinits tracers
                 impl->m_PointTracer->setGraph(nullptr);
                 impl->m_PointTracer->setVisible(false);
                 impl->m_Plot.replot();
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
                 if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
                     auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                     auto graphData = graph->data();
                     // Gets the closest data point to the mouse
                     auto graphDataIt = graphData->findBegin(mouseKey);
                     if (graphDataIt != graphData->constEnd()) {
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         // Displays point tracer
                         impl->m_PointTracer->setGraph(graph);
                         impl->m_PointTracer->setGraphKey(graphDataIt->key);
                         impl->m_PointTracer->setLayer(
                             impl->m_Plot.layer("main")); // Tracer is set on top of the plot's main layer
                         impl->m_PointTracer->setVisible(true);
                         impl->m_Plot.replot();
                         // Starts timer to show tooltip after timeout
                         auto showTooltip = [ tooltip = TOOLTIP_FORMAT.arg(key, value), eventPos, this ]()
                         {
                             QToolTip::showText(impl->m_Plot.mapToGlobal(eventPos) + TOOLTIP_OFFSET, tooltip,
                                                &impl->m_Plot, TOOLTIP_RECT);
                         };
                         QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTooltip);
                         impl->m_TracerTimer.start();
                     }
                 }
             }
+            void VisualizationGraphRenderingDelegate::setAxesProperties(const Unit &xAxisUnit,
+                                                                        const Unit &valuesUnit) noexcept
+            {
+                // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
+                impl->m_XAxisLabel = xAxisUnit.m_Name;
+                auto setAxisProperties = [](auto axis, const auto &unit) {
+                    // label (unit name)
+                    axis->setLabel(unit.m_Name);
+                    // ticker (depending on the type of unit)
+                    axis->setTicker(axisTicker(unit.m_TimeUnit));
+                };
+                setAxisProperties(impl->m_Plot.xAxis, xAxisUnit);
+                setAxisProperties(impl->m_Plot.yAxis, valuesUnit);
+                // Updates x-axis state
+                impl->updateXAxisState();
+                impl->m_Plot.layer(AXES_LAYER)->replot();
+            }
             void VisualizationGraphRenderingDelegate::showGraphOverlay(bool show) noexcept
             {
                 auto overlay = impl->m_Plot.layer(OVERLAY_LAYER);
                 overlay->setVisible(show);
                 overlay->replot();
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +14 0

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
+                // Set axes properties according to the units of the data series
+                /// @todo : for the moment, no control is performed on the axes: the units and the tickers
+                /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
+                auto xAxisUnit = Unit{};
+                auto valuesUnit = Unit{};
+                if (auto dataSeries = variable->dataSeries()) {
+                    dataSeries->lockRead();
+                    xAxisUnit = dataSeries->xAxisUnit();
+                    valuesUnit = dataSeries->valuesUnit();
+                    dataSeries->unlock();
+                }
+                impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 auto varRange = variable->range();
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, varRange,
                                         false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> 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()) {
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
             {
                 // Note: in case of different axes that depends on variable, we could start with a code like
                 // that:
                 //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                 //    }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setYRange(const SqpRange &range)
             {
                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             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(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &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;
             }
             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);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             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 (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{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())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

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