tempo-plotter Changeset - 87e2b55fa199 · protofusion repositories

Changeset - 87e2b55fa199

Parent rev.

Child rev.

[Not reviewed]

Merge default

0 13 0

Hasan Yavuz ÖZDERYA - 8 years ago 2017-08-27 13:37:16
hy@ozderya.net

Merge with scrollbar-exp

13 files changed with 271 insertions and 26 deletions:

src/framebufferseries.cpp

src/framebufferseries.h

src/mainwindow.cpp

src/plot.cpp

src/plot.h

src/plotcontrolpanel.cpp

src/plotcontrolpanel.h

src/plotcontrolpanel.ui

src/plotmanager.cpp

src/plotmanager.h

src/scrollzoomer.cpp

119

src/scrollzoomer.h

src/setting_defines.h

0 comments (0 inline, 0 general)

src/framebufferseries.cpp

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <math.h>
 #include "framebufferseries.h"
 FrameBufferSeries::FrameBufferSeries(FrameBuffer* buffer)
+{
     xAsIndex = true;
     _xmin = 0;
     _xmax = 1;
     _buffer = buffer;
     int_index_start = 0;
-    int_index_end = 0;
+    int_index_end = _buffer->size();
+}
 void FrameBufferSeries::setXAxis(bool asIndex, double xmin, double xmax)
+{
     xAsIndex = asIndex;
     _xmin = xmin;
     _xmax = xmax;
+}
 size_t FrameBufferSeries::size() const
+{
     return int_index_end - int_index_start;
+}
 QPointF FrameBufferSeries::sample(size_t i) const
+{
     i += int_index_start;
     if (xAsIndex)
+    {
         return QPointF(i, _buffer->sample(i));
+    }
     else
+    {
         return QPointF(i * (_xmax - _xmin) / _buffer->size() + _xmin, _buffer->sample(i));
+    }
+}
 QRectF FrameBufferSeries::boundingRect() const
+{
     if (xAsIndex)
+    {
         return _buffer->boundingRect();
+    }
     else
+    {
         auto rect = _buffer->boundingRect();
         rect.setLeft(_xmin);
         rect.setRight(_xmax);
         return rect;
+    }
+}
 void FrameBufferSeries::setRectOfInterest(const QRectF& rect)
+{
     if (xAsIndex)
+    {
         int_index_start = floor(rect.left())-1;
         int_index_end = ceil(rect.right())+1;
+    }
     else
+    {
         double xsize = _xmax - _xmin;
         size_t bsize = _buffer->size();
         int_index_start =  floor(bsize * (rect.left()-_xmin) / xsize)-1;
         int_index_end = ceil(bsize * (rect.right()-_xmin) / xsize)+1;
+    }
     int_index_start = std::max(int_index_start, (size_t) 0);
     int_index_end = std::min(_buffer->size(), int_index_end);
     int_index_start = std::max(int_index_start, 0);
     int_index_end = std::min((int) _buffer->size(), int_index_end);
+}

src/framebufferseries.h

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef FRAMEBUFFERSERIES_H
 #define FRAMEBUFFERSERIES_H
 #include <QPointF>
 #include <QRectF>
 #include <qwt_series_data.h>
 #include "framebuffer.h"
 /**
  * This class provides an interface for actual FrameBuffer
  * object. That way we can keep our data structures relatively
  * isolated from Qwt. Otherwise QwtPlotCurve owns FrameBuffer
  * structures.
  */
 class FrameBufferSeries : public QwtSeriesData<QPointF>
+{
 public:
     FrameBufferSeries(FrameBuffer* buffer);
     /// Behavior of X axis
     void setXAxis(bool asIndex, double xmin, double xmax);
     // QwtSeriesData implementations
     size_t size() const;
     QPointF sample(size_t i) const;
     QRectF boundingRect() const;
     void setRectOfInterest(const QRectF& rect);
 private:
     FrameBuffer* _buffer;
     bool xAsIndex;
     double _xmin;
     double _xmax;
     size_t int_index_start; ///< starting index of "rectangle of interest"
     size_t int_index_end;   ///< ending index of "rectangle of interest"
     int int_index_start; ///< starting index of "rectangle of interest"
     int int_index_end;   ///< ending index of "rectangle of interest"
 };
 #endif // FRAMEBUFFERSERIES_H

src/mainwindow.cpp

➞

Show inline comments

@@ @@ -58,267 +58,271 @@ MainWindow::MainWindow(QWidget *parent) @@
     QMainWindow(parent),
     ui(new Ui::MainWindow),
     aboutDialog(this),
     portControl(&serialPort),
     channelMan(1, 1, this),
     snapshotMan(this, &channelMan),
     commandPanel(&serialPort),
     dataFormatPanel(&serialPort, &channelMan, &recorder),
     recordPanel(&recorder, &channelMan),
     updateCheckDialog(this)
+{
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());
     ui->tabWidget->insertTab(0, &portControl, "Port");
     ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");
     ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");
     ui->tabWidget->insertTab(3, &commandPanel, "Commands");
     ui->tabWidget->insertTab(4, &recordPanel, "Record");
     ui->tabWidget->setCurrentIndex(0);
     auto tbPortControl = portControl.toolBar();
     addToolBar(tbPortControl);
     addToolBar(recordPanel.toolbar());
     ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());
     ui->menuBar->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());
     ui->menuBar->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());
     connect(&commandPanel, &CommandPanel::focusRequested, [this]()
+            {
                 this->ui->tabWidget->setCurrentWidget(&commandPanel);
                 this->ui->tabWidget->showTabs();
             });
     tbPortControl->setObjectName("tbPortControl");
     ui->plotToolBar->setObjectName("tbPlot");
     setupAboutDialog();
     // init view menu
     for (auto a : plotMan->menuActions())
+    {
         ui->menuView->addAction(a);
+    }
     ui->menuView->addSeparator();
     QMenu* tbMenu = ui->menuView->addMenu("Toolbars");
     tbMenu->addAction(ui->plotToolBar->toggleViewAction());
     tbMenu->addAction(portControl.toolBar()->toggleViewAction());
     // init UI signals
     // Help menu signals
     QObject::connect(ui->actionHelpAbout, &QAction::triggered,
               &aboutDialog, &QWidget::show);
     QObject::connect(ui->actionCheckUpdate, &QAction::triggered,
               &updateCheckDialog, &QWidget::show);
     QObject::connect(ui->actionReportBug, &QAction::triggered,
                      [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});
     // File menu signals
     QObject::connect(ui->actionExportCsv, &QAction::triggered,
                      this, &MainWindow::onExportCsv);
     QObject::connect(ui->actionSaveSettings, &QAction::triggered,
                      this, &MainWindow::onSaveSettings);
     QObject::connect(ui->actionLoadSettings, &QAction::triggered,
                      this, &MainWindow::onLoadSettings);
     ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);
     QObject::connect(ui->actionQuit, &QAction::triggered,
                      this, &MainWindow::close);
     // port control signals
     QObject::connect(&portControl, &PortControl::portToggled,
                      this, &MainWindow::onPortToggled);
     // plot control signals
     connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,
             this, &MainWindow::onNumOfSamplesChanged);
     connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,
             plotMan, &PlotManager::setNumOfSamples);
     connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,
             plotMan, &PlotManager::setYAxis);
     connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,
             plotMan, &PlotManager::setXAxis);
     connect(&plotControlPanel, &PlotControlPanel::plotWidthChanged,
             plotMan, &PlotManager::setPlotWidth);
     QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),
                      this, SLOT(clearPlot()));
     QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,
                      plotMan, &PlotManager::flashSnapshotOverlay);
     // init port signals
     QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),
                      this, SLOT(onPortError(QSerialPort::SerialPortError)));
     // init data format and reader
     QObject::connect(&channelMan, &ChannelManager::dataAdded,
                      plotMan, &PlotManager::replot);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      &channelMan, &ChannelManager::pause);
     QObject::connect(&recordPanel, &RecordPanel::recordStarted,
                      &dataFormatPanel, &DataFormatPanel::startRecording);
     QObject::connect(&recordPanel, &RecordPanel::recordStopped,
                      &dataFormatPanel, &DataFormatPanel::stopRecording);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      [this](bool enabled)
+                     {
                          if (enabled && !recordPanel.recordPaused())
+                         {
                              dataFormatPanel.pause(true);
+                         }
                          else
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,
                      [this](bool enabled)
+                     {
                          if (ui->actionPause->isChecked() && enabled)
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     connect(&serialPort, &QIODevice::aboutToClose,
             &recordPanel, &RecordPanel::onPortClose);
     // init data arrays and plot
     numOfSamples = plotControlPanel.numOfSamples();
     unsigned numOfChannels = dataFormatPanel.numOfChannels();
     channelMan.setNumOfSamples(numOfSamples);
     channelMan.setNumOfChannels(dataFormatPanel.numOfChannels());
     connect(&dataFormatPanel, &DataFormatPanel::numOfChannelsChanged,
             &channelMan, &ChannelManager::setNumOfChannels);
     connect(&channelMan, &ChannelManager::numOfChannelsChanged,
             this, &MainWindow::onNumOfChannelsChanged);
     plotControlPanel.setChannelInfoModel(channelMan.infoModel());
     // init curve list
     for (unsigned int i = 0; i < numOfChannels; i++)
+    {
         plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));
+    }
     // init scales
     plotMan->setYAxis(plotControlPanel.autoScale(),
                       plotControlPanel.yMin(), plotControlPanel.yMax());
     plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),
                       plotControlPanel.xMin(), plotControlPanel.xMax());
     plotMan->setNumOfSamples(numOfSamples);
     plotMan->setPlotWidth(plotControlPanel.plotWidth());
     // Init sps (sample per second) counter
     spsLabel.setText("0sps");
     spsLabel.setToolTip("samples per second (per channel)");
     ui->statusBar->addPermanentWidget(&spsLabel);
     QObject::connect(&dataFormatPanel,
                      &DataFormatPanel::samplesPerSecondChanged,
                      this, &MainWindow::onSpsChanged);
     // init demo
     QObject::connect(ui->actionDemoMode, &QAction::toggled,
                      this, &MainWindow::enableDemo);
     QObject::connect(ui->actionDemoMode, &QAction::toggled,
                      plotMan, &PlotManager::showDemoIndicator);
     // load default settings
     QSettings settings("serialplot", "serialplot");
     loadAllSettings(&settings);
     // ensure command panel has 1 command if none loaded
     if (!commandPanel.numOfCommands())
+    {
         commandPanel.newCommandAction()->trigger();
+    }
     // Important: This should be after newCommandAction is triggered
     // (above) we don't want user to be greeted with command panel on
     // the very first run.
     connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()
+            {
                 this->ui->tabWidget->setCurrentWidget(&commandPanel);
                 this->ui->tabWidget->showTabs();
             });
+}
 MainWindow::~MainWindow()
+{
     if (serialPort.isOpen())
+    {
         serialPort.close();
+    }
     delete plotMan;
     delete ui;
     ui = NULL; // we check if ui is deleted in messageHandler
+}
 void MainWindow::closeEvent(QCloseEvent * event)
+{
     // save snapshots
     if (!snapshotMan.isAllSaved())
+    {
         auto clickedButton = QMessageBox::warning(
             this, "Closing SerialPlot",
             "There are un-saved snapshots. If you close you will loose the data.",
             QMessageBox::Discard, QMessageBox::Cancel);
         if (clickedButton == QMessageBox::Cancel)
+        {
             event->ignore();
             return;
+        }
+    }
     // save settings
     QSettings settings("serialplot", "serialplot");
     saveAllSettings(&settings);
     settings.sync();
     if (settings.status() != QSettings::NoError)
+    {
         QString errorText;
         if (settings.status() == QSettings::AccessError)
+        {
             QString file = settings.fileName();
             errorText = QString("Serialplot cannot save settings due to access error. \
 This happens if you have run serialplot as root (with sudo for ex.) previously. \
 Try fixing the permissions of file: %1, or just delete it.").arg(file);
+        }
         else
+        {
             errorText = QString("Serialplot cannot save settings due to unknown error: %1").\
                 arg(settings.status());
+        }
         auto button = QMessageBox::critical(
             NULL,
             "Failed to save settings!", errorText,
             QMessageBox::Cancel | QMessageBox::Ok);
         if (button == QMessageBox::Cancel)
+        {
             event->ignore();
             return;

src/plot.cpp

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <QRectF>
 #include <QKeySequence>
 #include <QColor>
 #include <qwt_symbol.h>
 #include <qwt_plot_curve.h>
 #include <math.h>
 #include <algorithm>
 #include "plot.h"
 #include "utils.h"
 static const int SYMBOL_SHOW_AT_WIDTH = 5;
 static const int SYMBOL_SIZE_MAX = 7;
 Plot::Plot(QWidget* parent) :
     QwtPlot(parent),
     zoomer(this->canvas(), false),
     sZoomer(this, &zoomer)
+{
     isAutoScaled = true;
     symbolSize = 0;
     numOfSamples = 1;
     plotWidth = 1;
     showSymbols = Plot::ShowSymbolsAuto;
     QObject::connect(&zoomer, &Zoomer::unzoomed, this, &Plot::unzoomed);
     zoomer.setZoomBase();
     grid.attach(this);
     legend.attach(this);
     showGrid(false);
     darkBackground(false);
     snapshotOverlay = NULL;
     connect(&zoomer, &QwtPlotZoomer::zoomed,
             [this](const QRectF &rect)
+            {
                 onXScaleChanged();
             });
     connect(this, &QwtPlot::itemAttached,
             [this](QwtPlotItem *plotItem, bool on)
+            {
                 if (symbolSize) updateSymbols();
             });
     // init demo indicator
     QwtText demoText(" DEMO RUNNING ");  // looks better with spaces
     demoText.setColor(QColor("white"));
     demoText.setBackgroundBrush(Qt::darkRed);
     demoText.setBorderRadius(4);
     demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignBottom);
     demoIndicator.setText(demoText);
     demoIndicator.hide();
     demoIndicator.attach(this);
     // init no channels are visible indicator
     QwtText noChannelText(" No Visible Channels ");
     noChannelText.setColor(QColor("white"));
     noChannelText.setBackgroundBrush(Qt::darkBlue);
     noChannelText.setBorderRadius(4);
     noChannelText.setRenderFlags(Qt::AlignHCenter | Qt::AlignVCenter);
     noChannelIndicator.setText(noChannelText);
     noChannelIndicator.hide();
     noChannelIndicator.attach(this);
+}
 Plot::~Plot()
+{
     if (snapshotOverlay != NULL) delete snapshotOverlay;
+}
 void Plot::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+{
     this->isAutoScaled = autoScaled;
     if (!autoScaled)
+    {
         yMin = yAxisMin;
         yMax = yAxisMax;
+    }
     zoomer.zoom(0);
     resetAxes();
+}
 void Plot::setXAxis(double xMin, double xMax)
+{
     _xMin = xMin;
     _xMax = xMax;
     zoomer.setXLimits(xMin, xMax);
     zoomer.zoom(0); // unzoom
     // set axis
     setAxisScale(QwtPlot::xBottom, xMin, xMax);
+    // setAxisScale(QwtPlot::xBottom, xMin, xMax);
     replot(); // Note: if we don't replot here scale at startup isn't set correctly
     // reset zoom base
     auto base = zoomer.zoomBase();
     base.setLeft(xMin);
     base.setRight(xMax);
     zoomer.setZoomBase(base);
     // auto base = zoomer.zoomBase();
     // base.setLeft(xMin);
     // base.setRight(xMax);
     // zoomer.setZoomBase(base);
     onXScaleChanged();
+}
 void Plot::resetAxes()
+{
     // reset y axis
     if (isAutoScaled)
+    {
         setAxisAutoScale(QwtPlot::yLeft);
+    }
     else
+    {
         setAxisScale(QwtPlot::yLeft, yMin, yMax);
+    }
     zoomer.setZoomBase();
     replot();
+}
 void Plot::unzoomed()
+{
     resetAxes();
     onXScaleChanged();
+}
 void Plot::showGrid(bool show)
+{
     grid.enableX(show);
     grid.enableY(show);
     replot();
+}
 void Plot::showMinorGrid(bool show)
+{
     grid.enableXMin(show);
     grid.enableYMin(show);
     replot();
+}
 void Plot::showLegend(bool show)
+{
     legend.setVisible(show);
     replot();
+}
 void Plot::showDemoIndicator(bool show)
+{
     demoIndicator.setVisible(show);
     replot();
+}
 void Plot::showNoChannel(bool show)
+{
     noChannelIndicator.setVisible(show);
     replot();
+}
 void Plot::unzoom()
+{
     zoomer.zoom(0);
+}
 void Plot::darkBackground(bool enabled)
+{
     QColor gridColor;
     if (enabled)
+    {
         setCanvasBackground(QBrush(Qt::black));
         gridColor.setHsvF(0, 0, 0.25);
         grid.setPen(gridColor);
         zoomer.setRubberBandPen(QPen(Qt::white));
         zoomer.setTrackerPen(QPen(Qt::white));
         sZoomer.setPickerPen(QPen(Qt::white));
         legend.setTextPen(QPen(Qt::white));
+    }
     else
+    {
         setCanvasBackground(QBrush(Qt::white));
         gridColor.setHsvF(0, 0, 0.80);
         grid.setPen(gridColor);
         zoomer.setRubberBandPen(QPen(Qt::black));
         zoomer.setTrackerPen(QPen(Qt::black));
         sZoomer.setPickerPen(QPen(Qt::black));
         legend.setTextPen(QPen(Qt::black));
+    }
     updateSymbols();
     replot();
+}
 /*
   Below crude drawing demostrates how color selection occurs for
   given channel index
 °                     <--Hue Value-->                           360°
   |* . o . + . o . * . o . + . o . * . o . + . o . * . o . + . o . |
   * -> 0-3
   + -> 4-7
   o -> 8-15
   . -> 16-31
  */
 QColor Plot::makeColor(unsigned int channelIndex)
+{
     auto i = channelIndex;
     if (i < 4)
+    {
         return QColor::fromHsv(360*i/4, 255, 230);
+    }
     else
+    {
         double p = floor(log2(i));
         double n = pow(2, p);
         i = i - n;
         return QColor::fromHsv(360*i/n + 360/pow(2,p+1), 255, 230);
+    }
+}
 void Plot::flashSnapshotOverlay(bool light)
+{
     if (snapshotOverlay != NULL) delete snapshotOverlay;
     QColor color;
     if(light)
+    {
         color = QColor(Qt::white);
+    }
     else
+    {
         color = QColor(Qt::black);
+    }
     snapshotOverlay = new PlotSnapshotOverlay(this->canvas(), color);
     connect(snapshotOverlay, &PlotSnapshotOverlay::done,
             [this]()
+            {
                 delete snapshotOverlay;
                 snapshotOverlay = NULL;
             });
+}
 void Plot::setSymbols(ShowSymbols shown)
+{
     showSymbols = shown;
     if (showSymbols == Plot::ShowSymbolsAuto)
+    {
         calcSymbolSize();
+    }
     else if (showSymbols == Plot::ShowSymbolsShow)
+    {
         symbolSize = SYMBOL_SIZE_MAX;
+    }
     else
+    {
         symbolSize = 0;
+    }
     updateSymbols();
     replot();
+}
 void Plot::onXScaleChanged()
+{
     if (showSymbols == Plot::ShowSymbolsAuto)
+    {
         calcSymbolSize();
         updateSymbols();
+    }
+}
 void Plot::calcSymbolSize()
+{
     auto sw = axisWidget(QwtPlot::xBottom);
     auto paintDist = sw->scaleDraw()->scaleMap().pDist();
     auto scaleDist = sw->scaleDraw()->scaleMap().sDist();
     auto fullScaleDist = zoomer.zoomBase().width();
     auto zoomRate = fullScaleDist / scaleDist;
     float samplesInView = numOfSamples / zoomRate;
     float plotWidthNumSamp = abs(numOfSamples * plotWidth / (_xMax - _xMin));
     float samplesInView = plotWidthNumSamp / zoomRate;
     int symDisPx = round(paintDist / samplesInView);
     if (symDisPx < SYMBOL_SHOW_AT_WIDTH)
+    {
         symbolSize = 0;
+    }
     else
+    {
         symbolSize = std::min(SYMBOL_SIZE_MAX, symDisPx-SYMBOL_SHOW_AT_WIDTH+1);
+    }
+}
 void Plot::updateSymbols()
+{
     const QwtPlotItemList curves = itemList( QwtPlotItem::Rtti_PlotCurve );
     if (curves.size() > 0)
+    {
         for (int i = 0; i < curves.size(); i++)
+        {
             QwtSymbol* symbol = NULL;
             QwtPlotCurve* curve = static_cast<QwtPlotCurve*>(curves[i]);
             if (symbolSize)
+            {
                 symbol = new QwtSymbol(QwtSymbol::Ellipse,
                                        canvasBackground(),
                                        curve->pen(),
                                        QSize(symbolSize, symbolSize));
+            }
             curve->setSymbol(symbol);
+        }
+    }
+}
 void Plot::resizeEvent(QResizeEvent * event)
+{
     QwtPlot::resizeEvent(event);
     onXScaleChanged();
+}
 void Plot::setNumOfSamples(unsigned value)
+{
     numOfSamples = value;
     onXScaleChanged();
+}
 void Plot::setPlotWidth(double width)
+{
     plotWidth = width;
     zoomer.setHViewSize(width);
+}

src/plot.h

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef PLOT_H
 #define PLOT_H
 #include <QColor>
 #include <QList>
 #include <QAction>
 #include <qwt_plot.h>
 #include <qwt_plot_grid.h>
 #include <qwt_plot_shapeitem.h>
 #include <qwt_plot_legenditem.h>
 #include <qwt_plot_textlabel.h>
 #include "zoomer.h"
 #include "scalezoomer.h"
 #include "plotsnapshotoverlay.h"
 class Plot : public QwtPlot
+{
     Q_OBJECT
     friend class PlotManager;
 public:
     enum ShowSymbols
+    {
         ShowSymbolsAuto,
         ShowSymbolsShow,
         ShowSymbolsHide
     };
     Plot(QWidget* parent = 0);
     ~Plot();
     static QColor makeColor(unsigned int channelIndex);
 public slots:
     void showGrid(bool show = true);
     void showMinorGrid(bool show = true);
     void showLegend(bool show = true);
     void showDemoIndicator(bool show = true);
     void showNoChannel(bool show = true);
     void unzoom();
     void darkBackground(bool enabled = true);
     void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     void setXAxis(double xMin, double xMax);
     void setSymbols(ShowSymbols shown);
     /**
      * Displays an animation for snapshot.
+     *
      * @param light show a light colored (white) animation or the opposite
      */
     void flashSnapshotOverlay(bool light);
     void setNumOfSamples(unsigned value);
     void setPlotWidth(double width);
 protected:
     /// update the display of symbols depending on `symbolSize`
     void updateSymbols();
 private:
     bool isAutoScaled;
     double yMin, yMax;
     double _xMin, _xMax;
     unsigned numOfSamples;
     double plotWidth;
     int symbolSize;
     Zoomer zoomer;
     ScaleZoomer sZoomer;
     QwtPlotGrid grid;
     PlotSnapshotOverlay* snapshotOverlay;
     QwtPlotLegendItem legend;
     QwtPlotTextLabel demoIndicator;
     QwtPlotTextLabel noChannelIndicator;
     ShowSymbols showSymbols;
     void resetAxes();
     void resizeEvent(QResizeEvent * event);
     void calcSymbolSize();
 private slots:
     void unzoomed();
     void onXScaleChanged();
 };
 #endif // PLOT_H

src/plotcontrolpanel.cpp

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <QVariant>
 #include <QMessageBox>
 #include <QCheckBox>
 #include <math.h>
 #include "color_selector.hpp"
 #include "plotcontrolpanel.h"
 #include "ui_plotcontrolpanel.h"
 #include "setting_defines.h"
 /// Confirm if #samples is being set to a value greater than this
-const int NUMSAMPLES_CONFIRM_AT = 10000;
+const int NUMSAMPLES_CONFIRM_AT = 1000000;
 /// Used for scale range selection combobox
 struct Range
+{
     double rmin;
     double rmax;
 };
 Q_DECLARE_METATYPE(Range);
 PlotControlPanel::PlotControlPanel(QWidget *parent) :
     QWidget(parent),
     ui(new Ui::PlotControlPanel),
     resetAct(tr("Reset"), this),
     resetNamesAct(tr("Reset Names"), this),
     resetColorsAct(tr("Reset Colors"), this),
     showAllAct(tr("Show All"), this),
     resetMenu(tr("Reset Menu"), this)
+{
     ui->setupUi(this);
     warnNumOfSamples = true;    // TODO: load from settings
     _numOfSamples = ui->spNumOfSamples->value();
     // set limits for axis limit boxes
     ui->spYmin->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spYmax->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spXmin->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spXmax->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     // connect signals
     connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),
             this, SLOT(onNumOfSamples(int)));
     connect(ui->cbAutoScale, &QCheckBox::toggled,
             this, &PlotControlPanel::onAutoScaleChecked);
     connect(ui->spYmax, SIGNAL(valueChanged(double)),
             this, SLOT(onYScaleChanged()));
     connect(ui->spYmin, SIGNAL(valueChanged(double)),
             this, SLOT(onYScaleChanged()));
     connect(ui->cbIndex, &QCheckBox::toggled,
             this, &PlotControlPanel::onIndexChecked);
     connect(ui->spXmax, SIGNAL(valueChanged(double)),
             this, SLOT(onXScaleChanged()));
     connect(ui->spXmin, SIGNAL(valueChanged(double)),
             this, SLOT(onXScaleChanged()));
     connect(ui->spPlotWidth, SIGNAL(valueChanged(int)),
             this, SLOT(onPlotWidthChanged()));
     // init scale range preset list
     for (int nbits = 8; nbits <= 24; nbits++) // signed binary formats
+    {
         int rmax = pow(2, nbits-1)-1;
         int rmin = -rmax-1;
         Range r = {double(rmin),  double(rmax)};
         ui->cbRangePresets->addItem(
             QString().sprintf("Signed %d bits %d to +%d", nbits, rmin, rmax),
             QVariant::fromValue(r));
+    }
     for (int nbits = 8; nbits <= 24; nbits++) // unsigned binary formats
+    {
         int rmax = pow(2, nbits)-1;
         ui->cbRangePresets->addItem(
             QString().sprintf("Unsigned %d bits %d to +%d", nbits, 0, rmax),
             QVariant::fromValue(Range{0, double(rmax)}));
+    }
     ui->cbRangePresets->addItem("-1 to +1", QVariant::fromValue(Range{-1, +1}));
     ui->cbRangePresets->addItem("0 to +1", QVariant::fromValue(Range{0, +1}));
     ui->cbRangePresets->addItem("-100 to +100", QVariant::fromValue(Range{-100, +100}));
     ui->cbRangePresets->addItem("0 to +100", QVariant::fromValue(Range{0, +100}));
     QObject::connect(ui->cbRangePresets, SIGNAL(activated(int)),
                      this, SLOT(onRangeSelected()));
     // color selector starts disabled until a channel is selected
     ui->colorSelector->setColor(QColor(0,0,0,0));
     ui->colorSelector->setDisplayMode(color_widgets::ColorPreview::AllAlpha);
     ui->colorSelector->setDisabled(true);
     // reset button
     resetMenu.addAction(&resetNamesAct);
     resetMenu.addAction(&resetColorsAct);
     resetMenu.addAction(&showAllAct);
     resetAct.setMenu(&resetMenu);
     ui->tbReset->setDefaultAction(&resetAct);
+}
 PlotControlPanel::~PlotControlPanel()
+{
     delete ui;
+}
 unsigned PlotControlPanel::numOfSamples()
+{
     return ui->spNumOfSamples->value();
+}
 void PlotControlPanel::onNumOfSamples(int value)
+{
     if (warnNumOfSamples && value > NUMSAMPLES_CONFIRM_AT)
+    {
         // ask confirmation
         if (!askNSConfirmation(value))
+        {
             // revert to old value
             disconnect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),
                        this, SLOT(onNumOfSamples(int)));
             ui->spNumOfSamples->setValue(_numOfSamples);
             connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),
                     this, SLOT(onNumOfSamples(int)));
             return;
+        }
+    }
     _numOfSamples = value;
     emit numOfSamplesChanged(value);
+}
 bool PlotControlPanel::askNSConfirmation(int value)
+{
     auto text = tr("Setting number of samples to a too big value "
                    "(>%1) can seriously impact the performance of "
                    "the application and cause freezes. Are you sure you "
                    "want to change the number of samples to %2?")
         .arg(QString::number(NUMSAMPLES_CONFIRM_AT), QString::number(value));
     // TODO: parent the mainwindow
     QMessageBox mb(QMessageBox::Warning,
                    tr("Confirm Number of Samples"),
                    text,
                    QMessageBox::Apply | QMessageBox::Cancel,
                    this);
     auto cb = new QCheckBox("Don't show this again.");
     connect(cb, &QCheckBox::stateChanged, [this](int state)
+            {
                 warnNumOfSamples = (state == Qt::Unchecked);
             });
     mb.setCheckBox(cb);
     return mb.exec() == QMessageBox::Apply;
+}
 void PlotControlPanel::onAutoScaleChecked(bool checked)
+{
     if (checked)
+    {
         ui->lYmin->setEnabled(false);
         ui->lYmax->setEnabled(false);
         ui->spYmin->setEnabled(false);
         ui->spYmax->setEnabled(false);
         emit yScaleChanged(true); // autoscale
+    }
     else
+    {
         ui->lYmin->setEnabled(true);
         ui->lYmax->setEnabled(true);
         ui->spYmin->setEnabled(true);
         ui->spYmax->setEnabled(true);
         emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
+    }
+}
 void PlotControlPanel::onYScaleChanged()
+{
     if (!autoScale())
+    {
         emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
+    }
+}
 bool PlotControlPanel::autoScale() const
+{
     return ui->cbAutoScale->isChecked();
+}
 double PlotControlPanel::yMax() const
+{
     return ui->spYmax->value();
+}
 double PlotControlPanel::yMin() const
+{
     return ui->spYmin->value();
+}
 bool PlotControlPanel::xAxisAsIndex() const
+{
     return ui->cbIndex->isChecked();
+}
 double PlotControlPanel::xMax() const
+{
     return ui->spXmax->value();
+}
 double PlotControlPanel::xMin() const
+{
     return ui->spXmin->value();
+}
 void PlotControlPanel::onRangeSelected()
+{
     Range r = ui->cbRangePresets->currentData().value<Range>();
     ui->spYmin->setValue(r.rmin);
     ui->spYmax->setValue(r.rmax);
     ui->cbAutoScale->setChecked(false);
+}
 void PlotControlPanel::onIndexChecked(bool checked)
+{
     if (checked)
+    {
         ui->lXmin->setEnabled(false);
         ui->lXmax->setEnabled(false);
         ui->spXmin->setEnabled(false);
         ui->spXmax->setEnabled(false);
         emit xScaleChanged(true); // use index
+    }
     else
+    {
         ui->lXmin->setEnabled(true);
         ui->lXmax->setEnabled(true);
         ui->spXmin->setEnabled(true);
         ui->spXmax->setEnabled(true);
         emit xScaleChanged(false, ui->spXmin->value(), ui->spXmax->value());
+    }
     emit plotWidthChanged(plotWidth());
+}
 void PlotControlPanel::onXScaleChanged()
+{
     if (!xAxisAsIndex())
+    {
         emit xScaleChanged(false, ui->spXmin->value(), ui->spXmax->value());
         emit plotWidthChanged(plotWidth());
+    }
+}
 double PlotControlPanel::plotWidth() const
+{
     double value = ui->spPlotWidth->value();
     if (!xAxisAsIndex())
+    {
         // scale by xmin and xmax
         auto xmax = ui->spXmax->value();
         auto xmin = ui->spXmin->value();
         double scale = (xmax - xmin) / _numOfSamples;
         value *= scale;
+    }
     return value;
+}
 void PlotControlPanel::onPlotWidthChanged()
+{
     emit plotWidthChanged(plotWidth());
+}
 void PlotControlPanel::setChannelInfoModel(ChannelInfoModel* model)
+{
     ui->tvChannelInfo->setModel(model);
     // channel color selector
     connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::currentRowChanged,
             [this](const QModelIndex &current, const QModelIndex &previous)
+            {
                 // TODO: duplicate with below lambda
                 QColor color(0,0,0,0); // transparent
                 if (current.isValid())
+                {
                     ui->colorSelector->setEnabled(true);
                     auto model = ui->tvChannelInfo->model();
                     color = model->data(current, Qt::ForegroundRole).value<QColor>();
+                }
                 else
+                {
                     ui->colorSelector->setDisabled(true);
+                }
                 // temporarily block signals because `setColor` emits `colorChanged`
                 bool wasBlocked = ui->colorSelector->blockSignals(true);
                 ui->colorSelector->setColor(color);
                 ui->colorSelector->blockSignals(wasBlocked);
             });
     connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::selectionChanged,
             [this](const QItemSelection & selected, const QItemSelection & deselected)
+            {
                 if (!selected.length())
+                {
                     ui->colorSelector->setDisabled(true);
                     // temporarily block signals because `setColor` emits `colorChanged`
                     bool wasBlocked = ui->colorSelector->blockSignals(true);
                     ui->colorSelector->setColor(QColor(0,0,0,0));
                     ui->colorSelector->blockSignals(wasBlocked);
+                }
             });
     connect(ui->colorSelector, &color_widgets::ColorSelector::colorChanged,
             [this](QColor color)
+            {
                 auto index = ui->tvChannelInfo->selectionModel()->currentIndex();
                 ui->tvChannelInfo->model()->setData(index, color, Qt::ForegroundRole);
             });
     connect(model, &QAbstractItemModel::dataChanged,
             [this](const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles = QVector<int> ())
+            {
                 auto current = ui->tvChannelInfo->selectionModel()->currentIndex();
                 // no current selection
                 if (!current.isValid()) return;
                 auto mod = ui->tvChannelInfo->model();
                 QColor color = mod->data(current, Qt::ForegroundRole).value<QColor>();
                 // temporarily block signals because `setColor` emits `colorChanged`
                 bool wasBlocked = ui->colorSelector->blockSignals(true);
                 ui->colorSelector->setColor(color);
                 ui->colorSelector->blockSignals(wasBlocked);
             });
     // reset actions
     connect(&resetAct, &QAction::triggered, model, &ChannelInfoModel::resetInfos);
     connect(&resetNamesAct, &QAction::triggered, model, &ChannelInfoModel::resetNames);
     connect(&resetColorsAct, &QAction::triggered, model, &ChannelInfoModel::resetColors);
     connect(&showAllAct, &QAction::triggered, model, &ChannelInfoModel::resetVisibility);
+}
 void PlotControlPanel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     settings->setValue(SG_Plot_NumOfSamples, numOfSamples());
     settings->setValue(SG_Plot_PlotWidth, ui->spPlotWidth->value());
     settings->setValue(SG_Plot_IndexAsX, xAxisAsIndex());
     settings->setValue(SG_Plot_XMax, xMax());
     settings->setValue(SG_Plot_XMin, xMin());
     settings->setValue(SG_Plot_AutoScale, autoScale());
     settings->setValue(SG_Plot_YMax, yMax());
     settings->setValue(SG_Plot_YMin, yMin());
     settings->endGroup();
+}
 void PlotControlPanel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     ui->spNumOfSamples->setValue(
         settings->value(SG_Plot_NumOfSamples, numOfSamples()).toInt());
     ui->spPlotWidth->setValue(
         settings->value(SG_Plot_PlotWidth, ui->spPlotWidth->value()).toInt());
     ui->cbIndex->setChecked(
         settings->value(SG_Plot_IndexAsX, xAxisAsIndex()).toBool());
     ui->spXmax->setValue(settings->value(SG_Plot_XMax, xMax()).toDouble());
     ui->spXmin->setValue(settings->value(SG_Plot_XMin, xMin()).toDouble());
     ui->cbAutoScale->setChecked(
         settings->value(SG_Plot_AutoScale, autoScale()).toBool());
     ui->spYmax->setValue(settings->value(SG_Plot_YMax, yMax()).toDouble());
     ui->spYmin->setValue(settings->value(SG_Plot_YMin, yMin()).toDouble());
     settings->endGroup();
+}

src/plotcontrolpanel.h

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef PLOTCONTROLPANEL_H
 #define PLOTCONTROLPANEL_H
 #include <QWidget>
 #include <QSettings>
 #include <QAction>
 #include <QMenu>
 #include "channelinfomodel.h"
 namespace Ui {
 class PlotControlPanel;
+}
 class PlotControlPanel : public QWidget
+{
     Q_OBJECT
 public:
     explicit PlotControlPanel(QWidget *parent = 0);
     ~PlotControlPanel();
     unsigned numOfSamples();
     bool   autoScale() const;
     double yMax() const;
     double yMin() const;
     bool   xAxisAsIndex() const;
     double xMax() const;
     double xMin() const;
     /// Returns the plot width adjusted for x axis scaling.
     double plotWidth() const;
     void setChannelInfoModel(ChannelInfoModel* model);
     /// Stores plot settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads plot settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 signals:
     void numOfSamplesChanged(int value);
     void yScaleChanged(bool autoScaled, double yMin = 0, double yMax = 1);
     void xScaleChanged(bool asIndex, double xMin = 0, double xMax = 1);
     void plotWidthChanged(double width);
 private:
     Ui::PlotControlPanel *ui;
     /// Holds 'number of samples' after the confirmation
     unsigned _numOfSamples;
     /// User can disable this setting in the checkbox
     bool warnNumOfSamples;
     QAction resetAct, resetNamesAct, resetColorsAct, showAllAct;
     QMenu resetMenu;
     /// Show a confirmation dialog before setting #samples to a big value
     bool askNSConfirmation(int value);
 private slots:
     void onNumOfSamples(int value);
     void onAutoScaleChecked(bool checked);
     void onYScaleChanged();
     void onRangeSelected();
     void onIndexChecked(bool checked);
     void onXScaleChanged();
     void onPlotWidthChanged();
 };
 #endif // PLOTCONTROLPANEL_H

src/plotcontrolpanel.ui

➞

Show inline comments

 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>PlotControlPanel</class>
  <widget class="QWidget" name="PlotControlPanel">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>706</width>
-    <height>187</height>
+    <height>195</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout">
    <item>
     <widget class="QWidget" name="widget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <property name="spacing">
        <number>3</number>
       </property>
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item>
        <widget class="QTableView" name="tvChannelInfo">
         <property name="sizePolicy">
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximumSize">
          <size>
           <width>300</width>
           <height>170</height>
          </size>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::SingleSelection</enum>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <property name="sizeConstraint">
          <enum>QLayout::SetMaximumSize</enum>
         </property>
         <item>
          <widget class="color_widgets::ColorSelector" name="colorSelector" native="true">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>20</width>
             <height>20</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>20</width>
             <height>20</height>
            </size>
           </property>
          </widget>
         </item>
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>1</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QToolButton" name="tbReset">
           <property name="text">
            <string>Reset</string>
           </property>
           <property name="popupMode">
            <enum>QToolButton::MenuButtonPopup</enum>
           </property>
           <property name="arrowType">
            <enum>Qt::NoArrow</enum>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QFormLayout" name="formLayout_2">
      <property name="fieldGrowthPolicy">
       <enum>QFormLayout::FieldsStayAtSizeHint</enum>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label_3">
        <property name="toolTip">
         <string/>
        </property>
        <property name="text">
-        <string>Number Of Samples:</string>
+        <string>Buffer Size:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QSpinBox" name="spNumOfSamples">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>100</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
-        <string>length of X axis</string>
+        <string>Length of acquisition as number of samples</string>
        </property>
        <property name="keyboardTracking">
         <bool>false</bool>
        </property>
        <property name="minimum">
         <number>2</number>
        </property>
        <property name="maximum">
-        <number>1000000</number>
+        <number>10000000</number>
        </property>
        <property name="value">
         <number>1000</number>
        </property>
       </widget>
      </item>
-     <item row="1" column="0">
+     <item row="2" column="0">
       <widget class="QCheckBox" name="cbIndex">
        <property name="text">
         <string>Index as X AXis</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
-     <item row="1" column="1">
+     <item row="2" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_4">
        <item>
         <widget class="QLabel" name="lXmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Xmin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spXmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>lower limit of Y axis</string>
          </property>
          <property name="value">
           <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lXmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Xmax</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spXmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>upper limit of Y axis</string>
          </property>
          <property name="maximum">
           <double>1000.000000000000000</double>
          </property>
          <property name="value">
           <double>1000.000000000000000</double>
          </property>
         </widget>
        </item>
       </layout>
      </item>
-     <item row="2" column="0">
+     <item row="3" column="0">
       <widget class="QCheckBox" name="cbAutoScale">
        <property name="text">
         <string>Auto Scale Y Axis</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
-     <item row="2" column="1">
+     <item row="3" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_3">
        <item>
         <widget class="QLabel" name="lYmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Ymin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spYmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>lower limit of Y axis</string>
          </property>
          <property name="value">
           <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lYmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Ymax</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spYmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>upper limit of Y axis</string>
          </property>
          <property name="maximum">
           <double>1000.000000000000000</double>
          </property>
          <property name="value">
           <double>1000.000000000000000</double>
          </property>
         </widget>
        </item>
       </layout>
      </item>
-     <item row="5" column="0">
+     <item row="6" column="0">
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Select Range Preset:</string>
        </property>
       </widget>
      </item>
-     <item row="5" column="1">
+     <item row="6" column="1">
       <widget class="QComboBox" name="cbRangePresets"/>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="label_4">
        <property name="toolTip">
         <string/>
        </property>
        <property name="text">
         <string>Plot Width:</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QSpinBox" name="spPlotWidth">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>100</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Width of X axis as maximum number of samples that are shown in plot</string>
        </property>
        <property name="keyboardTracking">
         <bool>false</bool>
        </property>
        <property name="minimum">
         <number>2</number>
        </property>
        <property name="maximum">
         <number>100000</number>
        </property>
        <property name="value">
         <number>1000</number>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <spacer name="horizontalSpacer_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>1</width>
        <height>20</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>color_widgets::ColorSelector</class>
    <extends>QWidget</extends>
    <header>color_selector.hpp</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>

src/plotmanager.cpp

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <algorithm>
 #include <QActionGroup>
 #include <QMetaEnum>
 #include <QtDebug>
 #include "qwt_symbol.h"
 #include "plot.h"
 #include "plotmanager.h"
 #include "utils.h"
 #include "setting_defines.h"
 PlotManager::PlotManager(QWidget* plotArea, ChannelInfoModel* infoModel, QObject *parent) :
     QObject(parent),
     _plotArea(plotArea),
     showGridAction("&Grid", this),
     showMinorGridAction("&Minor Grid", this),
     unzoomAction("&Unzoom", this),
     darkBackgroundAction("&Dark Background", this),
     showLegendAction("&Legend", this),
     showMultiAction("Multi &Plot", this),
     setSymbolsAction("Symbols", this)
+{
     _autoScaled = true;
     _yMin = 0;
     _yMax = 1;
     _xAxisAsIndex = true;
     isDemoShown = false;
     _infoModel = infoModel;
     _numOfSamples = 1;
     _plotWidth = 1;
     showSymbols = Plot::ShowSymbolsAuto;
     emptyPlot = NULL;
     // initalize layout and single widget
     isMulti = false;
     scrollArea = NULL;
     setupLayout(isMulti);
     addPlotWidget();
     // initialize menu actions
     showGridAction.setToolTip("Show Grid");
     showMinorGridAction.setToolTip("Show Minor Grid");
     unzoomAction.setToolTip("Unzoom the Plot");
     darkBackgroundAction.setToolTip("Enable Dark Plot Background");
     showLegendAction.setToolTip("Display the Legend on Plot");
     showMultiAction.setToolTip("Display All Channels Separately");
     setSymbolsAction.setToolTip("Show/Hide symbols");
     showGridAction.setShortcut(QKeySequence("G"));
     showMinorGridAction.setShortcut(QKeySequence("M"));
     showGridAction.setCheckable(true);
     showMinorGridAction.setCheckable(true);
     darkBackgroundAction.setCheckable(true);
     showLegendAction.setCheckable(true);
     showMultiAction.setCheckable(true);
     showGridAction.setChecked(false);
     showMinorGridAction.setChecked(false);
     darkBackgroundAction.setChecked(false);
     showLegendAction.setChecked(true);
     showMultiAction.setChecked(false);
     showMinorGridAction.setEnabled(false);
     // setup symbols menu
     setSymbolsAutoAct = setSymbolsMenu.addAction("Show When Zoomed");
     setSymbolsAutoAct->setCheckable(true);
     setSymbolsAutoAct->setChecked(true);
     connect(setSymbolsAutoAct, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             [this](bool checked)
+            {
                 if (checked) setSymbols(Plot::ShowSymbolsAuto);
             });
     setSymbolsShowAct = setSymbolsMenu.addAction("Always Show");
     setSymbolsShowAct->setCheckable(true);
     connect(setSymbolsShowAct, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             [this](bool checked)
+            {
                 if (checked) setSymbols(Plot::ShowSymbolsShow);
             });
     setSymbolsHideAct = setSymbolsMenu.addAction("Always Hide");
     setSymbolsHideAct->setCheckable(true);
     connect(setSymbolsHideAct, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             [this](bool checked)
+            {
                 if (checked) setSymbols(Plot::ShowSymbolsHide);
             });
     setSymbolsAction.setMenu(&setSymbolsMenu);
     // add symbol actions to same group so that they appear as radio buttons
     auto group = new QActionGroup(this);
     group->addAction(setSymbolsAutoAct);
     group->addAction(setSymbolsShowAct);
     group->addAction(setSymbolsHideAct);
     connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showGrid);
     connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             &showMinorGridAction, &QAction::setEnabled);
     connect(&showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showMinorGrid);
     connect(&unzoomAction, &QAction::triggered, this, &PlotManager::unzoom);
     connect(&darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::darkBackground);
     connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showLegend);
     connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showLegend);
     connect(&showMultiAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::setMulti);
     // connect to channel info model
     if (_infoModel != NULL)     // TODO: remove when snapshots have infomodel
+    {
         connect(_infoModel, &QAbstractItemModel::dataChanged,
                 this, &PlotManager::onChannelInfoChanged);
         connect(_infoModel, &QAbstractItemModel::modelReset,
                 [this]()
+                {
                     onChannelInfoChanged(_infoModel->index(0, 0), // start
                                          _infoModel->index(_infoModel->rowCount()-1, 0), // end
                                          {}); // roles ignored
                 });
+    }
@@ @@ -223,192 +224,193 @@ void PlotManager::setMulti(bool enabled) @@
     isMulti = enabled;
     // detach all curves
     for (auto curve : curves)
+    {
         curve->detach();
+    }
     // remove all widgets
     while (plotWidgets.size())
+    {
         delete plotWidgets.takeLast();
+    }
     // setup new layout
     setupLayout(isMulti);
     if (isMulti)
+    {
         // add new widgets and attach
         for (auto curve : curves)
+        {
             auto plot = addPlotWidget();
             plot->setVisible(curve->isVisible());
             curve->attach(plot);
+        }
+    }
     else
+    {
         // add a single widget
         auto plot = addPlotWidget();
         // attach all curves
         for (auto curve : curves)
+        {
             curve->attach(plot);
+        }
+    }
     checkNoVisChannels();
+}
 void PlotManager::setupLayout(bool multiPlot)
+{
     // delete previous layout if it exists
     if (_plotArea->layout() != 0)
+    {
         delete _plotArea->layout();
+    }
     if (multiPlot)
+    {
         // setup a scroll area
         scrollArea = new QScrollArea();
         auto scrolledPlotArea = new QWidget(scrollArea);
         scrollArea->setWidget(scrolledPlotArea);
         scrollArea->setWidgetResizable(true);
         _plotArea->setLayout(new QVBoxLayout());
         _plotArea->layout()->addWidget(scrollArea);
         _plotArea->layout()->setContentsMargins(0,0,0,0);
         layout = new QVBoxLayout(scrolledPlotArea);
+    }
     else
+    {
         // delete scrollArea left from multi layout
         if (scrollArea != NULL)
+        {
             delete scrollArea;
             scrollArea = NULL;
+        }
         layout = new QVBoxLayout(_plotArea);
+    }
     layout->setContentsMargins(2,2,2,2);
     layout->setSpacing(1);
+}
 Plot* PlotManager::addPlotWidget()
+{
     auto plot = new Plot();
     plotWidgets.append(plot);
     layout->addWidget(plot);
     plot->darkBackground(darkBackgroundAction.isChecked());
     plot->showGrid(showGridAction.isChecked());
     plot->showMinorGrid(showMinorGridAction.isChecked());
     plot->showLegend(showLegendAction.isChecked());
     plot->showDemoIndicator(isDemoShown);
     plot->setYAxis(_autoScaled, _yMin, _yMax);
     plot->setNumOfSamples(_numOfSamples);
     plot->setSymbols(showSymbols);
     plot->setPlotWidth(_plotWidth);
     if (_xAxisAsIndex)
+    {
         plot->setXAxis(0, _numOfSamples);
+    }
     else
+    {
         plot->setXAxis(_xMin, _xMax);
+    }
     return plot;
+}
 void PlotManager::addCurve(QString title, FrameBuffer* buffer)
+{
     auto curve = new QwtPlotCurve(title);
     auto series = new FrameBufferSeries(buffer);
     series->setXAxis(_xAxisAsIndex, _xMin, _xMax);
     curve->setSamples(series);
     _addCurve(curve);
+}
 void PlotManager::addCurve(QString title, QVector<QPointF> data)
+{
     auto curve = new QwtPlotCurve(title);
     curve->setSamples(data);
     _addCurve(curve);
+}
 void PlotManager::_addCurve(QwtPlotCurve* curve)
+{
     // store and init the curve
     curves.append(curve);
     unsigned index = curves.size()-1;
     auto color = _infoModel->color(index);
     curve->setPen(color);
     // create the plot for the curve if we are on multi display
     Plot* plot;
     if (isMulti)
+    {
         // create a new plot widget
         plot = addPlotWidget();
+    }
     else
+    {
         plot = plotWidgets[0];
+    }
     // show the curve
     curve->attach(plot);
     plot->replot();
+}
 void PlotManager::removeCurves(unsigned number)
+{
     for (unsigned i = 0; i < number; i++)
+    {
         if (!curves.isEmpty())
+        {
             delete curves.takeLast();
             if (isMulti) // delete corresponding widget as well
+            {
                 delete plotWidgets.takeLast();
+            }
+        }
+    }
+}
 unsigned PlotManager::numOfCurves()
+{
     return curves.size();
+}
 void PlotManager::setTitle(unsigned index, QString title)
+{
     curves[index]->setTitle(title);
     plotWidget(index)->replot();
+}
 Plot* PlotManager::plotWidget(unsigned curveIndex)
+{
     if (isMulti)
+    {
         return plotWidgets[curveIndex];
+    }
     else
+    {
         return plotWidgets[0];
+    }
+}
 void PlotManager::replot()
+{
     for (auto plot : plotWidgets)
@@ @@ -449,192 +451,201 @@ void PlotManager::showMinorGrid(bool sho @@
 void PlotManager::showLegend(bool show)
+{
     for (auto plot : plotWidgets)
+    {
         plot->showLegend(show);
+    }
+}
 void PlotManager::showDemoIndicator(bool show)
+{
     isDemoShown = show;
     for (auto plot : plotWidgets)
+    {
         plot->showDemoIndicator(show);
+    }
+}
 void PlotManager::unzoom()
+{
     for (auto plot : plotWidgets)
+    {
         plot->unzoom();
+    }
+}
 void PlotManager::darkBackground(bool enabled)
+{
     for (auto plot : plotWidgets)
+    {
         plot->darkBackground(enabled);
+    }
+}
 void PlotManager::setSymbols(Plot::ShowSymbols shown)
+{
     showSymbols = shown;
     for (auto plot : plotWidgets)
+    {
         plot->setSymbols(shown);
+    }
+}
 void PlotManager::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+{
     _autoScaled = autoScaled;
     _yMin = yAxisMin;
     _yMax = yAxisMax;
     for (auto plot : plotWidgets)
+    {
         plot->setYAxis(autoScaled, yAxisMin, yAxisMax);
+    }
+}
 void PlotManager::setXAxis(bool asIndex, double xMin, double xMax)
+{
     _xAxisAsIndex = asIndex;
     _xMin = xMin;
     _xMax = xMax;
     for (auto curve : curves)
+    {
         // TODO: what happens when addCurve(QVector) is used?
         FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());
         series->setXAxis(asIndex, xMin, xMax);
+    }
     for (auto plot : plotWidgets)
+    {
         if (asIndex)
+        {
             plot->setXAxis(0, _numOfSamples);
+        }
         else
+        {
             plot->setXAxis(xMin, xMax);
+        }
+    }
     replot();
+}
 void PlotManager::flashSnapshotOverlay()
+{
     for (auto plot : plotWidgets)
+    {
         plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());
+    }
+}
 void PlotManager::setNumOfSamples(unsigned value)
+{
     _numOfSamples = value;
     for (auto plot : plotWidgets)
+    {
         plot->setNumOfSamples(value);
         if (_xAxisAsIndex) plot->setXAxis(0, value);
+    }
+}
 void PlotManager::setPlotWidth(double width)
+{
     _plotWidth = width;
     for (auto plot : plotWidgets)
+    {
         plot->setPlotWidth(width);
+    }
+}
 PlotViewSettings PlotManager::viewSettings() const
+{
     return PlotViewSettings(
+        {
             showGridAction.isChecked(),
             showMinorGridAction.isChecked(),
             darkBackgroundAction.isChecked(),
             showLegendAction.isChecked(),
             showMultiAction.isChecked(),
             showSymbols
         });
+}
 void PlotManager::setViewSettings(const PlotViewSettings& settings)
+{
     showGridAction.setChecked(settings.showGrid);
     showGrid(settings.showGrid);
     showMinorGridAction.setChecked(settings.showMinorGrid);
     showMinorGrid(settings.showMinorGrid);
     darkBackgroundAction.setChecked(settings.darkBackground);
     darkBackground(settings.darkBackground);
     showLegendAction.setChecked(settings.showLegend);
     showLegend(settings.showLegend);
     showMultiAction.setChecked(settings.showMulti);
     setMulti(settings.showMulti);
     setSymbols(settings.showSymbols);
     if (showSymbols == Plot::ShowSymbolsAuto)
+    {
         setSymbolsAutoAct->setChecked(true);
+    }
     else if (showSymbols == Plot::ShowSymbolsShow)
+    {
         setSymbolsShowAct->setChecked(true);
+    }
     else
+    {
         setSymbolsHideAct->setChecked(true);
+    }
+}
 void PlotManager::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     settings->setValue(SG_Plot_DarkBackground, darkBackgroundAction.isChecked());
     settings->setValue(SG_Plot_Grid, showGridAction.isChecked());
     settings->setValue(SG_Plot_MinorGrid, showMinorGridAction.isChecked());
     settings->setValue(SG_Plot_Legend, showLegendAction.isChecked());
     settings->setValue(SG_Plot_MultiPlot, showMultiAction.isChecked());
     QString showSymbolsStr;
     if (showSymbols == Plot::ShowSymbolsAuto)
+    {
         showSymbolsStr = "auto";
+    }
     else if (showSymbols == Plot::ShowSymbolsShow)
+    {
         showSymbolsStr = "show";
+    }
     else
+    {
         showSymbolsStr = "hide";
+    }
     settings->setValue(SG_Plot_Symbols, showSymbolsStr);
     settings->endGroup();
+}
 void PlotManager::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     darkBackgroundAction.setChecked(
         settings->value(SG_Plot_DarkBackground, darkBackgroundAction.isChecked()).toBool());
     darkBackground(darkBackgroundAction.isChecked());
     showGridAction.setChecked(
         settings->value(SG_Plot_Grid, showGridAction.isChecked()).toBool());
     showGrid(showGridAction.isChecked());
     showMinorGridAction.setChecked(
         settings->value(SG_Plot_MinorGrid, showMinorGridAction.isChecked()).toBool());
     showMinorGridAction.setEnabled(showGridAction.isChecked());
     showMinorGrid(showMinorGridAction.isChecked());
     showLegendAction.setChecked(
         settings->value(SG_Plot_Legend, showLegendAction.isChecked()).toBool());
     showLegend(showLegendAction.isChecked());
     showMultiAction.setChecked(
         settings->value(SG_Plot_MultiPlot, showMultiAction.isChecked()).toBool());
     setMulti(showMultiAction.isChecked());
     QString showSymbolsStr = settings->value(SG_Plot_Symbols, QString()).toString();
     if (showSymbolsStr == "auto")
+    {
         setSymbols(Plot::ShowSymbolsAuto);
         setSymbolsAutoAct->setChecked(true);
+    }
     else if (showSymbolsStr == "show")
+    {

src/plotmanager.h

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef PLOTMANAGER_H
 #define PLOTMANAGER_H
 #include <QObject>
 #include <QWidget>
 #include <QScrollArea>
 #include <QVBoxLayout>
 #include <QList>
 #include <QSettings>
 #include <QAction>
 #include <QMenu>
 #include <qwt_plot_curve.h>
 #include "plot.h"
 #include "framebufferseries.h"
 #include "channelinfomodel.h"
 struct PlotViewSettings
+{
     bool showGrid;
     bool showMinorGrid;
     bool darkBackground;
     bool showLegend;
     bool showMulti;
     Plot::ShowSymbols showSymbols;
 };
 class PlotManager : public QObject
+{
     Q_OBJECT
 public:
     explicit PlotManager(QWidget* plotArea, ChannelInfoModel* infoModel = NULL, QObject *parent = 0);
     ~PlotManager();
     /// Add a new curve with title and buffer. A color is
     /// automatically chosen for curve.
     void addCurve(QString title, FrameBuffer* buffer);
     /// Alternative of `addCurve` for static curve data (snapshots).
     void addCurve(QString title, QVector<QPointF> data);
     /// Set the displayed title for a curve
     void setTitle(unsigned index, QString title);
     /// Removes curves from the end
     void removeCurves(unsigned number);
     /// Returns current number of curves known by plot manager
     unsigned numOfCurves();
     /// Returns the list of actions to be inserted into the `View` menu
     QList<QAction*> menuActions();
     /// Returns current status of menu actions
     PlotViewSettings viewSettings() const;
     /// Set the current state of view
     void setViewSettings(const PlotViewSettings& settings);
     /// Stores plot settings into a `QSettings`.
     void saveSettings(QSettings* settings);
     /// Loads plot settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     /// Enable/Disable multiple plot display
     void setMulti(bool enabled);
     /// Update all plot widgets
     void replot();
     /// Enable display of a "DEMO" label on each plot
     void showDemoIndicator(bool show = true);
     /// Set the Y axis
     void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     /// Set the X axis
     void setXAxis(bool asIndex, double xMin = 0 , double xMax = 1);
     /// Display an animation for snapshot
     void flashSnapshotOverlay();
     /// Should be called to update zoom base
     void setNumOfSamples(unsigned value);
     /// Maximum width of X axis (limit of hscroll)
     void setPlotWidth(double width);
 private:
     bool isMulti;
     QWidget* _plotArea;
     QVBoxLayout* layout; ///< layout of the `plotArea`
     QScrollArea* scrollArea;
     QList<QwtPlotCurve*> curves;
     QList<Plot*> plotWidgets;
     Plot* emptyPlot;  ///< for displaying when all channels are hidden
     ChannelInfoModel* _infoModel;
     bool isDemoShown;
     bool _autoScaled;
     double _yMin;
     double _yMax;
     bool _xAxisAsIndex;
     double _xMin;
     double _xMax;
     unsigned _numOfSamples;
     double _plotWidth;
     Plot::ShowSymbols showSymbols;
     // menu actions
     QAction showGridAction;
     QAction showMinorGridAction;
     QAction unzoomAction;
     QAction darkBackgroundAction;
     QAction showLegendAction;
     QAction showMultiAction;
     QAction setSymbolsAction;
     QMenu setSymbolsMenu;
     QAction* setSymbolsAutoAct;
     QAction* setSymbolsShowAct;
     QAction* setSymbolsHideAct;
     void setupLayout(bool multiPlot);
     /// Inserts a new plot widget to the current layout.
     Plot* addPlotWidget();
     /// Returns the plot widget that given curve is attached to
     Plot* plotWidget(unsigned curveIndex);
     /// Common part of overloaded `addCurve` functions
     void _addCurve(QwtPlotCurve* curve);
     void setSymbols(Plot::ShowSymbols shown);
     /// Check and make sure "no visible channels" text is shown
     void checkNoVisChannels();
 private slots:
     void showGrid(bool show = true);
     void showMinorGrid(bool show = true);
     void showLegend(bool show = true);
     void unzoom();
     void darkBackground(bool enabled = true);
     void onChannelInfoChanged(const QModelIndex & topLeft,
                               const QModelIndex & bottomRight,
                               const QVector<int> & roles = QVector<int> ());
 };
 #endif // PLOTMANAGER_H

src/scrollzoomer.cpp

➞

Show inline comments

 /*
   Copyright © 2014 Uwe Rathmann
   This file is copied from Qwt project; you can redistribute it and/or modify it
   under the terms of the Qwt License, Version 1.0. You can obtain the original
   source code and the details of the Qwt License from the Qwt website:
   http://qwt.sourceforge.net/
 */
 #include <qevent.h>
 #include <qwt_plot_canvas.h>
 #include <qwt_plot_layout.h>
 #include <qwt_scale_engine.h>
 #include <qwt_scale_widget.h>
 #include "scrollbar.h"
 #include "scrollzoomer.h"
 class ScrollData
+{
 public:
     ScrollData():
         scrollBar( NULL ),
         position( ScrollZoomer::OppositeToScale ),
         mode( Qt::ScrollBarAsNeeded )
+    {
+    }
     ~ScrollData()
+    {
         delete scrollBar;
+    }
     ScrollBar *scrollBar;
     ScrollZoomer::ScrollBarPosition position;
     Qt::ScrollBarPolicy mode;
 };
 ScrollZoomer::ScrollZoomer( QWidget *canvas ):
     QwtPlotZoomer( canvas ),
     d_cornerWidget( NULL ),
     d_hScrollData( NULL ),
     d_vScrollData( NULL ),
     d_inZoom( false )
+{
     xMin = 0.;
     xMax = 10000.;
     hViewSize = 10000;
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         d_alignCanvasToScales[ axis ] = false;
     if ( !canvas )
         return;
     d_hScrollData = new ScrollData;
     d_vScrollData = new ScrollData;
     hscrollmove = false;
     vscrollmove = false;
+}
 ScrollZoomer::~ScrollZoomer()
+{
     delete d_cornerWidget;
     delete d_vScrollData;
     delete d_hScrollData;
+}
 void ScrollZoomer::setXLimits(double min, double max)
+{
     xMin = min;
     xMax = max;
     setZoomBase();
+}
 void ScrollZoomer::setHViewSize(double size)
+{
     hViewSize = size;
     setZoomBase();
+}
 void ScrollZoomer::setZoomBase(bool doReplot)
+{
     QwtPlotZoomer::setZoomBase(doReplot);
     auto zb = zoomBase();
     auto zs = zoomStack();
     zb.setRight(xMax);
     if ((xMax - xMin) < hViewSize)
+    {
         zb.setLeft(xMin);
+    }
     else
+    {
         zb.setLeft(xMax-hViewSize);
+    }
     zs[0] = zb;
     setZoomStack(zs);
+}
 void ScrollZoomer::rescale()
+{
     QwtScaleWidget *xScale = plot()->axisWidget( xAxis() );
     QwtScaleWidget *yScale = plot()->axisWidget( yAxis() );
     if ( zoomRectIndex() <= 0 )
+    {
         if ( d_inZoom )
+        {
             xScale->setMinBorderDist( 0, 0 );
             yScale->setMinBorderDist( 0, 0 );
             QwtPlotLayout *layout = plot()->plotLayout();
             for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
                 layout->setAlignCanvasToScale( axis, d_alignCanvasToScales[ axis ] );
             d_inZoom = false;
+        }
+    }
     else
+    {
         if ( !d_inZoom )
+        {
             /*
              We set a minimum border distance.
              Otherwise the canvas size changes when scrolling,
              between situations where the major ticks are at
              the canvas borders (requiring extra space for the label)
              and situations where all labels can be painted below/top
              or left/right of the canvas.
              */
             int start, end;
             xScale->getBorderDistHint( start, end );
             xScale->setMinBorderDist( start, end );
             yScale->getBorderDistHint( start, end );
             yScale->setMinBorderDist( start, end );
             QwtPlotLayout *layout = plot()->plotLayout();
             for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+            {
                 d_alignCanvasToScales[axis] =
                     layout->alignCanvasToScale( axis );
+            }
             layout->setAlignCanvasToScales( false );
             d_inZoom = true;
+        }
+    }
     QwtPlotZoomer::rescale();
     // NOTE: Below snippet is copied from QwtPlotZoomer::rescale() just so that
     // we can refrain from updating y axis when moving horizontal scrollbar, so
     // that auto-scale isn't disrupted. Also we don't want to jump around in
     // x-axis when moving vertical scroll.
+    {
         QwtPlot *plt = plot();
         if ( !plt )
             return;
         const QRectF &rect = zoomStack()[zoomRectIndex()];
         if ( rect != scaleRect() )
+        {
             const bool doReplot = plt->autoReplot();
             plt->setAutoReplot( false );
             if (!vscrollmove)
+            {
                 double x1 = rect.left();
                 double x2 = rect.right();
                 if ( !plt->axisScaleDiv( xAxis() ).isIncreasing() )
                     qSwap( x1, x2 );
                 plt->setAxisScale( xAxis(), x1, x2 );
+            }
             if (!hscrollmove)
+            {
                 double y1 = rect.top();
                 double y2 = rect.bottom();
                 if ( !plt->axisScaleDiv( yAxis() ).isIncreasing() )
                     qSwap( y1, y2 );
                 plt->setAxisScale( yAxis(), y1, y2 );
                 plt->setAutoReplot( doReplot );
+            }
             plt->replot();
+        }
+    }
     updateScrollBars();
+}
 ScrollBar *ScrollZoomer::scrollBar( Qt::Orientation orientation )
+{
     ScrollBar *&sb = ( orientation == Qt::Vertical )
         ? d_vScrollData->scrollBar : d_hScrollData->scrollBar;
     if ( sb == NULL )
+    {
         sb = new ScrollBar( orientation, canvas() );
         sb->hide();
         connect( sb,
             SIGNAL( valueChanged( Qt::Orientation, double, double ) ),
             SLOT( scrollBarMoved( Qt::Orientation, double, double ) ) );
+    }
     return sb;
+}
 ScrollBar *ScrollZoomer::horizontalScrollBar() const
+{
     return d_hScrollData->scrollBar;
+}
 ScrollBar *ScrollZoomer::verticalScrollBar() const
+{
     return d_vScrollData->scrollBar;
+}
 void ScrollZoomer::setHScrollBarMode( Qt::ScrollBarPolicy mode )
+{
     if ( hScrollBarMode() != mode )
+    {
         d_hScrollData->mode = mode;
         updateScrollBars();
+    }
+}
 void ScrollZoomer::setVScrollBarMode( Qt::ScrollBarPolicy mode )
+{
     if ( vScrollBarMode() != mode )
+    {
         d_vScrollData->mode = mode;
         updateScrollBars();
+    }
+}
 Qt::ScrollBarPolicy ScrollZoomer::hScrollBarMode() const
+{
     return d_hScrollData->mode;
+}
 Qt::ScrollBarPolicy ScrollZoomer::vScrollBarMode() const
+{
     return d_vScrollData->mode;
+}
 void ScrollZoomer::setHScrollBarPosition( ScrollBarPosition pos )
+{
     if ( d_hScrollData->position != pos )
+    {
         d_hScrollData->position = pos;
         updateScrollBars();
+    }
+}
 void ScrollZoomer::setVScrollBarPosition( ScrollBarPosition pos )
+{
     if ( d_vScrollData->position != pos )
+    {
         d_vScrollData->position = pos;
         updateScrollBars();
+    }
+}
 ScrollZoomer::ScrollBarPosition ScrollZoomer::hScrollBarPosition() const
+{
     return d_hScrollData->position;
+}
 ScrollZoomer::ScrollBarPosition ScrollZoomer::vScrollBarPosition() const
+{
     return d_vScrollData->position;
+}
 void ScrollZoomer::setCornerWidget( QWidget *w )
+{
     if ( w != d_cornerWidget )
+    {
         if ( canvas() )
+        {
             delete d_cornerWidget;
             d_cornerWidget = w;
             if ( d_cornerWidget->parent() != canvas() )
                 d_cornerWidget->setParent( canvas() );
             updateScrollBars();
+        }
+    }
+}
 QWidget *ScrollZoomer::cornerWidget() const
+{
     return d_cornerWidget;
+}
 bool ScrollZoomer::eventFilter( QObject *object, QEvent *event )
+{
     if ( object == canvas() )
+    {
         switch( event->type() )
+        {
             case QEvent::Resize:
+            {
                 int left, top, right, bottom;
                 canvas()->getContentsMargins( &left, &top, &right, &bottom );
                 QRect rect;
                 rect.setSize( static_cast<QResizeEvent *>( event )->size() );
                 rect.adjust( left, top, -right, -bottom );
                 layoutScrollBars( rect );
                 break;
+            }
             case QEvent::Show:
+            {
                 layoutScrollBars( canvas()->contentsRect() );
                 break;
+            }
             case QEvent::ChildRemoved:
+            {
                 const QObject *child =
                     static_cast<QChildEvent *>( event )->child();
                 if ( child == d_cornerWidget )
                     d_cornerWidget = NULL;
                 else if ( child == d_hScrollData->scrollBar )
                     d_hScrollData->scrollBar = NULL;
                 else if ( child == d_vScrollData->scrollBar )
                     d_vScrollData->scrollBar = NULL;
                 break;
+            }
             default:
                 break;
+        }
+    }
     return QwtPlotZoomer::eventFilter( object, event );
+}
 bool ScrollZoomer::needScrollBar( Qt::Orientation orientation ) const
+{
     Qt::ScrollBarPolicy mode;
     double zoomMin, zoomMax, baseMin, baseMax;
     if ( orientation == Qt::Horizontal )
+    {
         mode = d_hScrollData->mode;
         baseMin = zoomBase().left();
         baseMax = zoomBase().right();
         baseMin = xMin;
         baseMax = xMax;
         zoomMin = zoomRect().left();
         zoomMax = zoomRect().right();
+    }
     else
+    {
         mode = d_vScrollData->mode;
         baseMin = zoomBase().top();
         baseMax = zoomBase().bottom();
         zoomMin = zoomRect().top();
         zoomMax = zoomRect().bottom();
+    }
     bool needed = false;
     switch( mode )
+    {
         case Qt::ScrollBarAlwaysOn:
             needed = true;
             break;
         case Qt::ScrollBarAlwaysOff:
             needed = false;
             break;
         default:
+        {
             if ( baseMin < zoomMin || baseMax > zoomMax )
                 needed = true;
             break;
+        }
+    }
     return needed;
+}
 void ScrollZoomer::updateScrollBars()
+{
     if ( !canvas() )
         return;
     const int xAxis = QwtPlotZoomer::xAxis();
     const int yAxis = QwtPlotZoomer::yAxis();
     int xScrollBarAxis = xAxis;
     if ( hScrollBarPosition() == OppositeToScale )
         xScrollBarAxis = oppositeAxis( xScrollBarAxis );
     int yScrollBarAxis = yAxis;
     if ( vScrollBarPosition() == OppositeToScale )
         yScrollBarAxis = oppositeAxis( yScrollBarAxis );
     QwtPlotLayout *layout = plot()->plotLayout();
     bool showHScrollBar = needScrollBar( Qt::Horizontal );
     if ( showHScrollBar )
+    {
         ScrollBar *sb = scrollBar( Qt::Horizontal );
         sb->setPalette( plot()->palette() );
         sb->setInverted( !plot()->axisScaleDiv( xAxis ).isIncreasing() );
-        sb->setBase( zoomBase().left(), zoomBase().right() );
+        sb->setBase( xMin, xMax );
         sb->moveSlider( zoomRect().left(), zoomRect().right() );
         if ( !sb->isVisibleTo( canvas() ) )
+        {
             sb->show();
             layout->setCanvasMargin( layout->canvasMargin( xScrollBarAxis )
                 + sb->extent(), xScrollBarAxis );
+        }
+    }
     else
+    {
         if ( horizontalScrollBar() )
+        {
             horizontalScrollBar()->hide();
             layout->setCanvasMargin( layout->canvasMargin( xScrollBarAxis )
                 - horizontalScrollBar()->extent(), xScrollBarAxis );
+        }
+    }
     bool showVScrollBar = needScrollBar( Qt::Vertical );
     if ( showVScrollBar )
+    {
         ScrollBar *sb = scrollBar( Qt::Vertical );
         sb->setPalette( plot()->palette() );
         sb->setInverted( plot()->axisScaleDiv( yAxis ).isIncreasing() );
         sb->setBase( zoomBase().top(), zoomBase().bottom() );
         sb->moveSlider( zoomRect().top(), zoomRect().bottom() );
         if ( !sb->isVisibleTo( canvas() ) )
+        {
             sb->show();
             layout->setCanvasMargin( layout->canvasMargin( yScrollBarAxis )
                 + sb->extent(), yScrollBarAxis );
+        }
+    }
     else
+    {
         if ( verticalScrollBar() )
+        {
             verticalScrollBar()->hide();
             layout->setCanvasMargin( layout->canvasMargin( yScrollBarAxis )
                 - verticalScrollBar()->extent(), yScrollBarAxis );
+        }
+    }
     if ( showHScrollBar && showVScrollBar )
+    {
         if ( d_cornerWidget == NULL )
+        {
             d_cornerWidget = new QWidget( canvas() );
             d_cornerWidget->setAutoFillBackground( true );
             d_cornerWidget->setPalette( plot()->palette() );
+        }
         d_cornerWidget->show();
+    }
     else
+    {
         if ( d_cornerWidget )
             d_cornerWidget->hide();
+    }
     layoutScrollBars( canvas()->contentsRect() );
     plot()->updateLayout();
+}
 void ScrollZoomer::layoutScrollBars( const QRect &rect )
+{
     int hPos = xAxis();
     if ( hScrollBarPosition() == OppositeToScale )
         hPos = oppositeAxis( hPos );
     int vPos = yAxis();
     if ( vScrollBarPosition() == OppositeToScale )
         vPos = oppositeAxis( vPos );
     ScrollBar *hScrollBar = horizontalScrollBar();
     ScrollBar *vScrollBar = verticalScrollBar();
     const int hdim = hScrollBar ? hScrollBar->extent() : 0;
     const int vdim = vScrollBar ? vScrollBar->extent() : 0;
     if ( hScrollBar && hScrollBar->isVisible() )
+    {
         int x = rect.x();
         int y = ( hPos == QwtPlot::xTop )
             ? rect.top() : rect.bottom() - hdim + 1;
         int w = rect.width();
         if ( vScrollBar && vScrollBar->isVisible() )
+        {
             if ( vPos == QwtPlot::yLeft )
                 x += vdim;
             w -= vdim;
+        }
         hScrollBar->setGeometry( x, y, w, hdim );
+    }
     if ( vScrollBar && vScrollBar->isVisible() )
+    {
         int pos = yAxis();
         if ( vScrollBarPosition() == OppositeToScale )
             pos = oppositeAxis( pos );
         int x = ( vPos == QwtPlot::yLeft )
             ? rect.left() : rect.right() - vdim + 1;
         int y = rect.y();
         int h = rect.height();
         if ( hScrollBar && hScrollBar->isVisible() )
+        {
             if ( hPos == QwtPlot::xTop )
                 y += hdim;
             h -= hdim;
+        }
         vScrollBar->setGeometry( x, y, vdim, h );
+    }
     if ( hScrollBar && hScrollBar->isVisible() &&
         vScrollBar && vScrollBar->isVisible() )
+    {
         if ( d_cornerWidget )
+        {
             QRect cornerRect(
                 vScrollBar->pos().x(), hScrollBar->pos().y(),
                 vdim, hdim );
             d_cornerWidget->setGeometry( cornerRect );
+        }
+    }
+}
 void ScrollZoomer::scrollBarMoved(
     Qt::Orientation o, double min, double max )
+{
     Q_UNUSED( max );
     if ( o == Qt::Horizontal )
+    {
         hscrollmove = true;
         moveTo( QPointF( min, zoomRect().top() ) );
         hscrollmove = false;
+    }
     else
+    {
         vscrollmove = true;
         moveTo( QPointF( zoomRect().left(), min ) );
         vscrollmove = false;
+    }
     Q_EMIT zoomed( zoomRect() );
+}
 int ScrollZoomer::oppositeAxis( int axis ) const
+{
     switch( axis )
+    {
         case QwtPlot::xBottom:
             return QwtPlot::xTop;
         case QwtPlot::xTop:
             return QwtPlot::xBottom;
         case QwtPlot::yLeft:
             return QwtPlot::yRight;
         case QwtPlot::yRight:
             return QwtPlot::yLeft;
         default:
             break;
+    }
     return axis;
+}
 void ScrollZoomer::moveTo( const QPointF &pos )
+{
     // QwtPlotZoomer::moveTo(pos);
     // return;
     double x = pos.x();
     double y = pos.y();
     if ( x < xMin )
         x = xMin;
     if ( x > xMax - zoomRect().width() )
         x = xMax - zoomRect().width();
     if ( y < zoomBase().top() )
         y = zoomBase().top();
     if ( y > zoomBase().bottom() - zoomRect().height() )
         y = zoomBase().bottom() - zoomRect().height();
     if ( x != zoomRect().left() || y != zoomRect().top() )
+    {
         auto zs = zoomStack();
         zs[zoomRectIndex()].moveTo( x, y );
         setZoomStack(zs, zoomRectIndex());
         rescale();
+    }
+}

src/scrollzoomer.h

➞

Show inline comments

 /*
   Copyright © 2014 Uwe Rathmann
   This file is copied from Qwt project; you can redistribute it and/or modify it
   under the terms of the Qwt License, Version 1.0. You can obtain the original
   source code and the details of the Qwt License from the Qwt website:
   http://qwt.sourceforge.net/
 */
 #ifndef _SCROLLZOOMER_H
 #define _SCROLLZOOMER_H
 #include <qglobal.h>
 #include <qwt_plot_zoomer.h>
 #include <qwt_plot.h>
 class ScrollData;
 class ScrollBar;
 class ScrollZoomer: public QwtPlotZoomer
+{
     Q_OBJECT
 public:
     enum ScrollBarPosition
+    {
         AttachedToScale,
         OppositeToScale
     };
     ScrollZoomer( QWidget * );
     virtual ~ScrollZoomer();
     ScrollBar *horizontalScrollBar() const;
     ScrollBar *verticalScrollBar() const;
     void setHScrollBarMode( Qt::ScrollBarPolicy );
     void setVScrollBarMode( Qt::ScrollBarPolicy );
     Qt::ScrollBarPolicy vScrollBarMode () const;
     Qt::ScrollBarPolicy hScrollBarMode () const;
     void setHScrollBarPosition( ScrollBarPosition );
     void setVScrollBarPosition( ScrollBarPosition );
     ScrollBarPosition hScrollBarPosition() const;
     ScrollBarPosition vScrollBarPosition() const;
     QWidget* cornerWidget() const;
     virtual void setCornerWidget( QWidget * );
     virtual bool eventFilter( QObject *, QEvent * );
     void setXLimits(double min, double max);
     void setHViewSize(double size);
     virtual void setZoomBase(bool doReplot = true);
     virtual void rescale();
 public Q_SLOTS:
     virtual void moveTo( const QPointF & );
 protected:
     virtual ScrollBar *scrollBar( Qt::Orientation );
     virtual void updateScrollBars();
     virtual void layoutScrollBars( const QRect & );
 private Q_SLOTS:
     void scrollBarMoved( Qt::Orientation o, double min, double max );
 private:
     QRectF d_limits;
     double xMin, xMax;
     double hViewSize;
     bool needScrollBar( Qt::Orientation ) const;
     int oppositeAxis( int ) const;
     QWidget *d_cornerWidget;
     ScrollData *d_hScrollData;
     ScrollData *d_vScrollData;
     bool d_inZoom;
     bool d_alignCanvasToScales[ QwtPlot::axisCnt ];
     bool hscrollmove;
     bool vscrollmove;
 };
 #endif

src/setting_defines.h

➞

Show inline comments

 /*
   Copyright © 2017 Hasan Yavuz Özderya
   This file is part of serialplot.
   serialplot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   serialplot is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef SETTING_DEFINES_H
 #define SETTING_DEFINES_H
 const char SettingGroup_MainWindow[] = "MainWindow";
 const char SettingGroup_Port[] = "Port";
 const char SettingGroup_DataFormat[] = "DataFormat";
 const char SettingGroup_Binary[] = "DataFormat_Binary";
 const char SettingGroup_ASCII[] = "DataFormat_ASCII";
 const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";
 const char SettingGroup_Channels[] = "Channels";
 const char SettingGroup_Plot[] = "Plot";
 const char SettingGroup_Commands[] = "Commands";
 const char SettingGroup_Record[] = "Record";
 const char SettingGroup_UpdateCheck[] = "UpdateCheck";
 // mainwindow setting keys
 const char SG_MainWindow_Size[] = "size";
 const char SG_MainWindow_Pos[] = "pos";
 const char SG_MainWindow_ActivePanel[] = "activePanel";
 const char SG_MainWindow_HidePanels[] = "hidePanels";
 const char SG_MainWindow_Maximized[] = "maximized";
 const char SG_MainWindow_State[] = "state";
 // port setting keys
 const char SG_Port_SelectedPort[] = "selectedPort";
 const char SG_Port_BaudRate[] = "baudRate";
 const char SG_Port_Parity[] = "parity";
 const char SG_Port_DataBits[] = "dataBits";
 const char SG_Port_StopBits[] = "stopBits";
 const char SG_Port_FlowControl[] = "flowControl";
 // data format panel keys
 const char SG_DataFormat_Format[] = "format";
 // binary stream reader keys
 const char SG_Binary_NumOfChannels[] = "numOfChannels";
 const char SG_Binary_NumberFormat[] = "numberFormat";
 const char SG_Binary_Endianness[] = "endianness";
 // ascii reader keys
 const char SG_ASCII_NumOfChannels[] = "numOfChannels";
 const char SG_ASCII_Delimiter[] = "delimiter";
 const char SG_ASCII_CustomDelimiter[] = "customDelimiter";
 // framed reader keys
 const char SG_CustomFrame_NumOfChannels[] = "numOfChannels";
 const char SG_CustomFrame_FrameStart[] = "frameStart";
 const char SG_CustomFrame_FixedSize[] = "fixedSize";
 const char SG_CustomFrame_FrameSize[] = "frameSize";
 const char SG_CustomFrame_NumberFormat[] = "numberFormat";
 const char SG_CustomFrame_Endianness[] = "endianness";
 const char SG_CustomFrame_Checksum[] = "checksum";
 const char SG_CustomFrame_DebugMode[] = "debugMode";
 // channel manager keys
 const char SG_Channels_Channel[] = "channel";
 const char SG_Channels_Name[] = "name";
 const char SG_Channels_Color[] = "color";
 const char SG_Channels_Visible[] = "visible";
 // plot settings keys
 const char SG_Plot_NumOfSamples[] = "numOfSamples";
 const char SG_Plot_PlotWidth[] = "plotWidth";
 const char SG_Plot_IndexAsX[] = "indexAsX";
 const char SG_Plot_XMax[] = "xMax";
 const char SG_Plot_XMin[] = "xMin";
 const char SG_Plot_AutoScale[] = "autoScale";
 const char SG_Plot_YMax[] = "yMax";
 const char SG_Plot_YMin[] = "yMin";
 const char SG_Plot_DarkBackground[] = "darkBackground";
 const char SG_Plot_Grid[] = "grid";
 const char SG_Plot_MinorGrid[] = "minorGrid";
 const char SG_Plot_Legend[] = "legend";
 const char SG_Plot_MultiPlot[] = "multiPlot";
 const char SG_Plot_Symbols[] = "symbols";
 // command setting keys
 const char SG_Commands_Command[] = "command";
 const char SG_Commands_Name[] = "name";
 const char SG_Commands_Type[] = "type";
 const char SG_Commands_Data[] = "data";
 // record panel settings keys
 const char SG_Record_AutoIncrement[]    = "autoIncrement";
 const char SG_Record_RecordPaused[]     = "recordPaused";
 const char SG_Record_StopOnClose[]      = "stopOnClose";
 const char SG_Record_Header[]           = "header";
 const char SG_Record_Separator[]        = "separator";
 const char SG_Record_DisableBuffering[] = "disableBuffering";
 // update check settings keys
 const char SG_UpdateCheck_Periodic[]  = "periodicCheck";
 const char SG_UpdateCheck_LastCheck[] = "lastCheck";
 #endif // SETTING_DEFINES_H

0 comments (0 inline, 0 general)