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

    });

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

                     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 bps (bits per second) counter

    bpsLabel.setText("0bps");

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

    connect(&bpsTimer, &QTimer::timeout,

            this, &MainWindow::onBpsTimeout);

    // Init sps (sample per second) counter

    spsLabel.setText("0sps");

    spsLabel.setToolTip(tr("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

    QSettings settings("serialplot", "serialplot");

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

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

    if (open)

    {

        bpsTimer.start(1000);

    }

    else

    {

        bpsTimer.stop();

        // if not cleared last displayed value is stuck

        bpsLabel.setText("0bps");

        spsLabel.setText("0sps");

    }

}

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

}

void MainWindow::onBpsTimeout()

{

    unsigned bits = dataFormatPanel.getBytesRead() * 8;

}

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::showSecondary(QWidget* wid)

{

    if (secondaryPlot != NULL)

    {

        secondaryPlot->deleteLater();

    }

    secondaryPlot = wid;

    ui->splitter->addWidget(wid);

    ui->splitter->setStretchFactor(0, 1);

    ui->splitter->setStretchFactor(1, 0);

}

void MainWindow::hideSecondary()

{

    if (secondaryPlot == NULL)

    {

        qFatal("Secondary plot doesn't exist!");

    }

    secondaryPlot->deleteLater();

/*

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

#include "ui_portcontrol.h"

#include <QSerialPortInfo>

#include <QKeySequence>

#include <QLabel>

#include <QMap>

#include <QtDebug>

#include "setting_defines.h"

#include "utils.h"

#define TBPORTLIST_MINWIDTH (200)

// setting mappings

const QMap<QSerialPort::Parity, QString> paritySettingMap({

        {QSerialPort::NoParity, "none"},

        {QSerialPort::OddParity, "odd"},

        {QSerialPort::EvenParity, "even"},

    });

PortControl::PortControl(QSerialPort* port, QWidget* parent) :

    QWidget(parent),

    ui(new Ui::PortControl),

    portToolBar("Port Toolbar"),

    openAction("Open", this),

    loadPortListAction("↺", this)

{

    ui->setupUi(this);

    serialPort = port;

            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 PortControl::updatePinLeds(void)

{

    auto pins = serialPort->pinoutSignals();

    ui->ledDCD->setOn(pins & QSerialPort::DataCarrierDetectSignal);

    ui->ledDSR->setOn(pins & QSerialPort::DataSetReadySignal);

    ui->ledRI->setOn(pins & QSerialPort::RingIndicatorSignal);

    ui->ledCTS->setOn(pins & QSerialPort::ClearToSendSignal);

}

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

    int dataBits = settings->value(SG_Port_Parity, dataBitsButtons.checkedId()).toInt();

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

    {

        dataBitsButtons.button((QSerialPort::DataBits) dataBits)->setChecked(true);

    }

    // load stop bits

/*

  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 PORTCONTROL_H

#define PORTCONTROL_H

#include <QWidget>

#include <QButtonGroup>

#include <QSerialPort>

#include <QStringList>

#include <QToolBar>

#include <QAction>

#include <QComboBox>

#include <QSettings>

#include <QTimer>

#include "portlist.h"

namespace Ui {

class PortControl;

}

class PortControl : public QWidget

{

    Q_OBJECT

public:

    explicit PortControl(QSerialPort* port, QWidget* parent = 0);

    ~PortControl();

    QSerialPort* serialPort;

    QToolBar* toolBar();

    /// Stores port settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads port settings from a `QSettings`. If open serial port is closed.

    void loadSettings(QSettings* settings);

private:

    Ui::PortControl *ui;

    QButtonGroup parityButtons;

    QButtonGroup dataBitsButtons;

    QButtonGroup stopBitsButtons;

    QButtonGroup flowControlButtons;

    QToolBar portToolBar;

    QAction openAction;

    QAction loadPortListAction;

    QComboBox tbPortList;

    PortList portList;

    /// Used to refresh pinout signal leds periodically

    QTimer pinUpdateTimer;

    /// Returns the currently selected (entered) "portName" in the UI

    QString selectedPortName();

    /// Returns currently selected parity as text to be saved in settings

    QString currentParityText();

    /// Returns currently selected flow control as text to be saved in settings

    QString currentFlowControlText();

public slots:

    void loadPortList();

    void loadBaudRateList();

    void togglePort();

    void selectPort(QString portName);

    void selectBaudRate(QString baudRate);

    void selectParity(int parity); // parity must be one of QSerialPort::Parity

    void selectDataBits(int dataBits); // bits must be one of QSerialPort::DataBits

    void selectStopBits(int stopBits); // stopBits must be one of QSerialPort::StopBits

    void selectFlowControl(int flowControl); // flowControl must be one of QSerialPort::FlowControl

private slots:

    void openActionTriggered(bool checked);

    void onCbPortListActivated(int index);

    void onTbPortListActivated(int index);

    void onPortError(QSerialPort::SerialPortError error);

    void updatePinLeds(void);