HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1364:60a7242b38cd

[VisualizationGraphWidget] Restored box zoom and zones plus refac...

jeandet -

r1364:60a7242b38cd

parent child

Context file:

r1364:60a7242b38cd

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

                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
-                QPoint _dragLastPos;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;

gui/src/Visualization/VisualizationGraphWidget.cpp +144 -130

                           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<Variable> variable,
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 GraphFlags m_Flags;
                 bool m_IsCalibration;
+                QCustomPlot* m_plot;
+                QPoint m_lastMousePos;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 bool m_VariableAutoRangeOnInit = true;
-                void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
+                inline void updateMousePosition(const QPoint& position)
+                {
+                    m_lastMousePos = position;
+                }
+                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)
                 {
-                    removeDrawingRect(plot);
+                    m_DrawingZone->setEnd(m_plot->xAxis->pixelToCoord(newPos.x()));
+                    m_plot->replot(QCustomPlot::rpQueuedReplot);
+                }
+                void startDrawingRect(const QPoint &pos)
+                {
+                    removeDrawingRect();
-                    auto axisPos = posToAxisPos(pos, plot);
+                    auto axisPos = posToAxisPos(pos);
-                    m_DrawingZoomRect = new QCPItemRect{&plot};
+                    m_DrawingZoomRect = new QCPItemRect{m_plot};
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
-                void removeDrawingRect(QCustomPlot &plot)
+                void removeDrawingRect()
                 {
                     if (m_DrawingZoomRect) {
-                        plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
+                        m_plot->removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
-                        plot.replot(QCustomPlot::rpQueuedReplot);
+                        m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 {
                     endDrawingZone(graph);
-                    auto axisPos = posToAxisPos(pos, graph->plot());
+                    auto axisPos = posToAxisPos(pos);
-                    m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
+                    m_DrawingZone = new VisualizationSelectionZoneItem{m_plot};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
-                VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
+                VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos) const
-                                                                const QCustomPlot &plot) 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 < plot.selectionTolerance()) {
+                            && distanceToZone >= 0 && distanceToZone < m_plot->selectionTolerance()) {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     }
                 }
-                QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
+                QPointF posToAxisPos(const QPoint &pos) const
                 {
-                    auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
+                    auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
-                    auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
+                    auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
                 }
                     }
                 }
-                void moveGraph(const QPoint& origin, const QPoint& destination, QCustomPlot* plot)
+                void moveGraph(const QPoint& destination)
                 {
                     auto currentPos = destination;
-                    auto xAxis = plot->axisRect()->rangeDragAxis(Qt::Horizontal);
+                    auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
-                    auto yAxis = plot->axisRect()->rangeDragAxis(Qt::Vertical);
+                    auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
-                    xAxis->setRange(_pixDistanceToRange(origin.x(), currentPos.x(), xAxis));
+                    xAxis->setRange(_pixDistanceToRange(m_lastMousePos.x(), currentPos.x(), xAxis));
-                    yAxis->setRange(_pixDistanceToRange(origin.y(), currentPos.y(), yAxis));
+                    yAxis->setRange(_pixDistanceToRange(m_lastMousePos.y(), currentPos.y(), yAxis));
                     setRange(xAxis->range());
-                    plot->replot(QCustomPlot::rpQueuedReplot);
+                    m_plot->replot(QCustomPlot::rpQueuedReplot);
+                    m_lastMousePos = destination;
                 }
             };
                       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);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
-                // ↓ swhitch to this ASAP, VisualizationGraphWidget should intercept all UI events
                 this->setFocusPolicy(Qt::WheelFocus);
                 this->setMouseTracking(true);
-                ui->widget->setAttribute(Qt::WA_TransparentForMouseEvents);
+                impl->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
-                //    connect(ui->widget, &QCustomPlot::mousePress, this,
+                impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
-                //    &VisualizationGraphWidget::onMousePress); connect(ui->widget, &QCustomPlot::mouseRelease,
+                impl->m_plot->setParent(this);
-                //    this,
-                //            &VisualizationGraphWidget::onMouseRelease);
-                //    connect(ui->widget, &QCustomPlot::mouseMove, this,
-                //    &VisualizationGraphWidget::onMouseMove); connect(ui->widget, &QCustomPlot::mouseWheel,
-                //    this, &VisualizationGraphWidget::onMouseWheel); connect(ui->widget,
-                //    &QCustomPlot::mouseDoubleClick, this,
-                //            &VisualizationGraphWidget::onMouseDoubleClick);
-                //    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);
-                //@TODO implement this :)
-                //    connect(this, &VisualizationGraphWidget::requestDataLoading,
-                //    &sqpApp->variableController(),
-                //            &VariableController::onRequestDataLoading);
-                //    connect(&sqpApp->variableController(), &VariableController2::updateVarDisplaying, this,
-                //            &VisualizationGraphWidget::onUpdateVarDisplaying);
-                // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
-                plot().setPlottingHint(QCP::phFastPolylines, true);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, DateTimeRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
-                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                auto createdPlottables = VisualizationGraphHelper::create(variable, *impl->m_plot);
                 // Sets graph properties
                 impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
-                        ui->widget->removePlottable(plottableIt->second);
+                        impl->m_plot->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                 }
                 // Updates graph
-                ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             std::vector<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
                     return;
                 }
-                VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
+                VisualizationGraphHelper::setYAxisRange(variable, *impl->m_plot);
             }
             DateTimeRange VisualizationGraphWidget::graphRange() const noexcept
             {
-                auto graphRange = ui->widget->xAxis->range();
+                auto graphRange = impl->m_plot->xAxis->range();
                 return DateTimeRange{graphRange.lower, graphRange.upper};
             }
                     impl->m_IsCalibration = true;
                 }
-                ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
+                impl->m_plot->xAxis->setRange(range.m_TStart, range.m_TEnd);
-                ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                 if (calibration) {
                     impl->m_IsCalibration = false;
             void VisualizationGraphWidget::zoom(double factor, int center, Qt::Orientation orientation)
             {
-                QCPAxis *axis = ui->widget->axisRect()->rangeZoomAxis(orientation);
+                QCPAxis *axis = impl->m_plot->axisRect()->rangeZoomAxis(orientation);
                 axis->scaleRange(factor, axis->pixelToCoord(center));
                 if (orientation == Qt::Horizontal)
                     impl->setRange(axis->range());
-                ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::move(double factor, Qt::Orientation orientation)
             {
-                auto oldRange = ui->widget->xAxis->range();
+                auto oldRange = impl->m_plot->xAxis->range();
-                QCPAxis *axis = ui->widget->axisRect()->rangeDragAxis(orientation);
+                QCPAxis *axis = impl->m_plot->axisRect()->rangeDragAxis(orientation);
-                if (ui->widget->xAxis->scaleType() == QCPAxis::stLinear) {
+                if (impl->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 (ui->widget->xAxis->scaleType() == QCPAxis::stLogarithmic) {
+                else if (impl->m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic) {
                     int start = 0, stop = 0;
                     double diff = 0.;
                     if (factor > 0.0) {
                         stop = 2 * this->width() * factor / 10;
                     }
                     diff = axis->pixelToCoord(start) / axis->pixelToCoord(stop);
-                    axis->setRange(ui->widget->axisRect()->rangeDragAxis(orientation)->range().lower * diff,
+                    axis->setRange(impl->m_plot->axisRect()->rangeDragAxis(orientation)->range().lower * diff,
-                                   ui->widget->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
+                                   impl->m_plot->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
                 }
                 if (orientation == Qt::Horizontal)
                     impl->setRange(axis->range());
-                ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 auto mimeData = new QMimeData;
-                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
             {
-                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeVerCursor);
-                        factor = pow(ui->widget->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
+                        factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
                         zoom(factor, event->pos().y(), Qt::Vertical);
                     }
                 }
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeHorCursor);
-                        factor = pow(ui->widget->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
+                        factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
                         zoom(factor, event->pos().x(), Qt::Horizontal);
                     }
                 }
             void VisualizationGraphWidget::mouseMoveEvent(QMouseEvent *event)
             {
-                if (event->buttons() == Qt::LeftButton)
+                if(impl->isDrawingZoomRect())
                 {
-                    impl->moveGraph(_dragLastPos, event->pos(), ui->widget);
+                    impl->updateZoomRect(event->pos());
-                    _dragLastPos = event->pos();
                 }
-                else if(impl->m_DrawingZoomRect)
+                else if (impl->isDrawingZoneRect())
                 {
-                    QPointF pos{ui->widget->xAxis->pixelToCoord(event->pos().x()), ui->widget->yAxis->pixelToCoord(event->pos().y())};
+                    impl->updateZoneRect(event->pos());
-                    impl->m_DrawingZoomRect->bottomRight->setCoords(pos);
                 }
-                else if (impl->m_DrawingZone)
+                else if (event->buttons() == Qt::LeftButton)
                 {
-                    impl->m_DrawingZone->setEnd(ui->widget->xAxis->pixelToCoord(event->pos().x()));
+                    impl->moveGraph(event->pos());
                 }
                 else
                 {
             void VisualizationGraphWidget::mouseReleaseEvent(QMouseEvent *event)
             {
+                if(impl->isDrawingZoomRect())
+                {
+                    impl->applyZoomRect();
+                }
+                else if(impl->isDrawingZoneRect())
+                {
+                    impl->endDrawingZone(this);
+                }
+                else
+                {
                     setCursor(Qt::ArrowCursor);
+                }
                 QWidget::mouseReleaseEvent(event);
             }
                 if (event->button() == Qt::LeftButton) {
                     if (event->modifiers() == Qt::ControlModifier) {
                     }
-                    else {
+                    else if (event->modifiers() == Qt::AltModifier) {
+                    }
+                    else
+                    {
+                        switch (sqpApp->plotsInteractionMode())
+                        {
+                        case SqpApplication::PlotsInteractionMode::DragAndDrop :
+                            break;
+                        case SqpApplication::PlotsInteractionMode::SelectionZones :
+                            if (!impl->selectionZoneAt(event->pos())) {
+                                impl->startDrawingZone(event->pos(), this);
+                            }
+                            break;
+                        case SqpApplication::PlotsInteractionMode::ZoomBox :
+                            impl->startDrawingRect(event->pos());
+                            break;
+                        default:
                             setCursor(Qt::ClosedHandCursor);
-                        this->_dragLastPos = event->pos();
+                            impl->updateMousePosition(event->pos());
+                        }
                     }
                 }
                 else if (event->button()==Qt::RightButton)
                     case Qt::Key_Shift:
                         break;
                     case Qt::Key_M:
-                        ui->widget->rescaleAxes();
+                        impl->m_plot->rescaleAxes();
-                        ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                        impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                         break;
                     case Qt::Key_Left:
                         if (event->modifiers() != Qt::ControlModifier) {
             QCustomPlot &VisualizationGraphWidget::plot() const noexcept
             {
-                return *ui->widget;
+                return *impl->m_plot;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
                 }
                 // Selection Zone Actions
-                auto selectionZoneItem = impl->selectionZoneAt(pos, plot());
+                auto selectionZoneItem = impl->selectionZoneAt(pos);
                 if (selectionZoneItem) {
                     auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                     selectedItems.removeAll(selectionZoneItem);
                 }
             }
-            //void VisualizationGraphWidget::onRangeChanged(const QCPRange &newRange, const QCPRange &oldRange)
-            //{
-            //    auto graphRange = DateTimeRange{newRange.lower, newRange.upper};
-            //    auto oldGraphRange = DateTimeRange{oldRange.lower, oldRange.upper};
-            //    if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
-            //        for (auto it = impl->m_VariableToPlotMultiMap.begin(),
-            //                  end = impl->m_VariableToPlotMultiMap.end();
-            //             it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
-            //            sqpApp->variableController().asyncChangeRange(it->first, graphRange);
-            //        }
-            //    }
-            //    //    if (impl->m_Flags.testFlag(GraphFlag::EnableSynchronization) && !impl->m_IsCalibration)
-            //    //    {
-            //    //        emit synchronize(graphRange, oldGraphRange);
-            //    //    }
-            //    //    auto pos = mapFromGlobal(QCursor::pos());
-            //    //    auto axisPos = impl->posToAxisPos(pos, plot());
-            //    //    if (auto parentZone = parentZoneWidget()) {
-            //    //        if (impl->pointIsInAxisRect(axisPos, plot())) {
-            //    //            parentZone->notifyMouseMoveInGraph(pos, axisPos, this);
-            //    //        }
-            //    //        else {
-            //    //            parentZone->notifyMouseLeaveGraph(this);
-            //    //        }
-            //    //    }
-            //    // Quits calibration
-            //    //    impl->m_IsCalibration = false;
-            //}
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->updateTooltip(event);
-                auto axisPos = impl->posToAxisPos(event->pos(), plot());
+                auto axisPos = impl->posToAxisPos(event->pos());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect) {
                 }
                 // Search for the selection zone under the mouse
-                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 // Processes event only if the wheel occurs on axis rect
-                if (!dynamic_cast<QCPAxisRect *>(ui->widget->layoutElementAt(event->posF()))) {
+                if (!dynamic_cast<QCPAxisRect *>(impl->m_plot->layoutElementAt(event->posF()))) {
                     return;
                 }
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
-                    ui->widget->axisRect()->setRangeZoom(zoomOrientations);
+                    impl->m_plot->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY) {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 if (!isDragDropClick && isLeftClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
-                        impl->startDrawingRect(event->pos(), plot());
+                        impl->startDrawingRect(event->pos());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
-                        auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
+                        auto zoneAtPos = impl->selectionZoneAt(event->pos());
                         if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos(), this);
                         }
                 // Selection / Deselection
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
-                    auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
+                    auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
                     auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().y()};
-                    impl->removeDrawingRect(plot());
+                    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)) {
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
-                    auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
+                    auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
                         && !impl->m_HasMovedMouse) {
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
-                auto graphRange = ui->widget->xAxis->range();
+                auto graphRange = impl->m_plot->xAxis->range();
                 auto dateTime = DateTimeRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {

gui/ui/Visualization/VisualizationGraphWidget.ui 0 -18

@@ -26,26 +26,8
26	<property name="bottomMargin">	26	<property name="bottomMargin">
27	<number>0</number>	27	<number>0</number>
28	</property>	28	</property>
29	<item>
30	<widget class="QCustomPlot" name="widget" native="true">
31	<property name="sizePolicy">
32	<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
33	<horstretch>0</horstretch>
34	<verstretch>0</verstretch>
35	</sizepolicy>
36	</property>
37	</widget>
38	</item>
39	</layout>	29	</layout>
40	</widget>	30	</widget>
41	<customwidgets>
42	<customwidget>
43	<class>QCustomPlot</class>
44	<extends>QWidget</extends>
45	<header>Visualization/qcustomplot.h</header>
46	<container>1</container>
47	</customwidget>
48	</customwidgets>
49	<resources/>	31	<resources/>
50	<connections/>	32	<connections/>
51	</ui>	33	</ui>

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