tempo-plotter Changeset - 45bff47b2ed9 · protofusion repositories

Changeset - 45bff47b2ed9

Parent rev.

Child rev.

[Not reviewed]

barplot

0 7 0

Hasan Yavuz ÖZDERYA - 8 years ago 2017-10-07 08:30:07
hy@ozderya.net

move barplot under plotmanager and enable dark background

7 files changed with 68 insertions and 11 deletions:

src/barplot.cpp

src/barplot.h

src/mainwindow.cpp

src/mainwindow.h

src/plotmanager.cpp

src/plotmanager.h

src/snapshotview.cpp

0 comments (0 inline, 0 general)

src/barplot.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 "barplot.h"
 #include "barscaledraw.h"
 BarPlot::BarPlot(ChannelManager* channelMan, QWidget* parent) :
     QwtPlot(parent), barChart(channelMan)
+{
     _channelMan = channelMan;
     barChart.attach(this);
     setAxisMaxMinor(QwtPlot::xBottom, 0);
     setAxisScaleDraw(QwtPlot::xBottom, new BarScaleDraw(channelMan));
     update();
     connect(_channelMan, &ChannelManager::dataAdded, this, &BarPlot::update);
     connect(_channelMan, &ChannelManager::numOfChannelsChanged, this, &BarPlot::update);
+}
 void BarPlot::update()
+{
     // Note: -0.99 is used instead of -1 to handle the case of `numOfChannels==1`
     setAxisScale(QwtPlot::xBottom, 0, _channelMan->numOfChannels()-0.99, 1);
     barChart.resample();
     replot();
+}
 void BarPlot::darkBackground(bool enabled)
+{
     if (enabled)
+    {
         setCanvasBackground(QBrush(Qt::black));
+    }
     else
+    {
         setCanvasBackground(QBrush(Qt::white));
+    }
     replot();
+}

src/barplot.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 BARPLOT_H
 #define BARPLOT_H
 #include <qwt_plot.h>
 #include "channelmanager.h"
 #include "barchart.h"
 class BarPlot : public QwtPlot
+{
     Q_OBJECT
 public:
     explicit BarPlot(ChannelManager* channelMan, QWidget* parent = 0);
 private:
     ChannelManager* _channelMan;
     BarChart barChart;
     QVector<double> chartData() const;
 public slots:
     void darkBackground(bool enabled);
 private slots:
     void update();
 };
 #endif // BARPLOT_H

src/mainwindow.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 "mainwindow.h"
 #include "ui_mainwindow.h"
 #include <QByteArray>
 #include <QApplication>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QFile>
 #include <QTextStream>
 #include <QMenu>
 #include <QDesktopServices>
 #include <QMap>
 #include <QtDebug>
 #include <qwt_plot.h>
 #include <limits.h>
 #include <cmath>
 #include <iostream>
 #include <plot.h>
 #include "framebufferseries.h"
 #include "utils.h"
 #include "defines.h"
 #include "version.h"
 #include "setting_defines.h"
 #if defined(Q_OS_WIN) && defined(QT_STATIC)
 #include <QtPlugin>
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)
 #endif
 const QMap<int, QString> panelSettingMap({
         {0, "Port"},
         {1, "DataFormat"},
         {2, "Plot"},
         {3, "Commands"}
     });
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::MainWindow),
     aboutDialog(this),
     portControl(&serialPort),
     channelMan(1, 1, this),
     barPlot(&channelMan),
     snapshotMan(this, &channelMan),
     commandPanel(&serialPort),
     dataFormatPanel(&serialPort, &channelMan, &recorder),
     recordPanel(&recorder, &channelMan),
     updateCheckDialog(this)
+{
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());
+    plotMan = new PlotManager(ui->plotArea, ui->splitter, &channelMan, 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
@@ @@ -172,194 +171,192 @@ MainWindow::MainWindow(QWidget *parent) @@
     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();
             });
     ui->splitter->addWidget(&barPlot);
+}
 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;
+        }
+    }
     QMainWindow::closeEvent(event);
+}
 void MainWindow::setupAboutDialog()
+{
     Ui_AboutDialog uiAboutDialog;
     uiAboutDialog.setupUi(&aboutDialog);
     QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,
                      [](){ QApplication::aboutQt();});
     QString aboutText = uiAboutDialog.lbAbout->text();
     aboutText.replace("$VERSION_STRING$", VERSION_STRING);
     aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);
     uiAboutDialog.lbAbout->setText(aboutText);
+}
 void MainWindow::onPortToggled(bool open)
+{
     // make sure demo mode is disabled
     if (open && isDemoRunning()) enableDemo(false);
     ui->actionDemoMode->setEnabled(!open);
+}
 void MainWindow::onPortError(QSerialPort::SerialPortError error)
+{
     switch(error)
+    {
         case QSerialPort::NoError :
             break;
         case QSerialPort::ResourceError :

src/mainwindow.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 MAINWINDOW_H
 #define MAINWINDOW_H
 #include <QMainWindow>
 #include <QButtonGroup>
 #include <QLabel>
 #include <QString>
 #include <QVector>
 #include <QList>
 #include <QSerialPort>
 #include <QSignalMapper>
 #include <QTimer>
 #include <QColor>
 #include <QtGlobal>
 #include <QSettings>
 #include <qwt_plot_curve.h>
 #include "portcontrol.h"
 #include "commandpanel.h"
 #include "dataformatpanel.h"
 #include "plotcontrolpanel.h"
 #include "recordpanel.h"
 #include "ui_about_dialog.h"
 #include "framebuffer.h"
 #include "channelmanager.h"
 #include "snapshotmanager.h"
 #include "plotmanager.h"
 #include "barplot.h"
 #include "datarecorder.h"
 #include "updatecheckdialog.h"
 namespace Ui {
 class MainWindow;
+}
 class MainWindow : public QMainWindow
+{
     Q_OBJECT
 public:
     explicit MainWindow(QWidget *parent = 0);
     ~MainWindow();
     PlotViewSettings viewSettings() const;
     void messageHandler(QtMsgType type, const QMessageLogContext &context,
                         const QString &msg);
 private:
     Ui::MainWindow *ui;
     QDialog aboutDialog;
     void setupAboutDialog();
     QSerialPort serialPort;
     PortControl portControl;
     unsigned int numOfSamples;
     QList<QwtPlotCurve*> curves;
     ChannelManager channelMan;
     PlotManager* plotMan;
     BarPlot barPlot;
     SnapshotManager snapshotMan;
     DataRecorder recorder;       // operated by `recordPanel`
     QLabel spsLabel;
     CommandPanel commandPanel;
     DataFormatPanel dataFormatPanel;
     RecordPanel recordPanel;
     PlotControlPanel plotControlPanel;
     UpdateCheckDialog updateCheckDialog;
     bool isDemoRunning();
     /// Stores settings for all modules
     void saveAllSettings(QSettings* settings);
     /// Load settings for all modules
     void loadAllSettings(QSettings* settings);
     /// Stores main window settings into a `QSettings`
     void saveMWSettings(QSettings* settings);
     /// Loads main window settings from a `QSettings`
     void loadMWSettings(QSettings* settings);
     /// `QWidget::closeEvent` handler
     void closeEvent(QCloseEvent * event);
 private slots:
     void onPortToggled(bool open);
     void onPortError(QSerialPort::SerialPortError error);
     void onNumOfSamplesChanged(int value);
     void onNumOfChannelsChanged(unsigned value);
     void clearPlot();
     void onSpsChanged(unsigned sps);
     void enableDemo(bool enabled);
     void onExportCsv();
     void onSaveSettings();
     void onLoadSettings();
 };
 #endif // MAINWINDOW_H

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) :
 PlotManager::PlotManager(
     QWidget* plotArea, QSplitter* splitter, ChannelManager* channelMan,
     ChannelInfoModel* infoModel, QObject *parent) :
     QObject(parent),
     _plotArea(plotArea),
     _splitter(splitter),
     showGridAction("&Grid", this),
     showMinorGridAction("&Minor Grid", this),
     unzoomAction("&Unzoom", this),
     darkBackgroundAction("&Dark Background", this),
     showLegendAction("&Legend", this),
     showMultiAction("Multi &Plot", this),
     showBarPlotAction("&Bar Plot", this),
     setSymbolsAction("Symbols", this)
+{
     _autoScaled = true;
     _yMin = 0;
     _yMax = 1;
     _xAxisAsIndex = true;
     isDemoShown = false;
     _channelMan = channelMan;
     _infoModel = infoModel;
     _numOfSamples = 1;
     _plotWidth = 1;
     showSymbols = Plot::ShowSymbolsAuto;
     emptyPlot = NULL;
     barPlot = 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");
     showBarPlotAction.setToolTip("Show bar plot");
     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);
     showBarPlotAction.setCheckable(true);
     showGridAction.setChecked(false);
     showMinorGridAction.setChecked(false);
     darkBackgroundAction.setChecked(false);
     showLegendAction.setChecked(true);
     showMultiAction.setChecked(false);
     showBarPlotAction.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(&showBarPlotAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showBarPlot);
     // 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
                 });
+    }
+}
 PlotManager::~PlotManager()
+{
     while (curves.size())
+    {
         delete curves.takeLast();
+    }
     // remove all widgets
     while (plotWidgets.size())
+    {
         delete plotWidgets.takeLast();
+    }
     if (scrollArea != NULL) delete scrollArea;
     if (emptyPlot != NULL) delete emptyPlot;
+}
 void PlotManager::onChannelInfoChanged(const QModelIndex &topLeft,
                                        const QModelIndex &bottomRight,
                                        const QVector<int> &roles)
+{
     int start = topLeft.row();
     int end = bottomRight.row();
     for (int ci = start; ci <= end; ci++)
+    {
         QString name = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::EditRole).toString();
         QColor color = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::ForegroundRole).value<QColor>();
         bool visible = topLeft.sibling(ci, ChannelInfoModel::COLUMN_VISIBILITY).data(Qt::CheckStateRole).toBool();
         curves[ci]->setTitle(name);
         curves[ci]->setPen(color);
         curves[ci]->setVisible(visible);
         curves[ci]->setItemAttribute(QwtPlotItem::Legend, visible);
         // replot only updated widgets
         if (isMulti)
+        {
             plotWidgets[ci]->updateSymbols(); // required for color change
             plotWidgets[ci]->updateLegend(curves[ci]);
             plotWidgets[ci]->setVisible(visible);
             if (visible)
+            {
                 plotWidgets[ci]->replot();
+            }
+        }
+    }
     checkNoVisChannels();
     // replot single widget
     if (!isMulti)
+    {
         plotWidgets[0]->updateSymbols();
         plotWidgets[0]->updateLegend();
         replot();
+    }
+}
 void PlotManager::checkNoVisChannels()
+{
     // if all channels are hidden show indicator
     bool allhidden = std::none_of(curves.cbegin(), curves.cend(),
                                   [](QwtPlotCurve* c) {return c->isVisible();});
     plotWidgets[0]->showNoChannel(allhidden);
     if (isMulti)
+    {
         plotWidgets[0]->showNoChannel(allhidden);
         plotWidgets[0]->setVisible(true);
+    }
+}
 void PlotManager::setMulti(bool enabled)
+{
     if (enabled == isMulti) return;
     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::showBarPlot(bool show)
+{
     // A secondary plot can only be shown if splitter is provided.
     Q_ASSERT(_splitter != NULL);
     if (show)
+    {
         Q_ASSERT(barPlot == NULL);
         barPlot = new BarPlot(_channelMan, _splitter);
+    }
     else
+    {
         Q_ASSERT(barPlot != NULL);
         delete barPlot;
         barPlot = NULL;
+    }
+}
 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)
+    {
         plot->replot();
+    }
+}
 QList<QAction*> PlotManager::menuActions()
+{
     QList<QAction*> actions;
     actions << &showGridAction;
     actions << &showMinorGridAction;
     actions << &unzoomAction;
     actions << &darkBackgroundAction;
     actions << &showLegendAction;
     actions << &showMultiAction;
     actions << &showBarPlotAction;
     actions << &setSymbolsAction;
     return actions;
+}
 void PlotManager::showGrid(bool show)
+{
     for (auto plot : plotWidgets)
+    {
         plot->showGrid(show);
+    }
+}
 void PlotManager::showMinorGrid(bool show)
+{
     for (auto plot : plotWidgets)
+    {
         plot->showMinorGrid(show);
+    }
+}
 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);
+    }
     if (barPlot != NULL) barPlot->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);

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 <QSplitter>
 #include <qwt_plot_curve.h>
 #include "plot.h"
 #include "barplot.h"
 #include "framebufferseries.h"
 #include "channelmanager.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);
     explicit PlotManager(
         QWidget* plotArea, QSplitter* splitter = NULL,
         ChannelManager* channelMan = NULL, 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;
     BarPlot* barPlot;
     QSplitter* _splitter;
     QVBoxLayout* layout; ///< layout of the `plotArea`
     QScrollArea* scrollArea;
     QList<QwtPlotCurve*> curves;
     QList<Plot*> plotWidgets;
     Plot* emptyPlot;  ///< for displaying when all channels are hidden
     ChannelManager* _channelMan;
     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 showBarPlotAction;
     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);
     /// Enable/Disable multiple plot display
     void setMulti(bool enabled);
     /// Display/Hide bar plot
     void showBarPlot(bool show = true);
     void onChannelInfoChanged(const QModelIndex & topLeft,
                               const QModelIndex & bottomRight,
                               const QVector<int> & roles = QVector<int> ());
 };
 #endif // PLOTMANAGER_H

src/snapshotview.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 "snapshotview.h"
 #include "ui_snapshotview.h"
 SnapshotView::SnapshotView(MainWindow* parent, Snapshot* snapshot) :
     QMainWindow(parent),
     ui(new Ui::SnapshotView),
     renameDialog(this)
+{
     _snapshot = snapshot;
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea, snapshot->infoModel(), this);
+    plotMan = new PlotManager(ui->plotArea, NULL, NULL, snapshot->infoModel(), this);
     plotMan->setViewSettings(parent->viewSettings());
     ui->menuSnapshot->insertAction(ui->actionClose, snapshot->deleteAction());
     this->setWindowTitle(snapshot->displayName());
     // initialize curves
     unsigned numOfChannels = snapshot->data.size();
     unsigned numOfSamples = snapshot->data[0].size();
     for (unsigned ci = 0; ci < numOfChannels; ci++)
+    {
         plotMan->addCurve(snapshot->channelName(ci), snapshot->data[ci]);
+    }
     plotMan->setNumOfSamples(numOfSamples);
     plotMan->setPlotWidth(numOfSamples);
     renameDialog.setWindowTitle("Rename Snapshot");
     renameDialog.setLabelText("Enter new name:");
     connect(ui->actionRename, &QAction::triggered,
             this, &SnapshotView::showRenameDialog);
     connect(ui->actionSave, &QAction::triggered,
             this, &SnapshotView::save);
     // add 'View' menu items
     for (auto a : plotMan->menuActions())
+    {
         ui->menuView->addAction(a);
+    }
+}
 SnapshotView::~SnapshotView()
+{
     for (auto curve : curves)
+    {
         delete curve;
+    }
     delete plotMan;
     delete ui;
+}
 void SnapshotView::closeEvent(QCloseEvent *event)
+{
     QMainWindow::closeEvent(event);
     emit closed();
+}
 void SnapshotView::showRenameDialog()
+{
     renameDialog.setTextValue(_snapshot->name());
     renameDialog.open(this, SLOT(renameSnapshot(QString)));
+}
 void SnapshotView::renameSnapshot(QString name)
+{
     _snapshot->setName(name);
     setWindowTitle(_snapshot->displayName());
+}
 void SnapshotView::save()
+{
     QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));
     if (fileName.isNull()) return; // user canceled
     _snapshot->save(fileName);
     setWindowTitle(_snapshot->displayName());
+}

0 comments (0 inline, 0 general)