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

/*

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

#include "tooltipfilter.h"

#include "version.h"

void messageHandler(QtMsgType type, const QMessageLogContext &context,

                    const QString &msg)

{

}

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

{

    QApplication a(argc, argv);

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

}

  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 <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"}

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

{

    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 plotMenu.viewSettings();

}

void MainWindow::messageHandler(QtMsgType type,

                                const QString &msg)

{

    if (type != QtDebugMsg && ui != NULL)

    {

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

    }

}

void MainWindow::saveAllSettings(QSettings* settings)

{

    saveMWSettings(settings);

    portControl.saveSettings(settings);

    dataFormatPanel.saveSettings(settings);

    stream.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

    plotMenu.saveSettings(settings);

    commandPanel.saveSettings(settings);

    recordPanel.saveSettings(settings);

    textView.saveSettings(settings);

    updateCheckDialog.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    stream.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

    plotMenu.loadSettings(settings);

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

    }

}

#include "recordpanel.h"

#include "ui_about_dialog.h"

#include "stream.h"

#include "snapshotmanager.h"

#include "plotmanager.h"

#include "plotmenu.h"

#include "updatecheckdialog.h"

#include "samplecounter.h"

#include "datatextview.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    PlotViewSettings viewSettings() const;

private:

    Ui::MainWindow *ui;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    QList<QwtPlotCurve*> curves;

    // ChannelManager channelMan;

    Stream stream;

    PlotManager* plotMan;

    QWidget* secondaryPlot;

    SnapshotManager snapshotMan;

    SampleCounter sampleCounter;

    QLabel spsLabel;

    CommandPanel commandPanel;

    DataFormatPanel dataFormatPanel;

    RecordPanel recordPanel;

    PlotControlPanel plotControlPanel;

    PlotMenu plotMenu;

    DataTextView textView;

    UpdateCheckDialog updateCheckDialog;

    /// Returns true if demo is running

    bool isDemoRunning();

    /// Display a secondary plot in the splitter, removing and

    /// deleting previous one if it exists

    void showSecondary(QWidget* wid);

    /// Hide secondary plot

    void hideSecondary();

    /// Stores settings for all modules

    void saveAllSettings(QSettings* settings);

    /// Load settings for all modules

    void loadAllSettings(QSettings* settings);

    /// Stores main window settings into a `QSettings`

    void saveMWSettings(QSettings* settings);

    /// Loads main window settings from a `QSettings`

    void loadMWSettings(QSettings* settings);

    /// `QWidget::closeEvent` handler

    void closeEvent(QCloseEvent * event);

private slots:

    void onPortToggled(bool open);

    void onSourceChanged(Source* source);

    void onNumOfSamplesChanged(int value);

    QObject::connect(&openAction, &QAction::triggered,

                     this, &PortControl::openActionTriggered);

    loadPortListAction.setToolTip("Reload port list");

    QObject::connect(&loadPortListAction, &QAction::triggered,

                     [this](bool checked){loadPortList();});

    // setup toolbar

    portToolBar.addWidget(&tbPortList);

    portToolBar.addAction(&loadPortListAction);

    portToolBar.addAction(&openAction);

    // setup port selection widgets

    tbPortList.setMinimumWidth(TBPORTLIST_MINWIDTH);

    tbPortList.setModel(&portList);

    ui->cbPortList->setModel(&portList);

    QObject::connect(ui->cbPortList,

                     SELECT<int>::OVERLOAD_OF(&QComboBox::activated),

                     this, &PortControl::onCbPortListActivated);

    QObject::connect(&tbPortList,

                     SELECT<int>::OVERLOAD_OF(&QComboBox::activated),

                     this, &PortControl::onTbPortListActivated);

    QObject::connect(ui->cbPortList,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

    QObject::connect(&tbPortList,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

    // setup buttons

    ui->pbOpenPort->setDefaultAction(&openAction);

    ui->pbReloadPorts->setDefaultAction(&loadPortListAction);

    // setup baud rate selection widget

    QObject::connect(ui->cbBaudRate,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

    // setup parity selection buttons

    parityButtons.addButton(ui->rbNoParity, (int) QSerialPort::NoParity);

    parityButtons.addButton(ui->rbEvenParity, (int) QSerialPort::EvenParity);

    parityButtons.addButton(ui->rbOddParity, (int) QSerialPort::OddParity);

    QObject::connect(&parityButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &PortControl::selectParity);

    // setup data bits selection buttons

    dataBitsButtons.addButton(ui->rb8Bits, (int) QSerialPort::Data8);

    dataBitsButtons.addButton(ui->rb7Bits, (int) QSerialPort::Data7);

    dataBitsButtons.addButton(ui->rb6Bits, (int) QSerialPort::Data6);

    dataBitsButtons.addButton(ui->rb5Bits, (int) QSerialPort::Data5);

    QObject::connect(&dataBitsButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &PortControl::selectDataBits);

    // setup stop bits selection buttons

    stopBitsButtons.addButton(ui->rb1StopBit, (int) QSerialPort::OneStop);

    stopBitsButtons.addButton(ui->rb2StopBit, (int) QSerialPort::TwoStop);

}

void PortControl::loadPortList()

{

    QString currentSelection = ui->cbPortList->currentData(PortNameRole).toString();

    portList.loadPortList();

    int index = portList.indexOf(currentSelection);

    if (index >= 0)

    {

        ui->cbPortList->setCurrentIndex(index);

        tbPortList.setCurrentIndex(index);

    }

}

void PortControl::loadBaudRateList()

{

    ui->cbBaudRate->clear();

    for (auto baudRate : QSerialPortInfo::standardBaudRates())

    {

        ui->cbBaudRate->addItem(QString::number(baudRate));

    }

}

{

    if (serialPort->isOpen())

    {

        if (!serialPort->setBaudRate(baudRate.toInt()))

        {

            qCritical() << "Can't set baud rate!";

        }

    }

}

void PortControl::selectParity(int parity)

{

    if (serialPort->isOpen())

    {

        if(!serialPort->setParity((QSerialPort::Parity) parity))

        {

            qCritical() << "Can't set parity option!";

        }

    }

}

void PortControl::selectDataBits(int dataBits)

{

    if (serialPort->isOpen())

        // in the portList if user hasn't pressed Enter

        // Also note that, portText may not be the `portName`

        QString portText = ui->cbPortList->currentText();

        QString portName;

        int portIndex = portList.indexOf(portText);

        if (portIndex < 0) // not in list, add to model and update the selections

        {

            portList.appendRow(new PortListItem(portText));

            ui->cbPortList->setCurrentIndex(portList.rowCount()-1);

            tbPortList.setCurrentIndex(portList.rowCount()-1);

            portName = portText;

        }

        else

        {

            // get the port name from the data field

            portName = static_cast<PortListItem*>(portList.item(portIndex))->portName();

        }

        serialPort->setPortName(ui->cbPortList->currentData(PortNameRole).toString());

        // open port

        if (serialPort->open(QIODevice::ReadWrite))

        {

            // set port settings

            selectParity((QSerialPort::Parity) parityButtons.checkedId());

            selectDataBits((QSerialPort::DataBits) dataBitsButtons.checkedId());

            selectStopBits((QSerialPort::StopBits) stopBitsButtons.checkedId());

            selectFlowControl((QSerialPort::FlowControl) flowControlButtons.checkedId());

            // set output signals

            serialPort->setDataTerminalReady(ui->ledDTR->isOn());

            serialPort->setRequestToSend(ui->ledRTS->isOn());

            // update pin signals

            updatePinLeds();

            pinUpdateTimer.start();

            qDebug() << "Opened port:" << serialPort->portName();

            emit portToggled(true);

        }

    }

    openAction.setChecked(serialPort->isOpen());

}

{

    // portName may be coming from combobox

    portName = portName.split(" ")[0];

    // has selection actually changed

    if (portName != serialPort->portName())

    {

        // if another port is already open, close it by toggling

        if (serialPort->isOpen())

        {

            togglePort();

            // open new selection by toggling

            togglePort();

        }

    }

}

QString PortControl::selectedPortName()

{

    QString portText = ui->cbPortList->currentText();

    int portIndex = portList.indexOf(portText);

    if (portIndex < 0) // not in the list yet

    {

        // return the displayed name as port name

        return portText;

    }

    else

}

QString PortControl::currentParityText()

{

    return paritySettingMap.value(

        (QSerialPort::Parity) parityButtons.checkedId());

}

QString PortControl::currentFlowControlText()

{

    if (flowControlButtons.checkedId() == QSerialPort::HardwareControl)

    {

        return "hardware";

    }

    else if (flowControlButtons.checkedId() == QSerialPort::SoftwareControl)

    {

        return "software";

    }

    else // no parity

    {

        return "none";

    }

}

void PortControl::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Port);

    settings->setValue(SG_Port_SelectedPort, selectedPortName());

    settings->setValue(SG_Port_BaudRate, ui->cbBaudRate->currentText());

    settings->setValue(SG_Port_Parity, currentParityText());

    settings->setValue(SG_Port_DataBits, dataBitsButtons.checkedId());

    settings->setValue(SG_Port_StopBits, stopBitsButtons.checkedId());

    settings->setValue(SG_Port_FlowControl, currentFlowControlText());

    settings->endGroup();

}

void PortControl::loadSettings(QSettings* settings)

{

    // make sure the port is closed

    if (serialPort->isOpen()) togglePort();

    settings->beginGroup(SettingGroup_Port);

    // set port name if it exists in the current list otherwise ignore

    QString portName = settings->value(SG_Port_SelectedPort, QString()).toString();

    if (!portName.isEmpty())

    {

        int index = portList.indexOfName(portName);

        if (index > -1) ui->cbPortList->setCurrentIndex(index);

    }

    // load baud rate setting if it exists in baud rate list

    QString baudSetting = settings->value(

        SG_Port_BaudRate, ui->cbBaudRate->currentText()).toString();

    int baudIndex = ui->cbBaudRate->findText(baudSetting);

    if (baudIndex > -1) ui->cbBaudRate->setCurrentIndex(baudIndex);

    // load parity setting

    QString parityText =

        settings->value(SG_Port_Parity, currentParityText()).toString();

    QSerialPort::Parity paritySetting = paritySettingMap.key(

        parityText, (QSerialPort::Parity) parityButtons.checkedId());

    parityButtons.button(paritySetting)->setChecked(true);

    // load number of bits

    if (dataBits >=5 && dataBits <= 8)