if (serialPort.isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort.portName();

                portControl.togglePort();

            }

            portControl.loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort.portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

            qCritical() << "Device is not open!";

            break;

        case QSerialPort::ParityError:

            qCritical() << "Parity error detected.";

            break;

        case QSerialPort::FramingError:

            qCritical() << "Framing error detected.";

            break;

        case QSerialPort::BreakConditionError:

            qCritical() << "Break condition is detected.";

            break;

        case QSerialPort::WriteError:

            qCritical() << "An error occurred while writing data.";

            break;

        case QSerialPort::ReadError:

            qCritical() << "An error occurred while reading data.";

            break;

        case QSerialPort::UnsupportedOperationError:

            qCritical() << "Operation is not supported.";

            break;

        case QSerialPort::TimeoutError:

            qCritical() << "A timeout error occurred.";

            break;

        case QSerialPort::UnknownError:

            qCritical() << "Unknown error! Error: " << serialPort.errorString();

            break;

        default:

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

            break;

    }

}

void MainWindow::clearPlot()

{

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

    {

        channelMan.channelBuffer(ci)->clear();

    }

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    channelMan.setNumOfSamples(value);

    plotMan->replot();

}

void MainWindow::onNumOfChannelsChanged(unsigned value)

{

    unsigned int oldNum = plotMan->numOfCurves();

    unsigned numOfChannels = value;

    if (numOfChannels > oldNum)

    {

        // add new channels

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

        {

            plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));

        }

    }

    else if(numOfChannels < oldNum)

    {

        plotMan->removeCurves(oldNum - numOfChannels);

    }

    plotMan->replot();

}

void MainWindow::onSpsChanged(unsigned sps)

{

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

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            dataFormatPanel.enableDemo(true);

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        dataFormatPanel.enableDemo(false);

        ui->actionDemoMode->setChecked(false);

    }

}

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

    {

        Snapshot* snapshot = snapshotMan.makeSnapshot();

        snapshot->save(fileName);

        delete snapshot;

    }

}

PlotViewSettings MainWindow::viewSettings() const

{

    return plotMan->viewSettings();

}

void MainWindow::messageHandler(QtMsgType type,

                                const QMessageLogContext &context,

                                const QString &msg)

{

    QString logString;

    switch (type)

    {

#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))

        case QtInfoMsg:

            logString = "[Info] " + msg;

            break;

#endif

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

    }

    if (type == QtFatalMsg)

    {

        __builtin_trap();

    }

}

void MainWindow::saveAllSettings(QSettings* settings)

{

    saveMWSettings(settings);

    portControl.saveSettings(settings);

    dataFormatPanel.saveSettings(settings);

    channelMan.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

    plotMan->saveSettings(settings);

    commandPanel.saveSettings(settings);

    recordPanel.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    channelMan.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

    plotMan->loadSettings(settings);

    commandPanel.loadSettings(settings);

    recordPanel.loadSettings(settings);

}

void MainWindow::saveMWSettings(QSettings* settings)

{

    // save window geometry

    settings->beginGroup(SettingGroup_MainWindow);

    settings->setValue(SG_MainWindow_Size, size());

    settings->setValue(SG_MainWindow_Pos, pos());

    // save active panel

    settings->setValue(SG_MainWindow_ActivePanel,

                       panelSettingMap.value(ui->tabWidget->currentIndex()));

    // save panel minimization

    settings->setValue(SG_MainWindow_HidePanels,

                       ui->tabWidget->hideAction.isChecked());

    // save window maximized state

    settings->setValue(SG_MainWindow_Maximized,

                       bool(windowState() & Qt::WindowMaximized));

    // save toolbar/dockwidgets state

    settings->setValue(SG_MainWindow_State, saveState());

    settings->endGroup();

}

void MainWindow::loadMWSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_MainWindow);

    // load window geometry

    resize(settings->value(SG_MainWindow_Size, size()).toSize());

    move(settings->value(SG_MainWindow_Pos, pos()).toPoint());

    // set active panel

    QString tabSetting =

        settings->value(SG_MainWindow_ActivePanel, QString()).toString();

    ui->tabWidget->setCurrentIndex(

        panelSettingMap.key(tabSetting, ui->tabWidget->currentIndex()));

    // hide panels

    ui->tabWidget->hideAction.setChecked(

        settings->value(SG_MainWindow_HidePanels,

                        ui->tabWidget->hideAction.isChecked()).toBool());

    // maximize window

    if (settings->value(SG_MainWindow_Maximized).toBool())

    {

        showMaximized();

    }

    // load toolbar/dockwidgets state

    restoreState(settings->value(SG_MainWindow_State).toByteArray());

    settings->setValue(SG_MainWindow_State, saveState());

    settings->endGroup();

}

void MainWindow::onSaveSettings()

{

    QString fileName = QFileDialog::getSaveFileName(

        this, tr("Save Settings"), QString(), "INI (*.ini)");

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

    {

        QSettings settings(fileName, QSettings::IniFormat);

        saveAllSettings(&settings);

    }

}

void MainWindow::onLoadSettings()

{

    QString fileName = QFileDialog::getOpenFileName(

        this, tr("Load Settings"), QString(), "INI (*.ini)");

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

    {

        QSettings settings(fileName, QSettings::IniFormat);

        loadAllSettings(&settings);

    }

}

/*

  Copyright © 2017 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 SETTING_DEFINES_H

#define SETTING_DEFINES_H

const char SettingGroup_MainWindow[] = "MainWindow";

const char SettingGroup_Port[] = "Port";

const char SettingGroup_DataFormat[] = "DataFormat";

const char SettingGroup_Binary[] = "DataFormat_Binary";

const char SettingGroup_ASCII[] = "DataFormat_ASCII";

const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";

const char SettingGroup_Channels[] = "Channels";

const char SettingGroup_Plot[] = "Plot";

const char SettingGroup_Commands[] = "Commands";

const char SettingGroup_Record[] = "Record";

// mainwindow setting keys

const char SG_MainWindow_Size[] = "size";

const char SG_MainWindow_Pos[] = "pos";

const char SG_MainWindow_ActivePanel[] = "activePanel";

const char SG_MainWindow_HidePanels[] = "hidePanels";

const char SG_MainWindow_Maximized[] = "maximized";

const char SG_MainWindow_State[] = "state";

// port setting keys

const char SG_Port_SelectedPort[] = "selectedPort";

const char SG_Port_BaudRate[] = "baudRate";

const char SG_Port_Parity[] = "parity";

const char SG_Port_DataBits[] = "dataBits";

const char SG_Port_StopBits[] = "stopBits";

const char SG_Port_FlowControl[] = "flowControl";

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

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

const char SG_Channels_Channel[] = "channel";

const char SG_Channels_Name[] = "name";

const char SG_Channels_Color[] = "color";

const char SG_Channels_Visible[] = "visible";

// plot settings keys

const char SG_Plot_NumOfSamples[] = "numOfSamples";

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

const char SG_Record_AutoIncrement[]    = "autoIncrement";

const char SG_Record_RecordPaused[]     = "recordPaused";

const char SG_Record_StopOnClose[]      = "stopOnClose";

const char SG_Record_Header[]           = "header";

const char SG_Record_Separator[]        = "separator";

const char SG_Record_DisableBuffering[] = "disableBuffering";

#endif // SETTING_DEFINES_H

/*

  Copyright © 2017 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 "updatecheckdialog.h"

#include "ui_updatecheckdialog.h"

UpdateCheckDialog::UpdateCheckDialog(QWidget *parent) :

    QDialog(parent),

    ui(new Ui::UpdateCheckDialog)

{

    ui->setupUi(this);

    connect(&updateChecker, &UpdateChecker::checkFailed,

            [this](QString errorMessage)

            {

                ui->label->setText(QString("Update check failed.\n") + errorMessage);

            });

    connect(&updateChecker, &UpdateChecker::checkFinished,

            [this](bool found, QString newVersion, QString downloadUrl)

            {

                QString text;

                if (!found)

                {

                    text = "There is no update yet.";

                }

                else

                {

                    text = QString("Found update to version %1. Click to <a href=\"%2\">download</a>.")\

                        .arg(newVersion).arg(downloadUrl);

                }

                ui->label->setText(text);

            });

}

UpdateCheckDialog::~UpdateCheckDialog()

{

    delete ui;

}

void UpdateCheckDialog::showEvent(QShowEvent *event)

{

    updateChecker.checkUpdate();

    ui->label->setText("Checking update...");

}

void UpdateCheckDialog::closeEvent(QShowEvent *event)

{

    if (updateChecker.isChecking()) updateChecker.cancelCheck();

}

/*

  Copyright © 2017 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 UPDATECHECKDIALOG_H

#define UPDATECHECKDIALOG_H

#include <QDialog>

#include "updatechecker.h"

namespace Ui {

class UpdateCheckDialog;

}

class UpdateCheckDialog : public QDialog

{

    Q_OBJECT

public:

    explicit UpdateCheckDialog(QWidget *parent = 0);

    ~UpdateCheckDialog();

private:

    Ui::UpdateCheckDialog *ui;

    UpdateChecker updateChecker;

    void showEvent(QShowEvent *event);

    void closeEvent(QShowEvent *event);

};

#endif // UPDATECHECKDIALOG_H

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>UpdateCheckDialog</class>

 <widget class="QDialog" name="UpdateCheckDialog">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>400</width>

    <height>148</height>

   </rect>

  </property>

  <property name="windowTitle">

   <string>Check Update</string>

  </property>

  <layout class="QVBoxLayout" name="verticalLayout">

   <item>

    <widget class="QLabel" name="label">

     <property name="text">

      <string>Checking update...</string>

     </property>

     <property name="openExternalLinks">

      <bool>true</bool>

     </property>

    </widget>

   </item>

   <item>

    <widget class="QDialogButtonBox" name="buttonBox">

     <property name="orientation">

      <enum>Qt::Horizontal</enum>

     </property>

     <property name="standardButtons">

      <set>QDialogButtonBox::Close</set>

     </property>

    </widget>

   </item>

  </layout>

 </widget>

 <resources/>

 <connections>

  <connection>

   <sender>buttonBox</sender>

   <signal>clicked(QAbstractButton*)</signal>

   <receiver>UpdateCheckDialog</receiver>

   <slot>close()</slot>

   <hints>

    <hint type="sourcelabel">

     <x>199</x>

     <y>125</y>

    </hint>

    <hint type="destinationlabel">

     <x>199</x>

     <y>73</y>

    </hint>

   </hints>

  </connection>

 </connections>

</ui>

/*

  Copyright © 2017 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 <QJsonDocument>

#include <QJsonObject>

#include <QJsonArray>

#include <QJsonValue>

#include <QRegularExpression>

#include <algorithm>

#include <functional>

#include "updatechecker.h"

// This link returns the list of downloads in JSON format. Note that we only use

// the first page because results are sorted new to old.

const char BB_DOWNLOADS_URL[] = "https://api.bitbucket.org/2.0/repositories/hyozd/serialplot/downloads?fields=values.name,values.links.self.href";

UpdateChecker::UpdateChecker(QObject *parent) :

    QObject(parent), nam(this)

{

    activeReply = NULL;

    connect(&nam, &QNetworkAccessManager::finished,

            this, &UpdateChecker::onReqFinished);

}

bool UpdateChecker::isChecking() const

{

    return activeReply != NULL && !activeReply->isFinished();

}

void UpdateChecker::checkUpdate()

{

    auto req = QNetworkRequest(QUrl(BB_DOWNLOADS_URL));

    activeReply = nam.get(req);

}

void UpdateChecker::cancelCheck()

{

    if (activeReply != NULL) activeReply->abort();

}

void UpdateChecker::onReqFinished(QNetworkReply* reply)

{

    if (reply->error() != QNetworkReply::NoError)

    {

        emit checkFailed(QString("Network error: ") + reply->errorString());

    }

    else

    {

        QJsonParseError error;

        auto data = QJsonDocument::fromJson(reply->readAll(), &error);

        if (error.error != QJsonParseError::NoError)

        {

            emit checkFailed(QString("JSon parsing error: ") + error.errorString());

        }

        else

        {

            QList<FileInfo> files;

            if (!parseData(data, files))

            {

                // TODO: emit detailed data contents for logging

                emit checkFailed("Data parsing error.");

            }

            else

            {

                FileInfo updateFile;

                if (findUpdate(files, updateFile))

                {

                    emit checkFinished(

                        true, updateFile.version.toString(), updateFile.link);

                }

                else

                {

                    emit checkFinished(false, "", "");

                }

            }

        }

    }

    reply->deleteLater();

    activeReply = NULL;

}

bool UpdateChecker::parseData(const QJsonDocument& data, QList<FileInfo>& files) const

{

    /* Data is expected to be in this form:

    {

       "values": [

       {

         "name": "serialplot-0.9.1-x86_64.AppImage",

         "links": {

           "self": {

             "href": "https://api.bitbucket.org/2.0/repositories/hyOzd/serialplot/downloads/serialplot-0.9.1-x86_64.AppImage"

            }

          }

       }, ... ]

    }

    */

    if (!data.isObject()) return false;

    auto values = data.object()["values"];

    if (values == QJsonValue::Undefined || !values.isArray()) return false;

    for (auto value : values.toArray())

    {

        if (!value.isObject()) return false;

        auto name = value.toObject().value("name");

        if (name.isUndefined() || !name.isString())

             return false;

        auto links = value.toObject().value("links");

        if (links.isUndefined() || !links.isObject())

            return false;

        auto self = links.toObject().value("self");

        if (self.isUndefined() || !self.isObject())

            return false;

        auto href = self.toObject().value("href");

        if (href.isUndefined() || !href.isString())

            return false;

        FileInfo finfo;

        finfo.name = name.toString();

        finfo.link = href.toString();

        finfo.hasVersion = VersionNumber::extract(name.toString(), finfo.version);

        if (finfo.name.contains("amd64") ||

            finfo.name.contains("x86_64") ||

            finfo.name.contains("win64"))

        {

            finfo.arch = FileArch::amd64;

        }

        else if (finfo.name.contains("win32") ||

                 finfo.name.contains("i386"))

        {

            finfo.arch = FileArch::i386;

        }

        else

        {

            finfo.arch = FileArch::unknown;

        }

        files += finfo;

    }

    return true;

}

bool UpdateChecker::findUpdate(const QList<FileInfo>& files, FileInfo& foundFile) const

{

    QList<FileInfo> fflist;

    // filter the file list according to extension and version number

    for (int i = 0; i < files.length(); i++)

    {

        // file type to look

#if defined(Q_OS_WIN)

        const char ext[] = ".exe";

#else  // of course linux

        const char ext[] = ".appimage";

#endif

        // file architecture to look

#if defined(Q_PROCESSOR_X86_64)

        const FileArch arch = FileArch::amd64;

#elif defined(Q_PROCESSOR_X86_32)

        const FileArch arch = FileArch::i386;

#elif defined(Q_PROCESSOR_ARM)

        const FileArch arch = FileArch::arm;

#else

        #error Unknown architecture for update file detection.

#endif

        // filter the file list

        auto file = files[i];

        if (file.name.contains(ext, Qt::CaseInsensitive) &&

            file.arch == arch &&

            file.hasVersion && file.version > CurrentVersion)

        {

            fflist += file;

        }

    }

    // sort and find most up to date file

    if (!fflist.empty())

    {

        std::sort(fflist.begin(), fflist.end(),

                  [](const FileInfo& a, const FileInfo& b)

                  {

                      return a.version > b.version;

                  });

        foundFile = fflist[0];

        return true;

    }

    else

    {

        return false;

    }

}