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 +147 -133

                            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;
-                 QCPItemRect *m_DrawingZoomRect = nullptr;
+                 QCPItemRect* m_DrawingZoomRect = nullptr;
                  QStack<QPair<QCPRange, QCPRange> > m_ZoomStack;
                  std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                  bool m_VariableAutoRangeOnInit = true;
-                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
+                 inline void updateMousePosition(const QPoint& position)
                  {
-                     removeDrawingRect(plot);
+                     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)
+                 {
+                     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,
-                                                                 const QCustomPlot &plot) const
+                 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos) const
                  {
                      VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
                      auto minDistanceToZone = -1;
                      for (auto zone : m_SelectionZones) {
                          auto distanceToZone = zone->selectTest(pos, false);
                          if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
-                             && distanceToZone >= 0 && distanceToZone < 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 axisY = plot.axisRect()->axis(QCPAxis::atLeft);
+                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
+                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                      return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
                  }
                      }
                  }
-                 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 yAxis = plot->axisRect()->rangeDragAxis(Qt::Vertical);
-                     xAxis->setRange(_pixDistanceToRange(origin.x(), currentPos.x(), xAxis));
-                     yAxis->setRange(_pixDistanceToRange(origin.y(), currentPos.y(), yAxis));
+                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
+                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
+                     xAxis->setRange(_pixDistanceToRange(m_lastMousePos.x(), currentPos.x(), xAxis));
+                     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);
-                 //    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,
-                 //    &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);
+                 impl->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
+                 impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
+                 impl->m_plot->setParent(this);
              }
              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);
-                 ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                 impl->m_plot->xAxis->setRange(range.m_TStart, range.m_TEnd);
+                 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();
-                 QCPAxis *axis = ui->widget->axisRect()->rangeDragAxis(orientation);
-                 if (ui->widget->xAxis->scaleType() == QCPAxis::stLinear) {
+                 auto oldRange = impl->m_plot->xAxis->range();
+                 QCPAxis *axis = impl->m_plot->axisRect()->rangeDragAxis(orientation);
+                 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,
-                                    ui->widget->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
+                     axis->setRange(impl->m_plot->axisRect()->rangeDragAxis(orientation)->range().lower * 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);
-                     _dragLastPos = event->pos();
+                     impl->updateZoomRect(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->m_DrawingZoomRect->bottomRight->setCoords(pos);
+                     impl->updateZoneRect(event->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)
              {
-                 setCursor(Qt::ArrowCursor);
+                 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 {
-                         setCursor(Qt::ClosedHandCursor);
-                         this->_dragLastPos = event->pos();
+                     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);
+                             impl->updateMousePosition(event->pos());
+                         }
                      }
                  }
                  else if (event->button()==Qt::RightButton)
                      case Qt::Key_Shift:
                          break;
                      case Qt::Key_M:
-                         ui->widget->rescaleAxes();
-                         ui->widget->replot(QCustomPlot::rpQueuedReplot);
+                         impl->m_plot->rescaleAxes();
+                         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

                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
-                <item>
-                 <widget class="QCustomPlot" name="widget" native="true">
-                  <property name="sizePolicy">
-                   <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
-                    <horstretch>0</horstretch>
-                    <verstretch>0</verstretch>
-                   </sizepolicy>
-                  </property>
-                 </widget>
-                </item>
                </layout>
               </widget>
-              <customwidgets>
-               <customwidget>
-                <class>QCustomPlot</class>
-                <extends>QWidget</extends>
-                <header>Visualization/qcustomplot.h</header>
-                <container>1</container>
-               </customwidget>
-              </customwidgets>
               <resources/>
               <connections/>
              </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