tempo-plotter Changeset - 840ec925ba83 · protofusion repositories

Changeset - 840ec925ba83

Parent rev.

Child rev.

[Not reviewed]

channelmanager

0 4 0

Hasan Yavuz ÖZDERYA - 9 years ago 2017-01-30 04:05:29
hy@ozderya.net

api for simpler access to channel info

4 files changed with 21 insertions and 4 deletions:

src/channelinfomodel.cpp

src/channelinfomodel.h

src/plotmanager.cpp

src/snapshot.cpp

0 comments (0 inline, 0 general)

src/channelinfomodel.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 "channelinfomodel.h"
 #include "setting_defines.h"
 #define NUMOF_COLORS  (32)
 const QColor colors[NUMOF_COLORS] =
+{
     QColor("#ff0056"),
     QColor("#7e2dd2"),
     QColor("#00ae7e"),
     QColor("#fe8900"),
     QColor("#ff937e"),
     QColor("#6a826c"),
     QColor("#ff029d"),
     QColor("#00b917"),
     QColor("#7a4782"),
     QColor("#85a900"),
     QColor("#a42400"),
     QColor("#683d3b"),
     QColor("#bdc6ff"),
     QColor("#263400"),
     QColor("#bdd393"),
     QColor("#d5ff00"),
     QColor("#9e008e"),
     QColor("#001544"),
     QColor("#c28c9f"),
     QColor("#ff74a3"),
     QColor("#01d0ff"),
     QColor("#004754"),
     QColor("#e56ffe"),
     QColor("#788231"),
     QColor("#0e4ca1"),
     QColor("#91d0cb"),
     QColor("#be9970"),
     QColor("#968ae8"),
     QColor("#bb8800"),
     QColor("#43002c"),
     QColor("#deff74"),
     QColor("#00ffc6")
 };
 ChannelInfoModel::ChannelInfoModel(unsigned numberOfChannels, QObject* parent) :
     QAbstractTableModel(parent)
+{
     _numOfChannels = 0;
     setNumOfChannels(numberOfChannels);
+}
 ChannelInfoModel::ChannelInfoModel(const ChannelInfoModel& other) :
     ChannelInfoModel(other.rowCount(), other.parent())
+{
     for (int i = 0; i < other.rowCount(); i++)
+    {
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::EditRole),
                 Qt::EditRole);
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::ForegroundRole),
                 Qt::ForegroundRole);
         setData(index(i, COLUMN_VISIBILITY),
                 other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),
                 Qt::CheckStateRole);
+    }
+}
 ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :
     ChannelInfoModel(channelNames.length(), NULL)
+{
     for (int i = 0; i < channelNames.length(); i++)
+    {
         setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);
+    }
+}
 ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)
+{
     name = tr("Channel %1").arg(index + 1);
     visibility = true;
     color = colors[index % NUMOF_COLORS];
+}
 QString ChannelInfoModel::name(unsigned i)
+{
     return infos[i].name;
+}
 QColor ChannelInfoModel::color(unsigned i)
+{
     return infos[i].color;
+}
 bool ChannelInfoModel::isVisible(unsigned i)
+{
     return infos[i].visibility;
+}
 int ChannelInfoModel::rowCount(const QModelIndex &parent) const
+{
     return _numOfChannels;
+}
 int ChannelInfoModel::columnCount(const QModelIndex & parent) const
+{
     return COLUMN_COUNT;
+}
 Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const
+{
     if (index.column() == COLUMN_NAME)
+    {
         return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     return Qt::NoItemFlags;
+}
 QVariant ChannelInfoModel::data(const QModelIndex &index, int role) const
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return QVariant();
+    }
     // get color
     if (role == Qt::ForegroundRole)
+    {
         return infos[index.row()].color;
+    }
     // get name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(infos[index.row()].name);
+        }
     } // get visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool visible = infos[index.row()].visibility;
             return visible ? Qt::Checked : Qt::Unchecked;
+        }
+    }
     return QVariant();
+}
 QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
     if (orientation == Qt::Horizontal)
+    {
         if (role == Qt::DisplayRole)
+        {
             if (section == COLUMN_NAME)
+            {
                 return tr("Channel");
+            }
             else if (section == COLUMN_VISIBILITY)
+            {
                 return tr("Visible");
+            }
+        }
+    }
     else                        // vertical
+    {
         if (section < (int) _numOfChannels && role == Qt::DisplayRole)
+        {
             return QString::number(section + 1);
+        }
+    }
     return QVariant();
+}
 bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return false;
+    }
     // set color
     if (role == Qt::ForegroundRole)
+    {
         infos[index.row()].color = value.value<QColor>();
         emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));
         return true;
+    }
     // set name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             infos[index.row()].name = value.toString();
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
     } // set visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             infos[index.row()].visibility = checked;
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
+    }
     // invalid index/role
     return false;
+}
 void ChannelInfoModel::setNumOfChannels(unsigned number)
+{
     if (number == _numOfChannels) return;
     bool isInserting = number > _numOfChannels;
     if (isInserting)
+    {
         beginInsertRows(QModelIndex(), _numOfChannels, number-1);
+    }
     else
+    {
         beginRemoveRows(QModelIndex(), number, _numOfChannels-1);
+    }
     // we create channel info but never remove channel info to
     // remember user entered info
     if ((int) number > infos.length())
+    {
         for (unsigned ci = _numOfChannels; ci < number; ci++)
+        {
             infos.append(ChannelInfo(ci));
+        }
+    }
     // make sure newly available channels are visible, we don't
     // remember visibility option intentionally so that user doesn't
     // get confused
     if (number > _numOfChannels)
+    {
         for (unsigned ci = _numOfChannels; ci < number; ci++)
+        {
             infos[ci].visibility = true;
+        }
+    }
     _numOfChannels = number;
     if (isInserting)
+    {
         endInsertRows();
+    }
     else
+    {
         endRemoveRows();
+    }
+}
 void ChannelInfoModel::resetInfos()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci] = ChannelInfo(ci);
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetNames()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].name = ChannelInfo(ci).name;
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetColors()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].color = ChannelInfo(ci).color;
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetVisibility()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].visibility = true;
+    }
     endResetModel();
+}
 void ChannelInfoModel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     settings->beginWriteArray(SG_Channels_Channel);
     // save all channel information regardless of current number of channels
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         settings->setArrayIndex(ci);
         settings->setValue(SG_Channels_Name, infos[ci].name);
         settings->setValue(SG_Channels_Color, infos[ci].color);
         settings->setValue(SG_Channels_Visible, infos[ci].visibility);
+    }
     settings->endArray();
     settings->endGroup();
+}
 void ChannelInfoModel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     unsigned size = settings->beginReadArray(SG_Channels_Channel);
     for (unsigned ci = 0; ci < size; ci++)
+    {
         settings->setArrayIndex(ci);
         ChannelInfo chanInfo(ci);
         chanInfo.name       = settings->value(SG_Channels_Name, chanInfo.name).toString();
         chanInfo.color      = settings->value(SG_Channels_Color, chanInfo.color).value<QColor>();
         chanInfo.visibility = settings->value(SG_Channels_Visible, true).toBool();
         if ((int) ci < infos.size())
+        {
             infos[ci] = chanInfo;
             if (ci < _numOfChannels)
+            {
                 auto roles = QVector<int>({
                     Qt::DisplayRole, Qt::EditRole, Qt::ForegroundRole, Qt::CheckStateRole});
                 emit dataChanged(index(ci, 0), index(ci, COLUMN_COUNT-1), roles);
+            }
+        }
         else
+        {
             infos.append(chanInfo);
+        }
+    }
     settings->endArray();
     settings->endGroup();
+}

src/channelinfomodel.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 CHANNELINFOMODEL_H
 #define CHANNELINFOMODEL_H
 #include <QAbstractTableModel>
 #include <QColor>
 #include <QSettings>
 #include <QStringList>
 class ChannelInfoModel : public QAbstractTableModel
+{
     Q_OBJECT
 public:
     enum ChannelInfoColumn
+    {
         COLUMN_NAME = 0,
         COLUMN_VISIBILITY,
         COLUMN_COUNT
     };
     explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);
     ChannelInfoModel(const ChannelInfoModel& other);
     explicit ChannelInfoModel(const QStringList& channelNames);
     QString name     (unsigned i);
     QColor  color    (unsigned i);
     bool    isVisible(unsigned i);
     // implemented from QAbstractItemModel
     int           rowCount(const QModelIndex &parent = QModelIndex()) const;
     int           columnCount(const QModelIndex &parent = QModelIndex()) const;
     QVariant      data(const QModelIndex &index, int role = Qt::DisplayRole) const;
     bool          setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
     Qt::ItemFlags flags(const QModelIndex &index) const;
     QVariant      headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
     void setNumOfChannels(unsigned number);
     /// Stores all channel info into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads all channel info from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     /// reset all channel info (names, color etc.)
     void resetInfos();
     /// reset all channel names
     void resetNames();
     /// reset all channel colors
     void resetColors();
     /// reset visibility
     void resetVisibility();
 private:
     struct ChannelInfo
+    {
         explicit ChannelInfo(unsigned index);
         QString name;
         bool visibility;
         QColor color;
     };
     unsigned _numOfChannels;     ///< @note this is not necessarily the length of `infos`
     /**
      * Channel info is added here but never removed so that we can
      * remember user entered info (names, colors etc.).
      */
     QList<ChannelInfo> infos;
 };
 #endif // CHANNELINFOMODEL_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 <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)
+{
     _autoScaled = true;
     _yMin = 0;
     _yMax = 1;
     isDemoShown = false;
     _infoModel = infoModel;
     // 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");
     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);
     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
                 });
+    }
+}
 PlotManager::~PlotManager()
+{
     while (curves.size())
+    {
         delete curves.takeLast();
+    }
     // remove all widgets
     while (plotWidgets.size())
+    {
         delete plotWidgets.takeLast();
+    }
     if (scrollArea != NULL) delete scrollArea;
+}
 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();
+            }
+        }
+    }
     // replot single widget
     if (!isMulti)
+    {
         plotWidgets[0]->updateSymbols();
         plotWidgets[0]->updateLegend();
         replot();
+    }
+}
 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)
+        {
             curve->attach(addPlotWidget());
+        }
+    }
     else
+    {
         // add a single widget
         auto plot = addPlotWidget();
         // attach all curves
         for (auto curve : curves)
+        {
             curve->attach(plot);
+        }
+    }
+}
 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->setAxis(_autoScaled, _yMin, _yMax);
     return plot;
+}
 void PlotManager::addCurve(QString title, FrameBuffer* buffer)
+{
     auto curve = new QwtPlotCurve(title);
     curve->setSamples(new FrameBufferSeries(buffer));
     _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->index(index, ChannelInfoModel::COLUMN_NAME)\
         .data(Qt::ForegroundRole).value<QColor>();
     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;
     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);
+    }
+}
 void PlotManager::setAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+{
     _autoScaled = autoScaled;
     _yMin = yAxisMin;
     _yMax = yAxisMax;
     for (auto plot : plotWidgets)
+    {
         plot->setAxis(autoScaled, yAxisMin, yAxisMax);
+    }
+}
 void PlotManager::flashSnapshotOverlay()
+{
     for (auto plot : plotWidgets)
+    {
         plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());
+    }
+}
 void PlotManager::onNumOfSamplesChanged(unsigned value)
+{
     for (auto plot : plotWidgets)
+    {
         plot->onNumOfSamplesChanged(value);
+    }
+}
 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());
     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());
     settings->endGroup();
+}

src/snapshot.cpp

➞

Show inline comments

 /*
   Copyright © 2015 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 <stddef.h>
 #include <QSaveFile>
 #include <QTextStream>
 #include "snapshot.h"
 #include "snapshotview.h"
 Snapshot::Snapshot(QMainWindow* parent, QString name, ChannelInfoModel infoModel) :
     QObject(parent),
     cInfoModel(infoModel),
     _showAction(this),
     _deleteAction("&Delete", this)
+{
     _name = name;
     _saved = false;
     view = NULL;
     mainWindow = parent;
     _showAction.setText(displayName());
     connect(&_showAction, &QAction::triggered, this, &Snapshot::show);
     _deleteAction.setToolTip(QString("Delete ") + _name);
     connect(&_deleteAction, &QAction::triggered, this, &Snapshot::onDeleteTriggered);
+}
 Snapshot::~Snapshot()
+{
     if (view != NULL)
+    {
         delete view;
+    }
+}
 QAction* Snapshot::showAction()
+{
     return &_showAction;
+}
 QAction* Snapshot::deleteAction()
+{
     return &_deleteAction;
+}
 void Snapshot::show()
+{
     if (view == NULL)
+    {
         view = new SnapshotView(mainWindow, this);
         connect(view, &SnapshotView::closed, this, &Snapshot::viewClosed);
+    }
     view->show();
     view->activateWindow();
     view->raise();
+}
 void Snapshot::viewClosed()
+{
     view->deleteLater();
     view = NULL;
+}
 void Snapshot::onDeleteTriggered()
+{
     emit deleteRequested(this);
+}
 QString Snapshot::name()
+{
     return _name;
+}
 QString Snapshot::displayName()
+{
     if (_saved)
+    {
         return name();
+    }
     else
+    {
         return name() + "*";
+    }
+}
 void Snapshot::setName(QString name)
+{
     _name = name;
     _showAction.setText(_name);
     emit nameChanged(this);
+}
 ChannelInfoModel* Snapshot::infoModel()
+{
     return &cInfoModel;
+}
 QString Snapshot::channelName(unsigned channel)
+{
     return cInfoModel.data(cInfoModel.index(channel, ChannelInfoModel::COLUMN_NAME),
                            Qt::DisplayRole).toString();
     return cInfoModel.name(channel);
+}
 void Snapshot::save(QString fileName)
+{
     // TODO: remove code duplication (MainWindow::onExportCsv)
     QSaveFile file(fileName);
     if (file.open(QIODevice::WriteOnly | QIODevice::Text))
+    {
         QTextStream fileStream(&file);
         unsigned numOfChannels = data.size();
         unsigned numOfSamples = data[0].size();
         // print header
         for (unsigned int ci = 0; ci < numOfChannels; ci++)
+        {
             fileStream << channelName(ci);
             if (ci != numOfChannels-1) fileStream << ",";
+        }
         fileStream << '\n';
         // print rows
         for (unsigned int i = 0; i < numOfSamples; i++)
+        {
             for (unsigned int ci = 0; ci < numOfChannels; ci++)
+            {
                 fileStream << data[ci][i].y();
                 if (ci != numOfChannels-1) fileStream << ",";
+            }
             fileStream << '\n';
+        }
         if (!file.commit())
+        {
             qCritical() << "File save error during snapshot save: " << file.error();
+        }
         else
+        {
             _saved = true;
             _showAction.setText(displayName());
+        }
+    }
     else
+    {
         qCritical() << "File open error during snapshot save: " << file.error();
+    }
+}
 bool Snapshot::isSaved()
+{
     return _saved;
+}

0 comments (0 inline, 0 general)