case NumberFormat_int8:

            sampleSize = 1;

            readSample = &MainWindow::readSampleAs<qint8>;

            break;

        case NumberFormat_uint16:

            sampleSize = 2;

            readSample = &MainWindow::readSampleAs<quint16>;

            break;

        case NumberFormat_int16:

            sampleSize = 2;

            readSample = &MainWindow::readSampleAs<qint16>;

            break;

        case NumberFormat_uint32:

            sampleSize = 4;

            readSample = &MainWindow::readSampleAs<quint32>;

            break;

        case NumberFormat_int32:

            sampleSize = 4;

            readSample = &MainWindow::readSampleAs<qint32>;

            break;

        case NumberFormat_float:

            sampleSize = 4;

            readSample = &MainWindow::readSampleAs<float>;

            break;

        case NumberFormat_ASCII:

            sampleSize = 0;    // these two members should not be used

            readSample = NULL; // in this mode

            break;

    }

    if (numberFormat == NumberFormat_ASCII)

    {

        QObject::disconnect(&(this->serialPort), &QSerialPort::readyRead, 0, 0);

        QObject::connect(&(this->serialPort), &QSerialPort::readyRead,

                         this, &MainWindow::onDataReadyASCII);

        portControl.enableSkipByte();

    }

    else

    {

        QObject::disconnect(&(this->serialPort), &QSerialPort::readyRead, 0, 0);

        QObject::connect(&(this->serialPort), &QSerialPort::readyRead,

                         this, &MainWindow::onDataReady);

        portControl.enableSkipByte(false);

    }

}

template<typename T> double MainWindow::readSampleAs()

{

    T data;

    this->serialPort.read((char*) &data, sizeof(data));

    if (ui->rbLittleE->isChecked())

    {

        data = qFromLittleEndian(data);

    }

    else

    {

        data = qFromBigEndian(data);

    }

    return double(data);

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::spsTimerTimeout()

{

    spsLabel.setText(QString::number(sampleCount/SPS_UPDATE_TIMEOUT) + "sps");

    sampleCount = 0;

}

void MainWindow::demoTimerTimeout()

{

    const double period = 100;

    demoCount++;

    if (demoCount > 100) demoCount = 0;

    if (!ui->actionPause->isChecked())

    {

        for (unsigned int ci = 0; ci < numOfChannels; ci++)

        {

            // we are calculating the fourier components of square wave

            double value = 4*sin(2*M_PI*double((ci+1)*demoCount)/period)/((2*(ci+1))*M_PI);

            addChannelData(ci, &value, 1);

        }

        ui->plot->replot();

    }

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            demoTimer.start();

            ui->actionDemoMode->setChecked(true);

            demoIndicator.show();

            ui->plot->replot();

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        demoTimer.stop();

        ui->actionDemoMode->setChecked(false);

        demoIndicator.hide();

        ui->plot->replot();

    }

}

void MainWindow::onExportCsv()

{

    bool wasPaused = ui->actionPause->isChecked();

    ui->actionPause->setChecked(true); // pause plotting

    QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));

    if (fileName.isNull())  // user canceled export

    {

        ui->actionPause->setChecked(wasPaused);

    }

    else

    {

        QFile file(fileName);

        if (file.open(QIODevice::WriteOnly | QIODevice::Text))

        {

            QTextStream fileStream(&file);

            for (unsigned int ci = 0; ci < numOfChannels; ci++)

            {

                fileStream << "Channel " << ci;

                if (ci != numOfChannels-1) fileStream << ",";

            }

            fileStream << '\n';

            for (unsigned int i = 0; i < numOfSamples; i++)

            {

                for (unsigned int ci = 0; ci < numOfChannels; ci++)

                {

                    fileStream << channelBuffers[ci]->sample(i).y();

                    if (ci != numOfChannels-1) fileStream << ",";

                }

                fileStream << '\n';

            }

        }

        else

        {

            qCritical() << "File open error during export: " << file.error();

        }

    }

}

void MainWindow::messageHandler(QtMsgType type,

                                const QMessageLogContext &context,

                                const QString &msg)

{

    QString logString;

    switch (type)

    {

        case QtDebugMsg:

            logString = "[Debug] " + msg;

            break;

        case QtWarningMsg:

            logString = "[Warning] " + msg;

            break;

        case QtCriticalMsg:

            logString = "[Error] " + msg;

            break;

        case QtFatalMsg:

            logString = "[Fatal] " + msg;

            break;

    }

    if (ui != NULL) ui->ptLog->appendPlainText(logString);

    std::cerr << logString.toStdString() << std::endl;

    if (type != QtDebugMsg && ui != NULL)

    {

        ui->statusBar->showMessage(msg, 5000);

    }

}

void MainWindow::takeSnapShot()

{

    QString name = QTime::currentTime().toString("'Snapshot ['HH:mm:ss']'");

    auto snapShot = new SnapShot(this, name);

    for (unsigned ci = 0; ci < numOfChannels; ci++)

    {

        snapShot->data.append(QVector<QPointF>(numOfSamples));

        for (unsigned i = 0; i < numOfSamples; i++)

        {

            snapShot->data[ci][i] = channelBuffers[ci]->sample(i);

        }

    }

    snapshots.append(snapShot);

    QObject::connect(snapShot, &SnapShot::deleteRequested,

                     this, &MainWindow::deleteSnapshot);

    updateSnapShotMenu();

}

void MainWindow::updateSnapShotMenu()

{

    ui->menuSnapShots->clear();

    ui->menuSnapShots->addAction(ui->actionSnapShot);

    if (snapshots.size())

    {

        ui->menuSnapShots->addSeparator();

        for (auto ss : snapshots)

        {

            ui->menuSnapShots->addAction(ss->showAction());

        }

        ui->menuSnapShots->addSeparator();

        ui->menuSnapShots->addAction(ui->actionClearSnapShots);

    }

}

void MainWindow::clearSnapshots()

{

    for (auto snapshot : snapshots)

    {

        delete snapshot;

    }

    snapshots.clear();

    updateSnapShotMenu();

}

void MainWindow::deleteSnapshot(SnapShot* snapshot)

{

    delete snapshots.takeAt(snapshots.indexOf(snapshot));

    updateSnapShotMenu();

}

#include <stddef.h>

#include "snapshot.h"

#include "snapshotview.h"

#include <QtDebug>

SnapShot::SnapShot(QMainWindow* parent, QString name) :

    QObject(parent),

    _showAction(name, this),

    _deleteAction("Delete", this)

{

    _name = name;

    view = NULL;

    mainWindow = parent;

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

{

    delete view;

    view = NULL;

}

void SnapShot::onDeleteTriggered()

{

    emit deleteRequested(this);

}

QString SnapShot::name()

{

    return _name;

}

#ifndef SNAPSHOT_H

#define SNAPSHOT_H

#include <QObject>

#include <QMainWindow>

#include <QAction>

#include <QVector>

class SnapShotView;

class SnapShot : public QObject

{

    Q_OBJECT

public:

    SnapShot(QMainWindow* parent, QString name);

    ~SnapShot();

    QVector<QVector<QPointF>> data;

    QAction* showAction();

    QAction* deleteAction();

    QString name();

signals:

    void deleteRequested(SnapShot*);

private:

    QString _name;

    QAction _showAction;

    QAction _deleteAction;

    QMainWindow* mainWindow;

    SnapShotView* view;

private slots:

    void viewClosed();

    void onDeleteTriggered();

};

#endif /* SNAPSHOT_H */