emit numOfSamplesChanged(number);

}

void ChannelManager::pause(bool paused)

{

    _paused = paused;

}

FrameBuffer* ChannelManager::channelBuffer(unsigned channel)

{

    return channelBuffers[channel];

}

ChannelInfoModel* ChannelManager::infoModel()

{

    return &_infoModel;

}

QString ChannelManager::channelName(unsigned channel)

{

    return _infoModel.data(_infoModel.index(channel, ChannelInfoModel::COLUMN_NAME),

                           Qt::DisplayRole).toString();

}

void ChannelManager::onChannelInfoChanged(const QModelIndex & topLeft,

                                          const QModelIndex & bottomRight,

                                          const QVector<int> & roles)

{

    int start = topLeft.row();

    int end = bottomRight.row();

    int col = topLeft.column();

    for (int ci = start; ci <= end; ci++)

    {

        for (auto role : roles)

        {

            switch (role)

            {

                case Qt::EditRole:

                    if (col == ChannelInfoModel::COLUMN_NAME)

                    {

                        emit channelNameChanged(ci, channelName(ci));

                    }

                    break;

                case Qt::ForegroundRole:

                    if (col == ChannelInfoModel::COLUMN_NAME)

                    {

                        // TODO: emit channel color changed

#include <QModelIndex>

#include <QVector>

#include <QSettings>

#include "framebuffer.h"

#include "channelinfomodel.h"

class ChannelManager : public QObject

{

    Q_OBJECT

public:

    explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);

    ~ChannelManager();

    unsigned numOfChannels();

    unsigned numOfSamples();

    FrameBuffer* channelBuffer(unsigned channel);

    QString channelName(unsigned channel);

    /// Stores channel names into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads channel names from a `QSettings`.

    void loadSettings(QSettings* settings);

    /// Returns a model that manages channel information (name, color etc)

    ChannelInfoModel* infoModel();

signals:

    void numOfChannelsChanged(unsigned value);

    void numOfSamplesChanged(unsigned value);

    void channelNameChanged(unsigned channel, QString name);

    void dataAdded(); ///< emitted when data added to channel man.

public slots:

    void setNumOfChannels(unsigned number);

    void setNumOfSamples(unsigned number);

    /**

     * Add data for all channels.

     *

     * All channels data is provided in a single array which contains equal

     * number of samples for all channels. Structure is as shown below:

     *

     * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]

     *

     * @param data samples for all channels

     * @param size size of `data`, must be multiple of `numOfChannels`

     */

    void addData(double* data, unsigned size);

    /// When paused `addData` does nothing.

    void pause(bool paused);

private:

    unsigned _numOfChannels;

    unsigned _numOfSamples;

    bool _paused;

    QList<FrameBuffer*> channelBuffers;

    // QStringListModel _channelNames;

    ChannelInfoModel _infoModel;

private slots:

    void onChannelInfoChanged(const QModelIndex & topLeft,

                              const QModelIndex & bottomRight,

                              const QVector<int> & roles = QVector<int> ());

};

#endif // CHANNELMANAGER_H

    if (enabled)

    {

        setCanvasBackground(QBrush(Qt::black));

        gridColor.setHsvF(0, 0, 0.25);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::white));

        zoomer.setTrackerPen(QPen(Qt::white));

        sZoomer.setPickerPen(QPen(Qt::white));

        legend.setTextPen(QPen(Qt::white));

    }

    else

    {

        setCanvasBackground(QBrush(Qt::white));

        gridColor.setHsvF(0, 0, 0.80);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::black));

        zoomer.setTrackerPen(QPen(Qt::black));

        sZoomer.setPickerPen(QPen(Qt::black));

        legend.setTextPen(QPen(Qt::black));

    }

    updateSymbols();

    replot();

}

void Plot::flashSnapshotOverlay(bool light)

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

    QColor color;

    if(light)

    {

        color = QColor(Qt::white);

    }

    else

    {

        color = QColor(Qt::black);

    }

    snapshotOverlay = new PlotSnapshotOverlay(this->canvas(), color);

    connect(snapshotOverlay, &PlotSnapshotOverlay::done,

            [this]()

            {

                delete snapshotOverlay;

                snapshotOverlay = NULL;

            });

}

void Plot::setSymbols(ShowSymbols shown)

#include <qwt_plot_legenditem.h>

#include <qwt_plot_textlabel.h>

#include "zoomer.h"

#include "scalezoomer.h"

#include "plotsnapshotoverlay.h"

class Plot : public QwtPlot

{

    Q_OBJECT

    friend class PlotManager;

public:

    enum ShowSymbols

    {

        ShowSymbolsAuto,

        ShowSymbolsShow,

        ShowSymbolsHide

    };

    Plot(QWidget* parent = 0);

    ~Plot();

public slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void showDemoIndicator(bool show = true);

    void showNoChannel(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

    void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);

    void setXAxis(double xMin, double xMax);

    void setSymbols(ShowSymbols shown);

    /**

     * Displays an animation for snapshot.

     *

     * @param light show a light colored (white) animation or the opposite

     */

    void flashSnapshotOverlay(bool light);

    void setNumOfSamples(unsigned value);

    void setPlotWidth(double width);

protected:

    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();

}

Plot* PlotManager::plotWidget(unsigned curveIndex)

{

    if (isMulti)

    {

        return plotWidgets[curveIndex];

    }

    else

    {

        return plotWidgets[0];

    }

}

void PlotManager::replot()

{

    for (auto plot : plotWidgets)

    {

        plot->replot();

    }

}

void PlotManager::showGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

#include <QList>

#include <QSettings>

#include <QMenu>

#include <qwt_plot_curve.h>

#include "plot.h"

#include "framebufferseries.h"

#include "channelinfomodel.h"

#include "plotmenu.h"

class PlotManager : public QObject

{

    Q_OBJECT

public:

    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

                         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);

    /// Removes curves from the end

    void removeCurves(unsigned number);

    /// Returns current number of curves known by plot manager

    unsigned numOfCurves();

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;

    PlotMenu* _menu;

    QVBoxLayout* layout; ///< layout of the `plotArea`

            [this](bool enabled)

            {

                _recorder->disableBuffering = enabled;

            });

    connect(ui->cbWindowsLE, &QCheckBox::toggled,

            [this](bool enabled)

            {

                _recorder->windowsLE = enabled;

            });

    connect(&recordAction, &QAction::toggled, ui->cbWindowsLE, &QWidget::setDisabled);

}

RecordPanel::~RecordPanel()

{

    delete ui;

}

QToolBar* RecordPanel::toolbar()

{

    return &recordToolBar;

}

bool RecordPanel::recordPaused()

{

    return ui->cbRecordPaused->isChecked();

}

bool RecordPanel::selectFile()

{

    QString fileName = QFileDialog::getSaveFileName(

        parentWidget(), tr("Select recording file"));

    if (fileName.isEmpty())

    {

        return false;

    }

    else

    {

        selectedFile = fileName;

        ui->lbFileName->setText(selectedFile);

        overwriteSelected = QFile::exists(fileName);

        return true;

    }

}

void RecordPanel::onRecord(bool start)

#include <QWidget>

#include <QString>

#include <QToolBar>

#include <QAction>

#include "datarecorder.h"

#include "channelmanager.h"

namespace Ui {

class RecordPanel;

}

class RecordPanel : public QWidget

{

    Q_OBJECT

public:

    explicit RecordPanel(DataRecorder* recorder, ChannelManager* channelMan,

                         QWidget* parent = 0);

    ~RecordPanel();

    QToolBar* toolbar();

    bool recordPaused();

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

signals:

    void recordStarted();

    void recordStopped();

    void recordPausedChanged(bool enabled);

public slots:

    /// Must be called when port is closed

    void onPortClose();

private:

    Ui::RecordPanel *ui;

    QToolBar recordToolBar;

    QAction recordAction;

    QString selectedFile;

    bool overwriteSelected;

    DataRecorder* _recorder;

    ChannelManager* _channelMan;