Tree: clang-format without the include sorting

author: Marcus Müller <mmueller@gnuradio.org> 2019-08-07 21:45:12 +0200
committer: Marcus Müller <marcus@hostalia.de> 2019-08-09 23:04:28 +0200
commit: f7bbf2c1d8d780294f3e016aff239ca35eb6516e (patch)
tree: e09ab6112e02b2215b2d59ac24d3d6ea2edac745 /gr-qtgui/lib/VectorDisplayPlot.cc
parent: 78431dc6941e3acc67c858277dfe4a0ed583643c (diff)
1 files changed, 330 insertions, 406 deletions
diff --git a/gr-qtgui/lib/VectorDisplayPlot.cc b/gr-qtgui/lib/VectorDisplayPlot.cc
index 009233b3e6..dbc1209b50 100644
--- a/gr-qtgui/lib/VectorDisplayPlot.cc
+++ b/gr-qtgui/lib/VectorDisplayPlot.cc
@@ -41,53 +41,41 @@
 /***********************************************************************
  * Widget to provide mouse pointer coordinate text
  **********************************************************************/
-class VectorDisplayZoomer: public QwtPlotZoomer
+class VectorDisplayZoomer : public QwtPlotZoomer
 {
 public:
 #if QWT_VERSION < 0x060100
-  VectorDisplayZoomer(QwtPlotCanvas* canvas)
-#else /* QWT_VERSION < 0x060100 */
-  VectorDisplayZoomer(QWidget* canvas)
+    VectorDisplayZoomer(QwtPlotCanvas* canvas)
+#else  /* QWT_VERSION < 0x060100 */
+    VectorDisplayZoomer(QWidget* canvas)
 #endif /* QWT_VERSION < 0x060100 */
-    : QwtPlotZoomer(canvas),
-    d_x_units(" "),
-    d_y_units(" ")
-  {
-    setTrackerMode(QwtPicker::AlwaysOn);
-  }
-
-  virtual void updateTrackerText()
-  {
-    updateDisplay();
-  }
-
-  void setXUnits(const QString &units)
-  {
-    d_x_units = units;
-  }
-
-  void setYUnits(const QString &units)
-  {
-    d_y_units = units;
-  }
+        : QwtPlotZoomer(canvas), d_x_units(" "), d_y_units(" ")
+    {
+        setTrackerMode(QwtPicker::AlwaysOn);
+    }
+
+    virtual void updateTrackerText() { updateDisplay(); }
+
+    void setXUnits(const QString& units) { d_x_units = units; }
+
+    void setYUnits(const QString& units) { d_y_units = units; }
 
 protected:
-  using QwtPlotZoomer::trackerText;
-  virtual QwtText trackerText(QPoint const &p) const
-  {
-    QwtDoublePoint dp = QwtPlotZoomer::invTransform(p);
-    QwtText t(QString("%1 %2, %3 %4")
-              .arg(dp.x(), 0, 'f', 2)
-              .arg(d_x_units)
-              .arg(dp.y(), 0, 'f', 2)
-              .arg(d_y_units)
-    );
-    return t;
-  }
+    using QwtPlotZoomer::trackerText;
+    virtual QwtText trackerText(QPoint const& p) const
+    {
+        QwtDoublePoint dp = QwtPlotZoomer::invTransform(p);
+        QwtText t(QString("%1 %2, %3 %4")
+                      .arg(dp.x(), 0, 'f', 2)
+                      .arg(d_x_units)
+                      .arg(dp.y(), 0, 'f', 2)
+                      .arg(d_y_units));
+        return t;
+    }
 
 private:
-  QString d_x_units; //!< Units on x-Axis (e.g. Hz)
-  QString d_y_units; //!< Units on y-Axis (e.g. V)
+    QString d_x_units; //!< Units on x-Axis (e.g. Hz)
+    QString d_y_units; //!< Units on y-Axis (e.g. V)
 };
 
 
@@ -95,535 +83,471 @@ private:
  * Main frequency display plotter widget
  **********************************************************************/
 VectorDisplayPlot::VectorDisplayPlot(int nplots, QWidget* parent)
-  : DisplayPlot(nplots, parent),
-    d_x_axis_label("x"),
-    d_y_axis_label("y")
+    : DisplayPlot(nplots, parent), d_x_axis_label("x"), d_y_axis_label("y")
 {
-  d_numPoints = 1024;
-  d_x_axis_start = 0;
-  d_x_axis_step = 1.0;
-  d_ymin = -10;
-  d_ymax = 10;
+    d_numPoints = 1024;
+    d_x_axis_start = 0;
+    d_x_axis_step = 1.0;
+    d_ymin = -10;
+    d_ymax = 10;
 
-  d_min_vec_data = new double[d_numPoints];
-  d_max_vec_data = new double[d_numPoints];
-  d_xdata = new double[d_numPoints];
+    d_min_vec_data = new double[d_numPoints];
+    d_max_vec_data = new double[d_numPoints];
+    d_xdata = new double[d_numPoints];
 
-  setAxisTitle(QwtPlot::xBottom, d_x_axis_label);
-  setAxisScale(QwtPlot::xBottom, d_x_axis_start, d_numPoints-1);
+    setAxisTitle(QwtPlot::xBottom, d_x_axis_label);
+    setAxisScale(QwtPlot::xBottom, d_x_axis_start, d_numPoints - 1);
 
-  setAxisScaleEngine(QwtPlot::yLeft, new QwtLinearScaleEngine);
-  setAxisScale(QwtPlot::yLeft, d_ymin, d_ymax);
-  setAxisTitle(QwtPlot::yLeft, d_y_axis_label);
+    setAxisScaleEngine(QwtPlot::yLeft, new QwtLinearScaleEngine);
+    setAxisScale(QwtPlot::yLeft, d_ymin, d_ymax);
+    setAxisTitle(QwtPlot::yLeft, d_y_axis_label);
 
-  QList<QColor> default_colors;
-  default_colors << QColor(Qt::blue) << QColor(Qt::red) << QColor(Qt::green)
-	 << QColor(Qt::black) << QColor(Qt::cyan) << QColor(Qt::magenta)
-	 << QColor(Qt::yellow) << QColor(Qt::gray) << QColor(Qt::darkRed)
-	 << QColor(Qt::darkGreen) << QColor(Qt::darkBlue) << QColor(Qt::darkGray);
+    QList<QColor> default_colors;
+    default_colors << QColor(Qt::blue) << QColor(Qt::red) << QColor(Qt::green)
+                   << QColor(Qt::black) << QColor(Qt::cyan) << QColor(Qt::magenta)
+                   << QColor(Qt::yellow) << QColor(Qt::gray) << QColor(Qt::darkRed)
+                   << QColor(Qt::darkGreen) << QColor(Qt::darkBlue)
+                   << QColor(Qt::darkGray);
 
-  // Create a curve for each input
-  // Automatically deleted when parent is deleted
-  for(unsigned int i = 0; i < d_nplots; ++i) {
-    d_ydata.push_back(new double[d_numPoints]);
-    memset(d_ydata[i], 0x0, d_numPoints*sizeof(double));
+    // Create a curve for each input
+    // Automatically deleted when parent is deleted
+    for (unsigned int i = 0; i < d_nplots; ++i) {
+        d_ydata.push_back(new double[d_numPoints]);
+        memset(d_ydata[i], 0x0, d_numPoints * sizeof(double));
 
-    d_plot_curve.push_back(new QwtPlotCurve(QString("Data %1").arg(i)));
-    d_plot_curve[i]->attach(this);
+        d_plot_curve.push_back(new QwtPlotCurve(QString("Data %1").arg(i)));
+        d_plot_curve[i]->attach(this);
 
-    QwtSymbol *symbol = new QwtSymbol(QwtSymbol::NoSymbol, QBrush(default_colors[i]),
-				      QPen(default_colors[i]), QSize(7,7));
+        QwtSymbol* symbol = new QwtSymbol(QwtSymbol::NoSymbol,
+                                          QBrush(default_colors[i]),
+                                          QPen(default_colors[i]),
+                                          QSize(7, 7));
 
 #if QWT_VERSION < 0x060000
-    d_plot_curve[i]->setRawData(d_xdata, d_ydata[i], d_numPoints);
-    d_plot_curve[i]->setSymbol(*symbol);
+        d_plot_curve[i]->setRawData(d_xdata, d_ydata[i], d_numPoints);
+        d_plot_curve[i]->setSymbol(*symbol);
 #else
-    d_plot_curve[i]->setRawSamples(d_xdata, d_ydata[i], d_numPoints);
-    d_plot_curve[i]->setSymbol(symbol);
+        d_plot_curve[i]->setRawSamples(d_xdata, d_ydata[i], d_numPoints);
+        d_plot_curve[i]->setSymbol(symbol);
 #endif
-    setLineColor(i, default_colors[i]);
-  }
-
-  // Create min/max plotter curves
-  d_min_vec_plot_curve = new QwtPlotCurve("Min Hold");
-  d_min_vec_plot_curve->attach(this);
-  const QColor default_min_fft_color = Qt::magenta;
-  setMinVecColor(default_min_fft_color);
+        setLineColor(i, default_colors[i]);
+    }
+
+    // Create min/max plotter curves
+    d_min_vec_plot_curve = new QwtPlotCurve("Min Hold");
+    d_min_vec_plot_curve->attach(this);
+    const QColor default_min_fft_color = Qt::magenta;
+    setMinVecColor(default_min_fft_color);
 #if QWT_VERSION < 0x060000
-  d_min_vec_plot_curve->setRawData(d_xdata, d_min_vec_data, d_numPoints);
+    d_min_vec_plot_curve->setRawData(d_xdata, d_min_vec_data, d_numPoints);
 #else
-  d_min_vec_plot_curve->setRawSamples(d_xdata, d_min_vec_data, d_numPoints);
+    d_min_vec_plot_curve->setRawSamples(d_xdata, d_min_vec_data, d_numPoints);
 #endif
-  d_min_vec_plot_curve->setVisible(false);
-  d_min_vec_plot_curve->setZ(0);
+    d_min_vec_plot_curve->setVisible(false);
+    d_min_vec_plot_curve->setZ(0);
 
-  d_max_vec_plot_curve = new QwtPlotCurve("Max Hold");
-  d_max_vec_plot_curve->attach(this);
-  QColor default_max_fft_color = Qt::darkYellow;
-  setMaxVecColor(default_max_fft_color);
+    d_max_vec_plot_curve = new QwtPlotCurve("Max Hold");
+    d_max_vec_plot_curve->attach(this);
+    QColor default_max_fft_color = Qt::darkYellow;
+    setMaxVecColor(default_max_fft_color);
 #if QWT_VERSION < 0x060000
-  d_max_vec_plot_curve->setRawData(d_xdata, d_max_vec_data, d_numPoints);
+    d_max_vec_plot_curve->setRawData(d_xdata, d_max_vec_data, d_numPoints);
 #else
-  d_max_vec_plot_curve->setRawSamples(d_xdata, d_max_vec_data, d_numPoints);
+    d_max_vec_plot_curve->setRawSamples(d_xdata, d_max_vec_data, d_numPoints);
 #endif
-  d_max_vec_plot_curve->setVisible(false);
-  d_max_vec_plot_curve->setZ(0);
+    d_max_vec_plot_curve->setVisible(false);
+    d_max_vec_plot_curve->setZ(0);
 
-  d_lower_intensity_marker= new QwtPlotMarker();
-  d_lower_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
-  QColor default_marker_lower_intensity_color = Qt::cyan;
-  setMarkerLowerIntensityColor(default_marker_lower_intensity_color);
-  d_lower_intensity_marker->attach(this);
+    d_lower_intensity_marker = new QwtPlotMarker();
+    d_lower_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
+    QColor default_marker_lower_intensity_color = Qt::cyan;
+    setMarkerLowerIntensityColor(default_marker_lower_intensity_color);
+    d_lower_intensity_marker->attach(this);
 
-  d_upper_intensity_marker = new QwtPlotMarker();
-  d_upper_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
-  QColor default_marker_upper_intensity_color = Qt::green;
-  setMarkerUpperIntensityColor(default_marker_upper_intensity_color);
-  d_upper_intensity_marker->attach(this);
+    d_upper_intensity_marker = new QwtPlotMarker();
+    d_upper_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
+    QColor default_marker_upper_intensity_color = Qt::green;
+    setMarkerUpperIntensityColor(default_marker_upper_intensity_color);
+    d_upper_intensity_marker->attach(this);
 
-  memset(d_xdata, 0x0, d_numPoints*sizeof(double));
+    memset(d_xdata, 0x0, d_numPoints * sizeof(double));
 
-  for(int64_t number = 0; number < d_numPoints; number++){
-    d_min_vec_data[number] = 1e6;
-    d_max_vec_data[number] = -1e6;
-  }
+    for (int64_t number = 0; number < d_numPoints; number++) {
+        d_min_vec_data[number] = 1e6;
+        d_max_vec_data[number] = -1e6;
+    }
 
-  d_marker_ref_level = new QwtPlotMarker();
-  d_marker_ref_level->setLineStyle(QwtPlotMarker::HLine);
-  QColor d_default_marker_ref_level_color = Qt::darkRed;
-  setMarkerRefLevelAmplitudeColor(d_default_marker_ref_level_color);
-  d_marker_ref_level->attach(this);
+    d_marker_ref_level = new QwtPlotMarker();
+    d_marker_ref_level->setLineStyle(QwtPlotMarker::HLine);
+    QColor d_default_marker_ref_level_color = Qt::darkRed;
+    setMarkerRefLevelAmplitudeColor(d_default_marker_ref_level_color);
+    d_marker_ref_level->attach(this);
 
-  d_ref_level = -HUGE_VAL;
+    d_ref_level = -HUGE_VAL;
 
-  d_zoomer = new VectorDisplayZoomer(canvas());
+    d_zoomer = new VectorDisplayZoomer(canvas());
 
 #if QWT_VERSION < 0x060000
-  d_zoomer->setSelectionFlags(QwtPicker::RectSelection | QwtPicker::DragSelection);
+    d_zoomer->setSelectionFlags(QwtPicker::RectSelection | QwtPicker::DragSelection);
 #endif
 
-  d_zoomer->setMousePattern(QwtEventPattern::MouseSelect2,
-                            Qt::RightButton, Qt::ControlModifier);
-  d_zoomer->setMousePattern(QwtEventPattern::MouseSelect3,
-                            Qt::RightButton);
+    d_zoomer->setMousePattern(
+        QwtEventPattern::MouseSelect2, Qt::RightButton, Qt::ControlModifier);
+    d_zoomer->setMousePattern(QwtEventPattern::MouseSelect3, Qt::RightButton);
 
 
-  const QColor default_zoomer_color(Qt::darkRed);
-  setZoomerColor(default_zoomer_color);
+    const QColor default_zoomer_color(Qt::darkRed);
+    setZoomerColor(default_zoomer_color);
 
-  // Do this after the zoomer has been built
-  _resetXAxisPoints();
+    // Do this after the zoomer has been built
+    _resetXAxisPoints();
 
-  // Turn off min/max hold plots in legend
+    // Turn off min/max hold plots in legend
 #if QWT_VERSION < 0x060100
-  QWidget *w;
-  QwtLegend* legendDisplay = legend();
-  w = legendDisplay->find(d_min_vec_plot_curve);
-  ((QwtLegendItem*)w)->setChecked(true);
-  w = legendDisplay->find(d_max_vec_plot_curve);
-  ((QwtLegendItem*)w)->setChecked(true);
-#else /* QWT_VERSION < 0x060100 */
-  QWidget *w;
-  w = ((QwtLegend*)legend())->legendWidget(itemToInfo(d_min_vec_plot_curve));
-  ((QwtLegendLabel*)w)->setChecked(true);
-  w = ((QwtLegend*)legend())->legendWidget(itemToInfo(d_max_vec_plot_curve));
-  ((QwtLegendLabel*)w)->setChecked(true);
+    QWidget* w;
+    QwtLegend* legendDisplay = legend();
+    w = legendDisplay->find(d_min_vec_plot_curve);
+    ((QwtLegendItem*)w)->setChecked(true);
+    w = legendDisplay->find(d_max_vec_plot_curve);
+    ((QwtLegendItem*)w)->setChecked(true);
+#else  /* QWT_VERSION < 0x060100 */
+    QWidget* w;
+    w = ((QwtLegend*)legend())->legendWidget(itemToInfo(d_min_vec_plot_curve));
+    ((QwtLegendLabel*)w)->setChecked(true);
+    w = ((QwtLegend*)legend())->legendWidget(itemToInfo(d_max_vec_plot_curve));
+    ((QwtLegendLabel*)w)->setChecked(true);
 #endif /* QWT_VERSION < 0x060100 */
 
-  replot();
+    replot();
 }
 
 VectorDisplayPlot::~VectorDisplayPlot()
 {
-  for(unsigned int i = 0; i < d_nplots; ++i)
-    delete [] d_ydata[i];
-  delete[] d_max_vec_data;
-  delete[] d_min_vec_data;
-  delete[] d_xdata;
+    for (unsigned int i = 0; i < d_nplots; ++i)
+        delete[] d_ydata[i];
+    delete[] d_max_vec_data;
+    delete[] d_min_vec_data;
+    delete[] d_xdata;
 }
 
-void
-VectorDisplayPlot::setYaxis(double min, double max)
+void VectorDisplayPlot::setYaxis(double min, double max)
 {
-  // Get the new max/min values for the plot
-  d_ymin = min;
-  d_ymax = max;
+    // Get the new max/min values for the plot
+    d_ymin = min;
+    d_ymax = max;
 
-  // Set the axis max/min to the new values
-  setAxisScale(QwtPlot::yLeft, d_ymin, d_ymax);
+    // Set the axis max/min to the new values
+    setAxisScale(QwtPlot::yLeft, d_ymin, d_ymax);
 
-  // Reset the base zoom level to the new axis scale set here.
-  // But don't do it if we set the axis due to auto scaling.
-  if(!d_autoscale_state)
-    d_zoomer->setZoomBase();
+    // Reset the base zoom level to the new axis scale set here.
+    // But don't do it if we set the axis due to auto scaling.
+    if (!d_autoscale_state)
+        d_zoomer->setZoomBase();
 }
 
-double
-VectorDisplayPlot::getYMin() const
-{
-  return d_ymin;
-}
+double VectorDisplayPlot::getYMin() const { return d_ymin; }
 
-double
-VectorDisplayPlot::getYMax() const
-{
-  return d_ymax;
-}
+double VectorDisplayPlot::getYMax() const { return d_ymax; }
 
-void VectorDisplayPlot::setXAxisLabel(const QString &label)
+void VectorDisplayPlot::setXAxisLabel(const QString& label)
 {
-  d_x_axis_label = label;
-  setAxisTitle(QwtPlot::xBottom, label);
+    d_x_axis_label = label;
+    setAxisTitle(QwtPlot::xBottom, label);
 }
 
-void VectorDisplayPlot::setYAxisLabel(const QString &label)
+void VectorDisplayPlot::setYAxisLabel(const QString& label)
 {
-  d_y_axis_label = label;
-  setAxisTitle(QwtPlot::yLeft, label);
+    d_y_axis_label = label;
+    setAxisTitle(QwtPlot::yLeft, label);
 }
 
-void VectorDisplayPlot::setXAxisUnit(const QString &unit)
+void VectorDisplayPlot::setXAxisUnit(const QString& unit)
 {
-  ((VectorDisplayZoomer*)d_zoomer)->setXUnits(unit);
+    ((VectorDisplayZoomer*)d_zoomer)->setXUnits(unit);
 }
 
-void VectorDisplayPlot::setYAxisUnit(const QString &unit)
+void VectorDisplayPlot::setYAxisUnit(const QString& unit)
 {
-  ((VectorDisplayZoomer*)d_zoomer)->setYUnits(unit);
+    ((VectorDisplayZoomer*)d_zoomer)->setYUnits(unit);
 }
 
-void
-VectorDisplayPlot::setXAxisValues(
-    const double start,
-    const double step
-) {
-  bool reset = false;
-  if((start != d_x_axis_start) || (step != d_x_axis_step))
-    reset = true;
+void VectorDisplayPlot::setXAxisValues(const double start, const double step)
+{
+    bool reset = false;
+    if ((start != d_x_axis_start) || (step != d_x_axis_step))
+        reset = true;
 
-  d_x_axis_start = start;
-  d_x_axis_step = step;
+    d_x_axis_start = start;
+    d_x_axis_step = step;
 
-  if((axisScaleDraw(QwtPlot::xBottom) != NULL) && (d_zoomer != NULL)) {
-    setAxisTitle(QwtPlot::xBottom, d_x_axis_label);
-    if(reset) {
-      _resetXAxisPoints();
-      clearMaxData();
-      clearMinData();
+    if ((axisScaleDraw(QwtPlot::xBottom) != NULL) && (d_zoomer != NULL)) {
+        setAxisTitle(QwtPlot::xBottom, d_x_axis_label);
+        if (reset) {
+            _resetXAxisPoints();
+            clearMaxData();
+            clearMinData();
+        }
     }
-  }
 }
 
-void
-VectorDisplayPlot::replot()
+void VectorDisplayPlot::replot()
 {
-  d_marker_ref_level->setYValue(d_ref_level);
-  QwtPlot::replot();
+    d_marker_ref_level->setYValue(d_ref_level);
+    QwtPlot::replot();
 }
 
-void
-VectorDisplayPlot::plotNewData(
-      const std::vector<double*> dataPoints,
-      const int64_t numDataPoints,
-      const double refLevel,
-      const double timeInterval
-) {
-  if(!d_stop) {
-    if(numDataPoints > 0) {
-      if(numDataPoints != d_numPoints) {
-        d_numPoints = numDataPoints;
+void VectorDisplayPlot::plotNewData(const std::vector<double*> dataPoints,
+                                    const int64_t numDataPoints,
+                                    const double refLevel,
+                                    const double timeInterval)
+{
+    if (!d_stop) {
+        if (numDataPoints > 0) {
+            if (numDataPoints != d_numPoints) {
+                d_numPoints = numDataPoints;
 
-        delete[] d_min_vec_data;
-        delete[] d_max_vec_data;
-        delete[] d_xdata;
-        d_xdata = new double[d_numPoints];
-        d_min_vec_data = new double[d_numPoints];
-        d_max_vec_data = new double[d_numPoints];
+                delete[] d_min_vec_data;
+                delete[] d_max_vec_data;
+                delete[] d_xdata;
+                d_xdata = new double[d_numPoints];
+                d_min_vec_data = new double[d_numPoints];
+                d_max_vec_data = new double[d_numPoints];
 
-        for(unsigned int i = 0; i < d_nplots; ++i) {
-          delete[] d_ydata[i];
-          d_ydata[i] = new double[d_numPoints];
+                for (unsigned int i = 0; i < d_nplots; ++i) {
+                    delete[] d_ydata[i];
+                    d_ydata[i] = new double[d_numPoints];
 
 #if QWT_VERSION < 0x060000
-          d_plot_curve[i]->setRawData(d_xdata, d_ydata[i], d_numPoints);
+                    d_plot_curve[i]->setRawData(d_xdata, d_ydata[i], d_numPoints);
 #else
-          d_plot_curve[i]->setRawSamples(d_xdata, d_ydata[i], d_numPoints);
+                    d_plot_curve[i]->setRawSamples(d_xdata, d_ydata[i], d_numPoints);
 #endif
-        }
+                }
 #if QWT_VERSION < 0x060000
-        d_min_vec_plot_curve->setRawData(d_xdata, d_min_vec_data, d_numPoints);
-        d_max_vec_plot_curve->setRawData(d_xdata, d_max_vec_data, d_numPoints);
+                d_min_vec_plot_curve->setRawData(d_xdata, d_min_vec_data, d_numPoints);
+                d_max_vec_plot_curve->setRawData(d_xdata, d_max_vec_data, d_numPoints);
 #else
-        d_min_vec_plot_curve->setRawSamples(d_xdata, d_min_vec_data, d_numPoints);
-        d_max_vec_plot_curve->setRawSamples(d_xdata, d_max_vec_data, d_numPoints);
+                d_min_vec_plot_curve->setRawSamples(d_xdata, d_min_vec_data, d_numPoints);
+                d_max_vec_plot_curve->setRawSamples(d_xdata, d_max_vec_data, d_numPoints);
 #endif
-        _resetXAxisPoints();
-        clearMaxData();
-        clearMinData();
-      }
-
-      double bottom=1e20, top=-1e20;
-      for(unsigned int n = 0; n < d_nplots; ++n) {
-
-        memcpy(d_ydata[n], dataPoints[n], numDataPoints*sizeof(double));
-
-        for(int64_t point = 0; point < numDataPoints; point++) {
-          if(dataPoints[n][point] < d_min_vec_data[point]) {
-            d_min_vec_data[point] = dataPoints[n][point];
-          }
-          if(dataPoints[n][point] > d_max_vec_data[point]) {
-            d_max_vec_data[point] = dataPoints[n][point];
-          }
-
-          // Find overall top and bottom values in plot.
-          // Used for autoscaling y-axis.
-          if(dataPoints[n][point] < bottom) {
-            bottom = dataPoints[n][point];
-          }
-          if(dataPoints[n][point] > top) {
-            top = dataPoints[n][point];
-          }
+                _resetXAxisPoints();
+                clearMaxData();
+                clearMinData();
+            }
+
+            double bottom = 1e20, top = -1e20;
+            for (unsigned int n = 0; n < d_nplots; ++n) {
+
+                memcpy(d_ydata[n], dataPoints[n], numDataPoints * sizeof(double));
+
+                for (int64_t point = 0; point < numDataPoints; point++) {
+                    if (dataPoints[n][point] < d_min_vec_data[point]) {
+                        d_min_vec_data[point] = dataPoints[n][point];
+                    }
+                    if (dataPoints[n][point] > d_max_vec_data[point]) {
+                        d_max_vec_data[point] = dataPoints[n][point];
+                    }
+
+                    // Find overall top and bottom values in plot.
+                    // Used for autoscaling y-axis.
+                    if (dataPoints[n][point] < bottom) {
+                        bottom = dataPoints[n][point];
+                    }
+                    if (dataPoints[n][point] > top) {
+                        top = dataPoints[n][point];
+                    }
+                }
+            }
+
+            if (d_autoscale_state)
+                _autoScale(bottom, top);
+
+            d_ref_level = refLevel;
+
+            replot();
         }
-      }
-
-      if(d_autoscale_state)
-        _autoScale(bottom, top);
-
-      d_ref_level = refLevel;
-
-      replot();
     }
-  }
 }
 
-void
-VectorDisplayPlot::clearMaxData()
+void VectorDisplayPlot::clearMaxData()
 {
-  for(int64_t number = 0; number < d_numPoints; number++) {
-    d_max_vec_data[number] = d_ymin;
-  }
+    for (int64_t number = 0; number < d_numPoints; number++) {
+        d_max_vec_data[number] = d_ymin;
+    }
 }
 
-void
-VectorDisplayPlot::clearMinData()
+void VectorDisplayPlot::clearMinData()
 {
-  for(int64_t number = 0; number < d_numPoints; number++) {
-    d_min_vec_data[number] = d_ymax;
-  }
+    for (int64_t number = 0; number < d_numPoints; number++) {
+        d_min_vec_data[number] = d_ymax;
+    }
 }
 
-void
-VectorDisplayPlot::_autoScale(double bottom, double top)
+void VectorDisplayPlot::_autoScale(double bottom, double top)
 {
-  // Auto scale the y-axis with a margin of 10 dB on either side.
-  d_ymin = bottom-10;
-  d_ymax = top+10;
-  setYaxis(d_ymin, d_ymax);
+    // Auto scale the y-axis with a margin of 10 dB on either side.
+    d_ymin = bottom - 10;
+    d_ymax = top + 10;
+    setYaxis(d_ymin, d_ymax);
 }
 
-void
-VectorDisplayPlot::setAutoScale(bool state)
-{
-  d_autoscale_state = state;
-}
+void VectorDisplayPlot::setAutoScale(bool state) { d_autoscale_state = state; }
 
-void
-VectorDisplayPlot::setMaxVecVisible(const bool visibleFlag)
+void VectorDisplayPlot::setMaxVecVisible(const bool visibleFlag)
 {
-  d_max_vec_visible = visibleFlag;
-  d_max_vec_plot_curve->setVisible(visibleFlag);
+    d_max_vec_visible = visibleFlag;
+    d_max_vec_plot_curve->setVisible(visibleFlag);
 }
 
-const bool
-VectorDisplayPlot::getMaxVecVisible() const
-{
-  return d_max_vec_visible;
-}
+const bool VectorDisplayPlot::getMaxVecVisible() const { return d_max_vec_visible; }
 
-void
-VectorDisplayPlot::setMinVecVisible(const bool visibleFlag)
+void VectorDisplayPlot::setMinVecVisible(const bool visibleFlag)
 {
-  d_min_vec_visible = visibleFlag;
-  d_min_vec_plot_curve->setVisible(visibleFlag);
+    d_min_vec_visible = visibleFlag;
+    d_min_vec_plot_curve->setVisible(visibleFlag);
 }
 
-const bool
-VectorDisplayPlot::getMinVecVisible() const
-{
-  return d_min_vec_visible;
-}
+const bool VectorDisplayPlot::getMinVecVisible() const { return d_min_vec_visible; }
 
-void
-VectorDisplayPlot::_resetXAxisPoints()
+void VectorDisplayPlot::_resetXAxisPoints()
 {
-  double xValue = d_x_axis_start;
-  for(int64_t loc = 0; loc < d_numPoints; loc++) {
-    d_xdata[loc] = xValue;
-    xValue += d_x_axis_step;
-  }
+    double xValue = d_x_axis_start;
+    for (int64_t loc = 0; loc < d_numPoints; loc++) {
+        d_xdata[loc] = xValue;
+        xValue += d_x_axis_step;
+    }
 
-  setAxisScale(QwtPlot::xBottom, d_xdata[0], d_xdata[d_numPoints-1]);
+    setAxisScale(QwtPlot::xBottom, d_xdata[0], d_xdata[d_numPoints - 1]);
 
-  // Set up zoomer base for maximum unzoom x-axis
-  // and reset to maximum unzoom level
-  QwtDoubleRect zbase = d_zoomer->zoomBase();
-  d_zoomer->zoom(zbase);
-  d_zoomer->setZoomBase(zbase);
-  d_zoomer->setZoomBase(true);
-  d_zoomer->zoom(0);
+    // Set up zoomer base for maximum unzoom x-axis
+    // and reset to maximum unzoom level
+    QwtDoubleRect zbase = d_zoomer->zoomBase();
+    d_zoomer->zoom(zbase);
+    d_zoomer->setZoomBase(zbase);
+    d_zoomer->setZoomBase(true);
+    d_zoomer->zoom(0);
 }
 
-void
-VectorDisplayPlot::setLowerIntensityLevel(const double lowerIntensityLevel)
+void VectorDisplayPlot::setLowerIntensityLevel(const double lowerIntensityLevel)
 {
-  d_lower_intensity_marker->setYValue(lowerIntensityLevel);
+    d_lower_intensity_marker->setYValue(lowerIntensityLevel);
 }
 
-void
-VectorDisplayPlot::setUpperIntensityLevel(const double upperIntensityLevel)
+void VectorDisplayPlot::setUpperIntensityLevel(const double upperIntensityLevel)
 {
-  d_upper_intensity_marker->setYValue(upperIntensityLevel);
+    d_upper_intensity_marker->setYValue(upperIntensityLevel);
 }
 
-void
-VectorDisplayPlot::setTraceColour(QColor c)
-{
-  d_plot_curve[0]->setPen(QPen(c));
-}
+void VectorDisplayPlot::setTraceColour(QColor c) { d_plot_curve[0]->setPen(QPen(c)); }
 
-void
-VectorDisplayPlot::setBGColour(QColor c)
+void VectorDisplayPlot::setBGColour(QColor c)
 {
-  QPalette palette;
-  palette.setColor(canvas()->backgroundRole(), c);
-  canvas()->setPalette(palette);
+    QPalette palette;
+    palette.setColor(canvas()->backgroundRole(), c);
+    canvas()->setPalette(palette);
 }
 
-void
-VectorDisplayPlot::onPickerPointSelected(const QwtDoublePoint & p)
+void VectorDisplayPlot::onPickerPointSelected(const QwtDoublePoint& p)
 {
-  QPointF point = p;
-  point.setX(point.x());
-  emit plotPointSelected(point);
+    QPointF point = p;
+    point.setX(point.x());
+    emit plotPointSelected(point);
 }
 
-void
-VectorDisplayPlot::onPickerPointSelected6(const QPointF & p)
+void VectorDisplayPlot::onPickerPointSelected6(const QPointF& p)
 {
-  QPointF point = p;
-  point.setX(point.x());
-  emit plotPointSelected(point);
+    QPointF point = p;
+    point.setX(point.x());
+    emit plotPointSelected(point);
 }
 
-void
-VectorDisplayPlot::setMinVecColor (QColor c)
+void VectorDisplayPlot::setMinVecColor(QColor c)
 {
-  d_min_vec_color = c;
-  d_min_vec_plot_curve->setPen(QPen(c));
+    d_min_vec_color = c;
+    d_min_vec_plot_curve->setPen(QPen(c));
 }
 
-const QColor
-VectorDisplayPlot::getMinVecColor() const
-{
-  return d_min_vec_color;
-}
+const QColor VectorDisplayPlot::getMinVecColor() const { return d_min_vec_color; }
 
-void
-VectorDisplayPlot::setMaxVecColor (QColor c)
+void VectorDisplayPlot::setMaxVecColor(QColor c)
 {
-  d_max_vec_color = c;
-  d_max_vec_plot_curve->setPen(QPen(c));
+    d_max_vec_color = c;
+    d_max_vec_plot_curve->setPen(QPen(c));
 }
 
-const QColor
-VectorDisplayPlot::getMaxVecColor() const
-{
-  return d_max_vec_color;
-}
+const QColor VectorDisplayPlot::getMaxVecColor() const { return d_max_vec_color; }
 
-void
-VectorDisplayPlot::setMarkerLowerIntensityColor (QColor c)
+void VectorDisplayPlot::setMarkerLowerIntensityColor(QColor c)
 {
-  d_marker_lower_intensity_color = c;
-  d_lower_intensity_marker->setLinePen(QPen(c));
+    d_marker_lower_intensity_color = c;
+    d_lower_intensity_marker->setLinePen(QPen(c));
 }
-const QColor
-VectorDisplayPlot::getMarkerLowerIntensityColor () const
+const QColor VectorDisplayPlot::getMarkerLowerIntensityColor() const
 {
-  return d_marker_lower_intensity_color;
+    return d_marker_lower_intensity_color;
 }
 
-void
-VectorDisplayPlot::setMarkerLowerIntensityVisible (bool visible)
+void VectorDisplayPlot::setMarkerLowerIntensityVisible(bool visible)
 {
-  d_marker_lower_intensity_visible = visible;
-  if(visible)
-    d_lower_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
-  else
-    d_lower_intensity_marker->setLineStyle(QwtPlotMarker::NoLine);
+    d_marker_lower_intensity_visible = visible;
+    if (visible)
+        d_lower_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
+    else
+        d_lower_intensity_marker->setLineStyle(QwtPlotMarker::NoLine);
 }
-const bool
-VectorDisplayPlot::getMarkerLowerIntensityVisible() const
+const bool VectorDisplayPlot::getMarkerLowerIntensityVisible() const
 {
-  return d_marker_lower_intensity_visible;
+    return d_marker_lower_intensity_visible;
 }
 
-void
-VectorDisplayPlot::setMarkerUpperIntensityColor(QColor c)
+void VectorDisplayPlot::setMarkerUpperIntensityColor(QColor c)
 {
-  d_marker_upper_intensity_color = c;
-  d_upper_intensity_marker->setLinePen(QPen(c, 0, Qt::DotLine));
+    d_marker_upper_intensity_color = c;
+    d_upper_intensity_marker->setLinePen(QPen(c, 0, Qt::DotLine));
 }
 
-const QColor
-VectorDisplayPlot::getMarkerUpperIntensityColor() const
+const QColor VectorDisplayPlot::getMarkerUpperIntensityColor() const
 {
-  return d_marker_upper_intensity_color;
+    return d_marker_upper_intensity_color;
 }
 
-void
-VectorDisplayPlot::setMarkerUpperIntensityVisible(bool visible)
+void VectorDisplayPlot::setMarkerUpperIntensityVisible(bool visible)
 {
-  d_marker_upper_intensity_visible = visible;
-  if(visible)
-    d_upper_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
-  else
-    d_upper_intensity_marker->setLineStyle(QwtPlotMarker::NoLine);
+    d_marker_upper_intensity_visible = visible;
+    if (visible)
+        d_upper_intensity_marker->setLineStyle(QwtPlotMarker::HLine);
+    else
+        d_upper_intensity_marker->setLineStyle(QwtPlotMarker::NoLine);
 }
 
-const bool
-VectorDisplayPlot::getMarkerUpperIntensityVisible() const
+const bool VectorDisplayPlot::getMarkerUpperIntensityVisible() const
 {
-  return d_marker_upper_intensity_visible;
+    return d_marker_upper_intensity_visible;
 }
 
-void
-VectorDisplayPlot::setMarkerRefLevelAmplitudeColor(QColor c)
+void VectorDisplayPlot::setMarkerRefLevelAmplitudeColor(QColor c)
 {
-  d_marker_ref_level_color = c;
-  d_marker_ref_level->setLinePen(QPen(c, 0, Qt::DotLine));
+    d_marker_ref_level_color = c;
+    d_marker_ref_level->setLinePen(QPen(c, 0, Qt::DotLine));
 }
 
-const QColor
-VectorDisplayPlot::getMarkerRefLevelAmplitudeColor() const
+const QColor VectorDisplayPlot::getMarkerRefLevelAmplitudeColor() const
 {
-  return d_marker_ref_level_color;
+    return d_marker_ref_level_color;
 }
 
-void
-VectorDisplayPlot::setMarkerRefLevelAmplitudeVisible(bool visible)
+void VectorDisplayPlot::setMarkerRefLevelAmplitudeVisible(bool visible)
 {
-  d_marker_ref_level_visible = visible;
-  if(visible)
-    d_marker_ref_level->setLineStyle(QwtPlotMarker::HLine);
-  else
-    d_marker_ref_level->setLineStyle(QwtPlotMarker::NoLine);
+    d_marker_ref_level_visible = visible;
+    if (visible)
+        d_marker_ref_level->setLineStyle(QwtPlotMarker::HLine);
+    else
+        d_marker_ref_level->setLineStyle(QwtPlotMarker::NoLine);
 }
 
-const bool
-VectorDisplayPlot::getMarkerRefLevelAmplitudeVisible() const
+const bool VectorDisplayPlot::getMarkerRefLevelAmplitudeVisible() const
 {
-  return d_marker_ref_level_visible;
+    return d_marker_ref_level_visible;
 }
 
 #endif /* VECTOR_DISPLAY_PLOT */
author	Marcus Müller <mmueller@gnuradio.org>	2019-08-07 21:45:12 +0200
committer	Marcus Müller <marcus@hostalia.de>	2019-08-09 23:04:28 +0200
commit	f7bbf2c1d8d780294f3e016aff239ca35eb6516e (patch)
tree	e09ab6112e02b2215b2d59ac24d3d6ea2edac745 /gr-qtgui/lib/VectorDisplayPlot.cc
parent	78431dc6941e3acc67c858277dfe4a0ed583643c (diff)