tempo-plotter Changeset - c3194fb3b7ea · protofusion repositories

Changeset - c3194fb3b7ea

Parent rev.

Child rev.

[Not reviewed]

Merge default

0 11 0

Hasan Yavuz ÖZDERYA - 7 years ago 2018-07-22 08:42:42
hy@ozderya.net

Merge with gain-offset

11 files changed with 359 insertions and 53 deletions:

src/channelinfomodel.cpp

184

src/channelinfomodel.h

src/plotcontrolpanel.cpp

src/plotcontrolpanel.h

src/plotcontrolpanel.ui

src/samplepack.cpp

src/samplepack.h

src/setting_defines.h

src/stream.cpp

src/stream.h

tests/test.cpp

0 comments (0 inline, 0 general)

src/channelinfomodel.cpp

➞

Show inline comments

@@ @@ -47,344 +47,508 @@ const QColor colors[NUMOF_COLORS] = @@
     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())
+{
     // TODO: why not set (copy) info list directly instead?
     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);
         setData(index(i, COLUMN_GAIN),
                 other.data(other.index(i, COLUMN_GAIN), Qt::CheckStateRole),
                 Qt::CheckStateRole);
         setData(index(i, COLUMN_GAIN),
                 other.data(other.index(i, COLUMN_GAIN), Qt::EditRole),
                 Qt::EditRole);
         setData(index(i, COLUMN_OFFSET),
                 other.data(other.index(i, COLUMN_OFFSET), Qt::CheckStateRole),
                 Qt::CheckStateRole);
         setData(index(i, COLUMN_OFFSET),
                 other.data(other.index(i, COLUMN_OFFSET), Qt::EditRole),
                 Qt::EditRole);
+    }
+}
 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];
     gain = 1.0;
     offset = 0.0;
     gainEn = false;
     offsetEn = false;
+}
 QString ChannelInfoModel::name(unsigned i) const
+{
     return infos[i].name;
+}
 QColor ChannelInfoModel::color(unsigned i) const
+{
     return infos[i].color;
+}
 bool ChannelInfoModel::isVisible(unsigned i) const
+{
     return infos[i].visibility;
+}
 bool ChannelInfoModel::gainEn (unsigned i) const
+{
     return infos[i].gainEn;
+}
 double ChannelInfoModel::gain (unsigned i) const
+{
     return infos[i].gain;
+}
 bool ChannelInfoModel::offsetEn (unsigned i) const
+{
     return infos[i].offsetEn;
+}
 double ChannelInfoModel::offset (unsigned i) const
+{
     return infos[i].offset;
+}
 QStringList ChannelInfoModel::channelNames() const
+{
     QStringList r;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         r << name(ci);
+    }
     return r;
+}
 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;
+    }
     else if (index.column() == COLUMN_GAIN || index.column() == COLUMN_OFFSET)
+    {
         return Qt::ItemIsEditable | 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();
+    }
     auto &info = infos[index.row()];
     // get color
     if (role == Qt::ForegroundRole)
+    {
-        return infos[index.row()].color;
+        return info.color;
+    }
-    // get name
     // name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
-            return QVariant(infos[index.row()].name);
+            return QVariant(info.name);
+        }
-    } // get visibility
     } // visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
-            bool visible = infos[index.row()].visibility;
+            bool visible = info.visibility;
             return visible ? Qt::Checked : Qt::Unchecked;
+        }
     } // gain
     else if (index.column() == COLUMN_GAIN)
+    {
         if (role == Qt::CheckStateRole)
+        {
             return info.gainEn ? Qt::Checked : Qt::Unchecked;
+        }
         else if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(info.gain);
+        }
     } // offset
     else if (index.column() == COLUMN_OFFSET)
+    {
         if (role == Qt::CheckStateRole)
+        {
             return info.offsetEn ? Qt::Checked : Qt::Unchecked;
+        }
         else if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(info.offset);
+        }
+    }
     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 if (section == COLUMN_GAIN)
+            {
                 return tr("Gain");
+            }
             else if (section == COLUMN_OFFSET)
+            {
                 return tr("Offset");
+            }
+        }
+    }
     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;
+    }
     auto &info = infos[index.row()];
     // set color
     if (role == Qt::ForegroundRole)
+    {
-        infos[index.row()].color = value.value<QColor>();
+        info.color = value.value<QColor>();
         emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));
         return true;
+    }
     // set name
     bool r = false;
     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;
             info.name = value.toString();
             r = 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;
             info.visibility = checked;
             r = true;
+        }
+    }
     else if (index.column() == COLUMN_GAIN)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             info.gain = value.toDouble();
             r = true;
+        }
         else if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             info.gainEn = checked;
             if (_gainOrOffsetEn != checked) updateGainOrOffsetEn();
             r = true;
+        }
+    }
     else if (index.column() == COLUMN_OFFSET)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             info.offset = value.toDouble();
             r = true;
+        }
         else if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             info.offsetEn = checked;
             if (_gainOrOffsetEn != checked) updateGainOrOffsetEn();
             r = true;
+        }
+    }
     // invalid index/role
     return false;
     if (r)
+    {
         emit dataChanged(index, index, QVector<int>({role}));
+    }
     return r;
+}
 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 = infos.length(); 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;
     updateGainOrOffsetEn();
     if (isInserting)
+    {
         endInsertRows();
+    }
     else
+    {
         endRemoveRows();
+    }
+}
 void ChannelInfoModel::resetInfos()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci] = ChannelInfo(ci);
+    }
     endResetModel();
+}
 // TODO: fix repetitive code, ChannelInfoModel::reset* functions
 void ChannelInfoModel::resetNames()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         // TODO: do not create a full object every time (applies to other reset methods as well)
         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(bool visible)
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].visibility = visible;
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetGains()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].gain = ChannelInfo(ci).gain;
         infos[ci].gainEn = ChannelInfo(ci).gainEn;
+    }
     updateGainOrOffsetEn();
     endResetModel();
+}
 void ChannelInfoModel::resetOffsets()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].offset = ChannelInfo(ci).offset;
         infos[ci].offsetEn = ChannelInfo(ci).offsetEn;
+    }
     updateGainOrOffsetEn();
     endResetModel();
+}
 bool ChannelInfoModel::gainOrOffsetEn() const
+{
     return _gainOrOffsetEn;
+}
 void ChannelInfoModel::updateGainOrOffsetEn()
+{
     _gainOrOffsetEn = false;
     for (int ci = 0; ci < _numOfChannels; ci++)
+    {
         auto& info = infos[ci];
         _gainOrOffsetEn |= (info.gainEn || info.offsetEn);
+    }
+}
 void ChannelInfoModel::saveSettings(QSettings* settings) const
+{
     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);
         auto& info = infos[ci];
         settings->setValue(SG_Channels_Name, info.name);
         settings->setValue(SG_Channels_Color, info.color);
         settings->setValue(SG_Channels_Visible, info.visibility);
         settings->setValue(SG_Channels_Gain, info.gain);
         settings->setValue(SG_Channels_GainEn, info.gainEn);
         settings->setValue(SG_Channels_Offset, info.offset);
         settings->setValue(SG_Channels_OffsetEn, info.offsetEn);
+    }
     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();
         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  , chanInfo.visibility).toBool();
         chanInfo.gain       = settings->value(SG_Channels_Gain     , chanInfo.gain).toDouble();
         chanInfo.gainEn     = settings->value(SG_Channels_GainEn   , chanInfo.gainEn).toBool();
         chanInfo.offset     = settings->value(SG_Channels_Offset   , chanInfo.offset).toDouble();
         chanInfo.offsetEn   = settings->value(SG_Channels_OffsetEn , chanInfo.offsetEn).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);
+        }
+    }
     updateGainOrOffsetEn();
     settings->endArray();
     settings->endGroup();
+}

src/channelinfomodel.h

➞

Show inline comments

@@ @@ -13,81 +13,105 @@ @@
   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
         COLUMN_GAIN,
         COLUMN_OFFSET,
         COLUMN_COUNT            // MUST be last
     };
     explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);
     ChannelInfoModel(const ChannelInfoModel& other);
     explicit ChannelInfoModel(const QStringList& channelNames);
     QString name     (unsigned i) const;
     QColor  color    (unsigned i) const;
     bool    isVisible(unsigned i) const;
     bool    gainEn   (unsigned i) const;
     double  gain     (unsigned i) const;
     bool    offsetEn (unsigned i) const;
     double  offset   (unsigned i) const;
     /// Returns true if any of the channels have gain or offset enabled
     bool gainOrOffsetEn() const;
     /// Returns a list of channel names
     QStringList channelNames() const;
     // 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) const;
     /// 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 all channel gain values and disables gains
     void resetGains();
     /// reset all channel offset values and disables offsets
     void resetOffsets();
     /// reset visibility
     void resetVisibility(bool visible);
 private:
     struct ChannelInfo
+    {
         explicit ChannelInfo(unsigned index);
         QString name;
         bool visibility;
         QColor color;
         double gain, offset;
         bool gainEn, offsetEn;
     };
     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;
     /**
      * Cache for gain and offset enabled variables of channels. If gain and/or
      * offset is not enabled for *any* of the channels this is false otherwise
      * true.
      */
     bool _gainOrOffsetEn;
     /// Updates `_gainOrOffsetEn` by scanning all channel infos.
     void updateGainOrOffsetEn();
 };
 #endif // CHANNELINFOMODEL_H

src/plotcontrolpanel.cpp

➞

Show inline comments

 /*
   Copyright © 2018 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 <QStyledItemDelegate>
 #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 = 1000000;
 /// Precision used for channel info table numbers
 const int DOUBLESP_PRECISION = 6;
 /// Used for scale range selection combobox
 struct Range
+{
     double rmin;
     double rmax;
 };
 Q_DECLARE_METATYPE(Range);
 /// Used for customizing double precision in tables
 class SpinBoxDelegate : public QStyledItemDelegate
+{
 public:
     QWidget* createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                           const QModelIndex &index) const Q_DECL_OVERRIDE
+        {
             auto w = QStyledItemDelegate::createEditor(
                 parent, option, index);
             auto sp = qobject_cast<QDoubleSpinBox*>(w);
             if (sp)
+            {
                 sp->setDecimals(DOUBLESP_PRECISION);
+            }
             return w;
+        }
 };
 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),
     hideAllAct(tr("Hide All"), this),
     resetGainsAct(tr("Reset All Gain"), this),
     resetOffsetsAct(tr("Reset All Offset"), this),
     resetMenu(tr("Reset Menu"), this)
+{
     ui->setupUi(this);
     delegate = new SpinBoxDelegate();
     ui->tvChannelInfo->setItemDelegate(delegate);
     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)),
@@ @@ -122,48 +149,50 @@ PlotControlPanel::PlotControlPanel(QWidg @@
     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 buttons
     resetAct.setToolTip(tr("Reset channel names and colors"));
     resetMenu.addAction(&resetNamesAct);
     resetMenu.addAction(&resetColorsAct);
     resetMenu.addAction(&resetGainsAct);
     resetMenu.addAction(&resetOffsetsAct);
     resetAct.setMenu(&resetMenu);
     ui->tbReset->setDefaultAction(&resetAct);
     showAllAct.setToolTip(tr("Show all channels"));
     hideAllAct.setToolTip(tr("Hide all channels"));
     ui->tbShowAll->setDefaultAction(&showAllAct);
     ui->tbHideAll->setDefaultAction(&hideAllAct);
+}
 PlotControlPanel::~PlotControlPanel()
+{
     delete ui;
+}
 unsigned PlotControlPanel::numOfSamples()
+{
     return ui->spNumOfSamples->value();
+}
 void PlotControlPanel::onNumOfSamples(int value)
+{
     if (warnNumOfSamples && value > NUMSAMPLES_CONFIRM_AT)
+    {
         // ask confirmation
@@ @@ -380,48 +409,50 @@ void PlotControlPanel::setChannelInfoMod @@
                 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(&resetGainsAct, &QAction::triggered, model, &ChannelInfoModel::resetGains);
     connect(&resetOffsetsAct, &QAction::triggered, model, &ChannelInfoModel::resetOffsets);
     connect(&showAllAct, &QAction::triggered, [model]{model->resetVisibility(true);});
     connect(&hideAllAct, &QAction::triggered, [model]{model->resetVisibility(false);});
+}
 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(

src/plotcontrolpanel.h

➞

Show inline comments

@@ @@ -3,87 +3,90 @@ @@
   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 <QStyledItemDelegate>
 #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, hideAllAct;
     QAction resetAct, resetNamesAct, resetColorsAct, showAllAct,
         hideAllAct, resetGainsAct, resetOffsetsAct;
     QMenu resetMenu;
     QStyledItemDelegate* delegate;
     /// 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>704</width>
     <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">
+      <sizepolicy hsizetype="MinimumExpanding" 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">
+         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximumSize">
          <size>
-          <width>300</width>
+          <width>30000</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="spacing">
          <number>3</number>
         </property>
         <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>
@@ @@ -388,53 +388,37 @@ @@
         <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/samplepack.cpp

➞

Show inline comments

 /*
   Copyright © 2018 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 <cstring>
 #include <QtGlobal>
 #include "samplepack.h"
 SamplePack::SamplePack(unsigned ns, unsigned nc, bool x)
+{
     Q_ASSERT(ns > 0 && nc > 0);
     _numSamples = ns;
     _numChannels = nc;
     _yData = new double[_numSamples * _numChannels]();
     if (x)
+    {
         _xData = new double[_numSamples]();
+    }
     else
+    {
         _xData = nullptr;
+    }
+}
 SamplePack::SamplePack(const SamplePack& other) :
     SamplePack(other.numSamples(), other.numChannels(), other.hasX())
+{
     size_t dataSize = sizeof(double) * numSamples();
     if (hasX())
         memcpy(xData(), other.xData(), dataSize);
     memcpy(_yData, other._yData, dataSize * numChannels());
+}
 SamplePack::~SamplePack()
+{
     delete[] _yData;
     if (_xData != nullptr)
+    {
         delete[] _xData;
+    }
+}
 bool SamplePack::hasX() const
+{
     return _xData != nullptr;
+}
 unsigned SamplePack::numChannels() const
+{
     return _numChannels;
+}
 unsigned SamplePack::numSamples() const
+{
     return _numSamples;
+}

src/samplepack.h

➞

Show inline comments

@@ @@ -8,42 +8,43 @@ @@
   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 SAMPLEPACK_H
 #define SAMPLEPACK_H
 class SamplePack
+{
 public:
     /**
      * @param ns number of samples
      * @param nc number of channels
      * @param x has X channel
      */
     SamplePack(unsigned ns, unsigned nc, bool x = false);
     SamplePack(const SamplePack& other);
     ~SamplePack();
     bool hasX() const;
     unsigned numChannels() const;
     unsigned numSamples() const;
     double* xData() const;
     double* data(unsigned channel) const;
     double* xData();
     double* data(unsigned channel);
 private:
     unsigned _numSamples, _numChannels;
     double* _xData;
     double* _yData;
 };
 #endif // SAMPLEPACK_H

src/setting_defines.h

➞

Show inline comments

@@ @@ -50,53 +50,57 @@ const char SG_Port_FlowControl[] = "flow @@
 // 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
+// channel info 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";
 const char SG_Channels_Gain[] = "gain";
 const char SG_Channels_GainEn[] = "gainEnabled";
 const char SG_Channels_Offset[] = "offset";
 const char SG_Channels_OffsetEn[] = "offsetEnabled";
 // 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

src/stream.cpp

➞

Show inline comments

@@ @@ -121,67 +121,115 @@ void Stream::setNumChannels(unsigned nc, @@
             xData = new RingBuffer(_numSamples);
+        }
         else
+        {
             xData = new IndexBuffer(_numSamples);
+        }
         for (auto c : channels)
+        {
             c->setX(xData);
+        }
         _hasx = x;
+    }
     if (nc != oldNum)
+    {
         _infoModel.setNumOfChannels(nc);
         // TODO: how about X change?
         emit numChannelsChanged(nc);
+    }
     Sink::setNumChannels(nc, x);
+}
-void Stream::feedIn(const SamplePack& data)
+const SamplePack* Stream::applyGainOffset(const SamplePack& pack) const
+{
     Q_ASSERT(data.numChannels() == numChannels() &&
              data.hasX() == hasX());
     Q_ASSERT(infoModel()->gainOrOffsetEn());
     SamplePack* mPack = new SamplePack(pack);
     unsigned ns = pack.numSamples();
     for (unsigned ci = 0; ci < numChannels(); ci++)
+    {
         // TODO: we could use some kind of map (int32, int64 would suffice) to speed things up
         bool gainEn = infoModel()->gainEn(ci);
         bool offsetEn = infoModel()->offsetEn(ci);
         if (gainEn || offsetEn)
+        {
             double* mdata = mPack->data(ci);
             double gain = infoModel()->gain(ci);
             double offset = infoModel()->offset(ci);
             if (gainEn)
+            {
                 for (unsigned i = 0; i < ns; i++)
+                {
                     mdata[i] *= gain;
+                }
+            }
             if (offsetEn)
+            {
                 for (unsigned i = 0; i < ns; i++)
+                {
                     mdata[i] += offset;
+                }
+            }
+        }
+    }
     return mPack;
+}
 void Stream::feedIn(const SamplePack& pack)
+{
     Q_ASSERT(pack.numChannels() == numChannels() &&
              pack.hasX() == hasX());
     if (_paused) return;
-    unsigned ns = data.numSamples();
+    unsigned ns = pack.numSamples();
     if (_hasx)
+    {
         static_cast<RingBuffer*>(xData)->addSamples(data.xData(), ns);
+    }
     for (unsigned i = 0; i < numChannels(); i++)
+    {
         static_cast<RingBuffer*>(channels[i]->yData())->addSamples(data.data(i), ns);
         static_cast<RingBuffer*>(xData)->addSamples(pack.xData(), ns);
+    }
     Sink::feedIn(data);
     // modified pack that gain and offset is applied to
     const SamplePack* mPack = nullptr;
     if (infoModel()->gainOrOffsetEn())
         mPack = applyGainOffset(pack);
     for (unsigned ci = 0; ci < numChannels(); ci++)
+    {
         auto buf = static_cast<RingBuffer*>(channels[ci]->yData());
         double* data = (mPack == nullptr) ? pack.data(ci) : mPack->data(ci);
         buf->addSamples(data, ns);
+    }
     Sink::feedIn((mPack == nullptr) ? pack : *mPack);
     if (mPack != nullptr) delete mPack;
     emit dataAdded();
+}
 void Stream::pause(bool paused)
+{
     _paused = paused;
+}
 void Stream::clear()
+{
     for (auto c : channels)
+    {
         static_cast<RingBuffer*>(c->yData())->clear();
+    }
+}
 void Stream::setNumSamples(unsigned value)
+{
     if (value == _numSamples) return;
     _numSamples = value;
     xData->resize(value);
     for (auto c : channels)
+    {

src/stream.h

➞

Show inline comments

@@ @@ -48,57 +48,70 @@ public: @@
      * @param x has X data input
      * @param ns number of samples
      */
     Stream(unsigned nc = 0, bool x = false, unsigned ns = 0);
     ~Stream();
     // implementations for `Source`
     virtual bool hasX() const;
     virtual unsigned numChannels() const;
     unsigned numSamples() const;
     const StreamChannel* channel(unsigned index) const;
     StreamChannel* channel(unsigned index);
     const ChannelInfoModel* infoModel() const;
     ChannelInfoModel* infoModel();
     /// Saves channel information
     void saveSettings(QSettings* settings) const;
     /// Load channel information
     void loadSettings(QSettings* settings);
 protected:
     // implementations for `Sink`
     virtual void setNumChannels(unsigned nc, bool x);
-    virtual void feedIn(const SamplePack& data);
+    virtual void feedIn(const SamplePack& pack);
 signals:
     void numChannelsChanged(unsigned value);
     void numSamplesChanged(unsigned value);
     void channelAdded(const StreamChannel* chan);
     void channelNameChanged(unsigned channel, QString name); // TODO: does it stay?
     void dataAdded(); ///< emitted when data added to channel man.
 public slots:
     // TODO: these won't be public
     // void setNumChannels(unsigned number);
     void setNumSamples(unsigned value);
     /// When paused data feed is ignored
     void pause(bool paused);
     /// Clears buffer data (fills with 0)
     void clear();
 private:
     unsigned _numSamples;
     bool _paused;
     bool _hasx;
     ResizableBuffer* xData;
     QList<StreamChannel*> channels;
     ChannelInfoModel _infoModel;
     /**
      * Applies gain and offset to given pack.
+     *
      * Caller is responsible for deleting returned `SamplePack`.
+     *
      * @note Should be called only when gain or offset is enabled. Guard with
      * `ChannelInfoModel::gainOrOffsetEn()`.
+     *
      * @param pack input data
      * @return modified data
      */
     const SamplePack* applyGainOffset(const SamplePack& pack) const;
 };
 #endif // STREAM_H

tests/test.cpp

➞

Show inline comments

@@ @@ -34,48 +34,72 @@ TEST_CASE("samplepack with no X", "[memo @@
     SamplePack pack(100, 3, false);
     REQUIRE_FALSE(pack.hasX());
     REQUIRE(pack.numChannels() == 3);
     REQUIRE(pack.numSamples() == 100);
     double* chan0 = pack.data(0);
     double* chan1 = pack.data(1);
     double* chan2 = pack.data(2);
     REQUIRE(chan0 == chan1 - 100);
     REQUIRE(chan1 == chan2 - 100);
+}
 TEST_CASE("samplepack with X", "[memory]")
+{
     SamplePack pack(100, 3, true);
     REQUIRE(pack.hasX());
     REQUIRE(pack.numChannels() == 3);
     REQUIRE(pack.numSamples() == 100);
     REQUIRE(pack.xData() != nullptr);
+}
 TEST_CASE("samplepack copy", "[memory]")
+{
     SamplePack pack(10, 3, true);
     // fill test data
     for (int i = 0; i < 10; i++)
+    {
         pack.xData()[i] = i;
         pack.data(0)[i] = i+5;
         pack.data(1)[i] = i*2;
         pack.data(2)[i] = i*3;
+    }
     SamplePack other = pack;
     // compare
     for (int i = 0; i < 10; i++)
+    {
         REQUIRE(other.xData()[i] == i);
         REQUIRE(other.data(0)[i] == i+5);
         REQUIRE(other.data(1)[i] == i*2);
         REQUIRE(other.data(2)[i] == i*3);
+    }
+}
 TEST_CASE("sink", "[memory, stream]")
+{
     TestSink sink;
     SamplePack pack(100, 3, false);
     sink.setNumChannels(3, false);
     REQUIRE(sink.numChannels() == 3);
     sink.feedIn(pack);
     REQUIRE(sink.totalFed == 100);
     sink.feedIn(pack);
     REQUIRE(sink.totalFed == 200);
     TestSink follower;
     sink.connectFollower(&follower);
     REQUIRE(follower.numChannels() == 3);
     REQUIRE(follower.hasX() == false);
     sink.feedIn(pack);
     REQUIRE(sink.totalFed == 300);
     REQUIRE(follower.totalFed == 100);
     sink.setNumChannels(2, true);

0 comments (0 inline, 0 general)