}

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

#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_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

  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)

            {

            });

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

}

  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

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

    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)