numberFormatButtons.addButton(ui->rbFloat,  NumberFormat_float);

    numberFormatButtons.addButton(ui->rbASCII,  NumberFormat_ASCII);

    QObject::connect(&numberFormatButtons, SIGNAL(buttonToggled(int, bool)),

                     this, SLOT(onNumberFormatButtonToggled(int, bool)));

    // init port signals

    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

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

    // init data arrays and plot

    numOfSamples = ui->spNumOfSamples->value();

    numOfChannels = 1;

    dataX.resize(numOfSamples);

    for (int i = 0; i < dataX.size(); i++)

    {

        dataX[i] = i;

    }

    // init channel data and curve list

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

    {

        channelsData.append(DataArray(numOfSamples, 0.0));

        curves.append(new QwtPlotCurve());

        curves[i]->setSamples(dataX, channelsData[i]);

        curves[i]->setPen(makeColor(i));

        curves[i]->attach(ui->plot);

    }

    // init number format

    if (numberFormatButtons.checkedId() >= 0)

    {

        selectNumberFormat((NumberFormat) numberFormatButtons.checkedId());

    }

    else

    {

        selectNumberFormat(NumberFormat_uint8);

    }

    // Init demo mode

    demoCount = 0;

    demoTimer.setInterval(100);

    QObject::connect(&demoTimer, &QTimer::timeout,

                     this, &MainWindow::demoTimerTimeout);

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     this, &MainWindow::enableDemo);

    {   // init demo indicator

        QwtText demoText(" DEMO RUNNING ");  // looks better with spaces

        demoText.setColor(QColor("white"));

        demoText.setBackgroundBrush(Qt::darkRed);

        demoText.setBorderRadius(4);

        demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignTop);

        demoIndicator.setText(demoText);

        demoIndicator.hide();

        demoIndicator.attach(ui->plot);

    }

}

MainWindow::~MainWindow()

{

    for (auto curve : curves)

    {

        delete curve;

    }

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete ui;

}

void MainWindow::setupAboutDialog()

{

    Ui_AboutDialog uiAboutDialog;

    uiAboutDialog.setupUi(&aboutDialog);

    QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,

                     [](){ QApplication::aboutQt();});

    QString aboutText = uiAboutDialog.lbAbout->text();

    aboutText.replace("$VERSION_STRING$", VERSION_STRING);

    aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);

    uiAboutDialog.lbAbout->setText(aboutText);

}

void MainWindow::onPortToggled(bool open)

{

    // make sure demo mode is disabled

    if (open && isDemoRunning()) enableDemo(false);

    ui->actionDemoMode->setEnabled(!open);

}

void MainWindow::onDataReady()

{

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

    {

        // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

        int packageSize = sampleSize * numOfChannels;

        int bytesAvailable = serialPort.bytesAvailable();

        if (bytesAvailable > 0 && skipByteRequested)

        {

            serialPort.read(1);

        case QSerialPort::UnknownError:

            qCritical() << "Unknown error!";

            break;

        default:

            qCritical() << "Unhandled port error: " << error;

            break;

    }

}

void MainWindow::skipByte()

{

    skipByteRequested = true;

}

void MainWindow::addChannelData(unsigned int channel, DataArray data)

{

    DataArray* channelDataArray = &(channelsData[channel]);

    int offset = numOfSamples - data.size();

    if (offset < 0)

    {

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

        {

            (*channelDataArray)[i] = data[i - offset];

        }

    }

    else if (offset == 0)

    {

        (*channelDataArray) = data;

    }

    else

    {

        // shift old samples

        int shift = data.size();

        for (int i = 0; i < offset; i++)

        {

            (*channelDataArray)[i] = (*channelDataArray)[i + shift];

        }

        // place new samples

        for (int i = 0; i < data.size(); i++)

        {

            (*channelDataArray)[offset + i] = data[i];

        }

    }

    // update plot

    curves[channel]->setSamples(dataX, (*channelDataArray));

    ui->plot->replot(); // TODO: replot after all channel data updated

}

void MainWindow::clearPlot()

{

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

    {

        channelsData[ci].fill(0.0);

        curves[ci]->setSamples(dataX, channelsData[ci]);

    }

    // update plot

    ui->plot->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    unsigned int oldNum = this->numOfSamples;

    numOfSamples = value;

    // resize data arrays

    if (numOfSamples < oldNum)

    {

        dataX.resize(numOfSamples);

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

        {

            channelsData[ci].remove(0, oldNum - numOfSamples);

        }

    }

    else if(numOfSamples > oldNum)

    {

        dataX.resize(numOfSamples);

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

        {

            dataX[i] = i;

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

            {

                channelsData[ci].prepend(0);

            }

        }

    }

}

void MainWindow::onNumOfChannelsChanged(int value)

{

    unsigned int oldNum = this->numOfChannels;

    this->numOfChannels = value;

    if (numOfChannels > oldNum)

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

{

    demoCount++;

    if (demoCount > 100) demoCount = 0;

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

    {

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

        {

            DataArray data(1);

            data.replace(0, (ci + 1)*demoCount);

            addChannelData(ci, data);

        }

    }

}

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

    }

}

/*

  Below crude drawing demostrates how color selection occurs for

  given channel index

  0°                     <--Hue Value-->                           360°

  |* . o . + . o . * . o . + . o . * . o . + . o . * . o . + . o . |

/*

  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/>.

*/

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <QMainWindow>

#include <QButtonGroup>

#include <QString>

#include <QVector>

#include <QList>

#include <QSerialPort>

#include <QSignalMapper>

#include <QTimer>

#include <QColor>

#include <QtGlobal>

#include <qwt_plot_curve.h>

#include <qwt_plot_textlabel.h>

#include "portcontrol.h"

#include "ui_about_dialog.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    void messageHandler(QtMsgType type, const QMessageLogContext &context,

                        const QString &msg);

private:

    enum NumberFormat

    {

        NumberFormat_uint8,

        NumberFormat_uint16,

        NumberFormat_uint32,

        NumberFormat_int8,

        NumberFormat_int16,

        NumberFormat_int32,

        NumberFormat_float,

        NumberFormat_ASCII

    };

    Ui::MainWindow *ui;

    QButtonGroup numberFormatButtons;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    unsigned int numOfChannels;

    QList<QwtPlotCurve*> curves;

    typedef QVector<double> DataArray;

    DataArray dataX;   // array that simply contains numbers 0..numberOfSamples

    QList<DataArray> channelsData;

    // `data` contains channel specific data

    void addChannelData(unsigned int channel, DataArray data);

    NumberFormat numberFormat;

    unsigned int sampleSize; // number of bytes in the selected number format

    double (MainWindow::*readSample)();

    // note that serialPort should already have enough bytes present

    template<typename T> double readSampleAs();

    bool skipByteRequested;

    // demo

    QTimer demoTimer;

    int demoCount;

    bool isDemoRunning();

    QwtPlotTextLabel demoIndicator;

    QColor makeColor(unsigned int channelIndex);

private slots:

    void onPortToggled(bool open);

    void onDataReady();      // used with binary number formats

    void onDataReadyASCII(); // used with ASCII number format

    void onPortError(QSerialPort::SerialPortError error);

    void skipByte();

    void onNumOfSamplesChanged(int value);

    void onAutoScaleChecked(bool checked);

    void onYScaleChanged();

    void onNumOfChannelsChanged(int value);

    void onNumberFormatButtonToggled(int numberFormatId, bool checked);

    void selectNumberFormat(NumberFormat numberFormatId);

    void clearPlot();

    void demoTimerTimeout();

    void enableDemo(bool enabled);

    void onExportCsv();

};

#endif // MAINWINDOW_H