// setup number format buttons

    numberFormatButtons.addButton(ui->rbUint8,  NumberFormat_uint8);

    numberFormatButtons.addButton(ui->rbUint16, NumberFormat_uint16);

    numberFormatButtons.addButton(ui->rbUint32, NumberFormat_uint32);

    numberFormatButtons.addButton(ui->rbInt8,   NumberFormat_int8);

    numberFormatButtons.addButton(ui->rbInt16,  NumberFormat_int16);

    numberFormatButtons.addButton(ui->rbInt32,  NumberFormat_int32);

    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 zoomer

    zoomer = new Zoomer(ui->plot->canvas(), false);

    zoomer->setZoomBase();

    // init number format

    if (numberFormatButtons.checkedId() >= 0)

    {

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

    }

    else

    {

        selectNumberFormat(NumberFormat_uint8);

    }

    // Init sps (sample per second) counter

    sampleCount = 0;

    spsLabel.setText("0sps");

    spsLabel.setToolTip("samples per second (total of all channels)");

    ui->statusBar->addPermanentWidget(&spsLabel);

    spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);

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

                     this, &MainWindow::spsTimerTimeout);

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

    }

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

            {

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

                {

                    fileStream << channelsData[ci][i];

                    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;

    }

    ui->ptLog->appendPlainText(logString);

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

    if (type != QtDebugMsg)

    {

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

    }

}

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 i th channels data

    void addChannelData(unsigned int channel, DataArray data);

    Zoomer* zoomer;

    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;

    const int SPS_UPDATE_TIMEOUT = 1;  // second

    QLabel spsLabel;

    unsigned int sampleCount;

    QTimer spsTimer;

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

    void demoTimerTimeout();

    void enableDemo(bool enabled);

    void onExportCsv();

};

/*

  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 "zoomer.h"

#include <qwt_plot.h>

#include <QtDebug>

Zoomer::Zoomer(QWidget* widget, bool doReplot) :

    QwtPlotZoomer(widget, doReplot)

{

    // do nothing

}

void Zoomer::zoom(int up)

{

    if (up == +1)

    {

        this->setZoomBase(this->plot());

    }

    QwtPlotZoomer::zoom(up);

    if (up == 0)

    {

    }

}

/*

  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 ZOOMER_H

#define ZOOMER_H

#include <qwt_plot_zoomer.h>

class Zoomer : public QwtPlotZoomer

{

    Q_OBJECT

public:

    Zoomer(QWidget *, bool doReplot=true);

    void zoom(int up);

};

#endif // ZOOMER_H