src/scrollzoomer.cpp

  src/scrollbar.cpp

  src/hidabletabwidget.cpp

  src/scalepicker.cpp

  src/scalezoomer.cpp

  src/portlist.cpp

  src/snapshot.cpp

  src/snapshotview.cpp

  src/snapshotmanager.cpp

  src/plotsnapshotoverlay.cpp

  src/commandpanel.cpp

  src/commandwidget.cpp

  src/commandedit.cpp

  src/dataformatpanel.cpp

  src/plotcontrolpanel.cpp

  src/recordpanel.cpp

  src/datarecorder.cpp

  src/tooltipfilter.cpp

  src/sneakylineedit.cpp

  src/stream.cpp

  src/streamchannel.cpp

  src/channelinfomodel.cpp

  src/ringbuffer.cpp

  src/ringbuffer.cpp

  src/indexbuffer.cpp

  src/linindexbuffer.cpp

  src/readonlybuffer.cpp

  src/framebufferseries.cpp

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

  src/asciireader.cpp

  src/asciireadersettings.cpp

  src/demoreader.cpp

  src/demoreadersettings.cpp

  src/framedreader.cpp

  src/framedreadersettings.cpp

  src/plotmanager.cpp

  src/plotmenu.cpp

  src/barplot.cpp

  src/barchart.cpp

  src/barscaledraw.cpp

  src/numberformat.cpp

  src/updatechecker.cpp

  src/versionnumber.cpp

  src/updatecheckdialog.cpp

  src/samplepack.cpp

  src/source.cpp

  src/sink.cpp

  src/samplecounter.cpp

  src/ledwidget.cpp

  src/datatextview.cpp

  misc/windows_icon.rc

  ${UI_FILES}

  ${RES_FILES}

  )

# Use the Widgets module from Qt 5.

target_link_libraries(${PROGRAM_NAME}

  ${QWT_LIBRARY}

  )

qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Network)

if (BUILD_QWT)

  add_dependencies(${PROGRAM_NAME} QWT)

endif ()

# set compiler flags

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

# Enable C++11 support, fail if not supported

include(CheckCXXCompilerFlag)

CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

if(COMPILER_SUPPORTS_CXX11)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

elseif(COMPILER_SUPPORTS_CXX0X)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

else()

  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

endif()

# default version

set(VERSION_STRING "0.10.0")

set(VERSION_REVISION "0")

# get revision number from mercurial and parse version string

include(GetVersion)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_STRING=\\\"${VERSION_STRING}\\\" ")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_MAJOR=${VERSION_MAJOR} ")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_MINOR=${VERSION_MINOR} ")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_PATCH=${VERSION_PATCH} ")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_REVISION=\\\"${VERSION_REVISION}\\\" ")

# add make run target

add_custom_target(run

    COMMAND ${PROGRAM_NAME}

    DEPENDS ${PROGRAM_NAME}

    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

)

# installing

install(TARGETS ${PROGRAM_NAME} DESTINATION bin)

# for windows put libraries to install directory

if (WIN32)

  file(GLOB WINDOWS_INSTALL_LIBRARIES

    "${CMAKE_BINARY_DIR}/windows_install_libraries/*.*")

  install(FILES ${WINDOWS_INSTALL_LIBRARIES} DESTINATION bin)

endif (WIN32)

# prepare menu item and icon

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.desktop.in"

  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop")

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.png"

  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png" COPYONLY)

set(DESKTOP_FILE ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop)

set(ICON_FILE ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png)

# install menu item and icon

if (UNIX)

  install(FILES ${DESKTOP_FILE} DESTINATION share/applications/)

  install(FILES ${ICON_FILE} DESTINATION share/icons/hicolor/256x256/apps/)

endif (UNIX)

# uninstalling

configure_file(

  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

  @ONLY)

if (UNIX)

  add_custom_target(uninstall

    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)

endif (UNIX)

# testing

set(ENABLE_TESTS false CACHE BOOL "Build tests.")

if (ENABLE_TESTS)

  enable_testing()

  add_subdirectory(tests)

endif ()

# packaging

include(BuildLinuxAppImage)

if (UNIX)

  set(CPACK_GENERATOR "DEB")

elseif (WIN32)

  set(CPACK_GENERATOR "NSIS")

endif (UNIX)

include(InstallRequiredSystemLibraries)

set(CPACK_PACKAGE_NAME "${PROGRAM_NAME}")

set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})

set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})

set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})

set(CPACK_STRIP_FILES TRUE)

set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5svg5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Small and simple software for plotting data from serial port

 Supports binary data formats ([u]int8, [u]int16, [u]int32, float)

 and ASCII (as CSV). Captured waveforms can be exported in CSV format.

 Can also send simple user defined commands to serial port device.")

if (NOT QWT_USE_STATIC)

  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

endif (NOT QWT_USE_STATIC)

if (UNIX)

  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME}")

elseif (WIN32)

  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME};${PROGRAM_DISPLAY_NAME}")

  set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROGRAM_NAME}")

  set(CPACK_CREATE_DESKTOP_LINKS "${PROGRAM_NAME}")

  set(CPACK_NSIS_MODIFY_PATH "ON")

  set(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/misc/serialplot.bmp")

  string(REPLACE "/" "\\\\" CPACK_PACKAGE_ICON ${CPACK_PACKAGE_ICON})

  set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")

  set(CPACK_NSIS_MENU_LINKS

    "https://bitbucket.org/hyOzd/serialplot" "SerialPlot source code on bitbucket.org")

  set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL true)

endif (UNIX)

if (UNIX)

  # set debian package name

/*

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

#include <QtGlobal>

#include <iostream>

#include "mainwindow.h"

#include "tooltipfilter.h"

#include "version.h"

MainWindow* pMainWindow = nullptr;

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

    }

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

    if (pMainWindow != nullptr)

    {

        // TODO: don't call MainWindow::messageHandler if window is destroyed

        pMainWindow->messageHandler(type, logString, msg);

    }

    if (type == QtFatalMsg)

    {

        __builtin_trap();

    }

}

int main(int argc, char *argv[])

{

    QApplication a(argc, argv);

    QApplication::setApplicationVersion(VERSION_STRING);

    qInstallMessageHandler(messageHandler);

    MainWindow w;

    pMainWindow = &w;

    ToolTipFilter ttf;

    a.installEventFilter(&ttf);

    // log application information

    qDebug() << "SerialPlot" << VERSION_STRING;

    qDebug() << "Revision" << VERSION_REVISION;

    w.show();

    return a.exec();

}

/*

  Copyright © 2019 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 "mainwindow.h"

#include "ui_mainwindow.h"

#include <QByteArray>

#include <QApplication>

#include <QFileDialog>

#include <QMessageBox>

#include <QFile>

#include <QTextStream>

#include <QMenu>

#include <QDesktopServices>

#include <QMap>

#include <QtDebug>

#include <QCommandLineParser>

#include <QFileInfo>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include <plot.h>

#include <barplot.h>

#include "framebufferseries.h"

#include "utils.h"

#include "defines.h"

#include "version.h"

#include "setting_defines.h"

#if defined(Q_OS_WIN) && defined(QT_STATIC)

#include <QtPlugin>

Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

#endif

// TODO: depends on tab insertion order, a better solution would be to use object names

const QMap<int, QString> panelSettingMap({

        {0, "Port"},

        {1, "DataFormat"},

        {2, "Plot"},

        {3, "Commands"},

        {4, "Record"},

        {5, "TextView"},

        {6, "Log"}

    });

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    secondaryPlot(NULL),

    snapshotMan(this, &stream),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort),

    recordPanel(&stream),

    textView(&stream),

    updateCheckDialog(this)

{

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea, &plotMenu, &stream);

    ui->tabWidget->insertTab(0, &portControl, "Port");

    ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");

    ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");

    ui->tabWidget->insertTab(3, &commandPanel, "Commands");

    ui->tabWidget->insertTab(4, &recordPanel, "Record");

    ui->tabWidget->insertTab(5, &textView, "Text View");

    ui->tabWidget->setCurrentIndex(0);

    auto tbPortControl = portControl.toolBar();

    addToolBar(tbPortControl);

    addToolBar(recordPanel.toolbar());

    ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());

    menuBar()->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());

    menuBar()->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());

    connect(&commandPanel, &CommandPanel::focusRequested, [this]()

            {

                this->ui->tabWidget->setCurrentWidget(&commandPanel);

                this->ui->tabWidget->showTabs();

            });

    tbPortControl->setObjectName("tbPortControl");

    ui->plotToolBar->setObjectName("tbPlot");

    setupAboutDialog();

    // init view menu

    ui->menuBar->insertMenu(ui->menuSecondary->menuAction(), &plotMenu);

    plotMenu.addSeparator();

    QMenu* tbMenu = plotMenu.addMenu("Toolbars");

    tbMenu->addAction(ui->plotToolBar->toggleViewAction());

    tbMenu->addAction(portControl.toolBar()->toggleViewAction());

    // init secondary plot menu

    auto group = new QActionGroup(this);

    group->addAction(ui->actionVertical);

    group->addAction(ui->actionHorizontal);

    // init UI signals

    // Secondary plot menu signals

    connect(ui->actionBarPlot, &QAction::triggered,

            this, &MainWindow::showBarPlot);

    connect(ui->actionVertical, &QAction::triggered,

            [this](bool checked)

            {

                if (checked) ui->splitter->setOrientation(Qt::Vertical);

            });

    connect(ui->actionHorizontal, &QAction::triggered,

            [this](bool checked)

            {

                     this, &MainWindow::close);

    // port control signals

    QObject::connect(&portControl, &PortControl::portToggled,

                     this, &MainWindow::onPortToggled);

    // plot control signals

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            this, &MainWindow::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            plotMan, &PlotManager::setNumOfSamples);

    connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

            plotMan, &PlotManager::setYAxis);

    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

            &stream, &Stream::setXAxis);

    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

            plotMan, &PlotManager::setXAxis);

    connect(&plotControlPanel, &PlotControlPanel::plotWidthChanged,

            plotMan, &PlotManager::setPlotWidth);

    // plot toolbar signals

    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

                     this, SLOT(clearPlot()));

    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

                     plotMan, &PlotManager::flashSnapshotOverlay);

    QObject::connect(ui->actionPause, &QAction::triggered,

                     &stream, &Stream::pause);

    QObject::connect(ui->actionPause, &QAction::triggered,

                     [this](bool enabled)

                     {

                         if (enabled && !recordPanel.recordPaused())

                         {

                             dataFormatPanel.pause(true);

                         }

                         else

                         {

                             dataFormatPanel.pause(false);

                         }

                     });

    QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,

                     [this](bool enabled)

                     {

                         if (ui->actionPause->isChecked() && enabled)

                         {

                             dataFormatPanel.pause(false);

                         }

                     });

    connect(&serialPort, &QIODevice::aboutToClose,

            &recordPanel, &RecordPanel::onPortClose);

    // init plot

    numOfSamples = plotControlPanel.numOfSamples();

    stream.setNumSamples(numOfSamples);

    plotControlPanel.setChannelInfoModel(stream.infoModel());

    // init scales

    stream.setXAxis(plotControlPanel.xAxisAsIndex(),

                    plotControlPanel.xMin(), plotControlPanel.xMax());

    plotMan->setYAxis(plotControlPanel.autoScale(),

                      plotControlPanel.yMin(), plotControlPanel.yMax());

    plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),

                      plotControlPanel.xMin(), plotControlPanel.xMax());

    plotMan->setNumOfSamples(numOfSamples);

    plotMan->setPlotWidth(plotControlPanel.plotWidth());

    // Init sps (sample per second) counter

    spsLabel.setText("0sps");

    spsLabel.setToolTip("samples per second (per channel)");

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

    connect(&sampleCounter, &SampleCounter::spsChanged,

            this, &MainWindow::onSpsChanged);

    // init demo

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

                     this, &MainWindow::enableDemo);

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

                     plotMan, &PlotManager::showDemoIndicator);

    // init stream connections

    connect(&dataFormatPanel, &DataFormatPanel::sourceChanged,

            this, &MainWindow::onSourceChanged);

    onSourceChanged(dataFormatPanel.activeSource());

    // load default settings

    loadAllSettings(&settings);

    // ensure command panel has 1 command if none loaded

    if (!commandPanel.numOfCommands())

    {

        commandPanel.newCommandAction()->trigger();

    }

    // Important: This should be after newCommandAction is triggered

    // (above) we don't want user to be greeted with command panel on

    // the very first run.

    connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()

            {

                this->ui->tabWidget->setCurrentWidget(&commandPanel);

                this->ui->tabWidget->showTabs();

            });

}

MainWindow::~MainWindow()

{

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete plotMan;

    delete ui;

    ui = NULL; // we check if ui is deleted in messageHandler

}

void MainWindow::closeEvent(QCloseEvent * event)

{

    // save snapshots

    if (!snapshotMan.isAllSaved())

    {

        auto clickedButton = QMessageBox::warning(

            this, "Closing SerialPlot",

            "There are un-saved snapshots. If you close you will loose the data.",

            QMessageBox::Discard, QMessageBox::Cancel);

        if (clickedButton == QMessageBox::Cancel)

        {

            event->ignore();

            return;

        }

    }

    // save settings

    saveAllSettings(&settings);

    settings.sync();

    if (settings.status() != QSettings::NoError)

    {

        QString errorText;

        if (settings.status() == QSettings::AccessError)

        {

            QString file = settings.fileName();

            errorText = QString("Serialplot cannot save settings due to access error. \

This happens if you have run serialplot as root (with sudo for ex.) previously. \

Try fixing the permissions of file: %1, or just delete it.").arg(file);

        }

        else

        {

            errorText = QString("Serialplot cannot save settings due to unknown error: %1").\

                arg(settings.status());

        }

        auto button = QMessageBox::critical(

            NULL,

            "Failed to save settings!", errorText,

            QMessageBox::Cancel | QMessageBox::Ok);

        if (button == QMessageBox::Cancel)

        {

            event->ignore();

            return;

        }

    }

    QMainWindow::closeEvent(event);

}

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::onSourceChanged(Source* source)

{

    source->connectSink(&stream);

    source->connectSink(&sampleCounter);

}

void MainWindow::clearPlot()

{

    stream.clear();

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    stream.setNumSamples(value);

    plotMan->replot();

}

void MainWindow::onSpsChanged(float sps)

{

    int precision = sps < 1. ? 3 : 0;

    spsLabel.setText(QString::number(sps, 'f', precision) + "sps");

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            dataFormatPanel.enableDemo(true);

        }

        else

        {

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    stream.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

    plotMenu.loadSettings(settings);

    commandPanel.loadSettings(settings);

    recordPanel.loadSettings(settings);

    textView.loadSettings(settings);

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

    }

}

void MainWindow::handleCommandLineOptions(const QCoreApplication &app)

{

    QCommandLineParser parser;

    parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsCompactedShortOptions);

    parser.setApplicationDescription("Small and simple software for plotting data from serial port in realtime.");

    parser.addHelpOption();

    parser.addVersionOption();

    QCommandLineOption portOpt({"p", "port"}, "Set port name.", "port name");

    QCommandLineOption baudrateOpt({"b" ,"baudrate"}, "Set port baud rate.", "baud rate");

    QCommandLineOption openPortOpt({"o", "open"}, "Open serial port.");

    parser.addOption(portOpt);

    parser.addOption(baudrateOpt);

    parser.addOption(openPortOpt);

    parser.process(app);

    {

        QFileInfo fileInfo(fileName);

        if (fileInfo.exists() && fileInfo.isFile())

        {

            QSettings settings(fileName, QSettings::IniFormat);

            loadAllSettings(&settings);

        }

        else

        {

        }

    }

    if (parser.isSet(portOpt))

    {

        portControl.selectPort(parser.value(portOpt));

    }

    if (parser.isSet(baudrateOpt))

    {

        portControl.selectBaudrate(parser.value(baudrateOpt));

    }

    if (parser.isSet(openPortOpt))

    {

        portControl.openPort();

    }

}