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,

            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

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

    QObject::connect(&dataFormatPanel,

                     &DataFormatPanel::samplesPerSecondChanged,

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

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

    }

    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

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

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

{

    // connect to new source

    source->connectSink(&stream);

}

void MainWindow::clearPlot()

{

    stream.clear();

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    stream.setNumSamples(value);

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

    secondaryPlot = NULL;

}

void MainWindow::showBarPlot(bool show)

{

    if (show)

    {

        auto plot = new BarPlot(&stream, &plotMenu);

        plot->setYAxis(plotControlPanel.autoScale(),

                       plotControlPanel.yMin(),

                       plotControlPanel.yMax());

        connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

                plot, &BarPlot::setYAxis);

        showSecondary(plot);

    }

    else

    {

        hideSecondary();

    }

}

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

    stream.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

    plotMenu.saveSettings(settings);

    commandPanel.saveSettings(settings);

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

    commandPanel.loadSettings(settings);

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

/*

  Copyright © 2018 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 <QtGlobal>

#include "sink.h"

void Sink::connectFollower(Sink* sink)

{

    Q_ASSERT(!followers.contains(sink));

    followers.append(sink);

    sink->setNumChannels(_numChannels, _hasX);

}

void Sink::disconnectFollower(Sink* sink)

{

    Q_ASSERT(followers.contains(sink));

    followers.removeOne(sink);

}

void Sink::feedIn(const SamplePack& data)

{

    for (auto sink : followers)

    {

        sink->feedIn(data);

    }

}

void Sink::setNumChannels(unsigned nc, bool x)

{

    _numChannels = nc;

    _hasX = x;

    for (auto sink : followers)

    {

        sink->setNumChannels(nc, x);

    }

}

{

    Q_ASSERT((source == nullptr) != (s == nullptr));

    source = s;

}

const Source* Sink::connectedSource() const

{

    return source;

}

Source* Sink::connectedSource()

{

    return const_cast<Source*>(static_cast<const Sink&>(*this).connectedSource());

}

/*

  Copyright © 2018 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 SINK_H

#define SINK_H

#include <QList>

#include "samplepack.h"

class Source;

class Sink

{

public:

    /// Placeholder virtual destructor

    virtual ~Sink() {};

    /// Connects a sink to get any data that this sink

    /// gets. Connecting an already connected sink is an error.

    void connectFollower(Sink* sink);

    /// Disconnects a follower. Disconnecting an unconnected sink is

    /// an error.

    void disconnectFollower(Sink* sink);

    /// Returns the connected source. `nullptr` if it's not connected.

    const Source* connectedSource() const;

    Source* connectedSource();

protected:

    /// Entry point for incoming data. Re-implementations should

    /// call this function to feed followers.

    virtual void feedIn(const SamplePack& data);

    /// Is set by connected source. Re-implementations should call

    /// this function to update followers.

    virtual void setNumChannels(unsigned nc, bool x);

    /// Set by the connected source when its connected. When

    ///

    /// @important Trying to connect a source while its already

    /// connected is an error.

    friend Source;

private:

    QList<Sink*> followers;

    bool _hasX;

    unsigned _numChannels;

};

#endif // SINK_H

/*

  Copyright © 2018 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 <QtGlobal>

#include "source.h"

Source::~Source()

{

    for (auto sink : sinks)

    {

        sink->setSource(nullptr);

    }

}

void Source::connectSink(Sink* sink)

{

    Q_ASSERT(!sinks.contains(sink));

    sinks.append(sink);

    sink->setSource(this);

    sink->setNumChannels(numChannels(), hasX());

}

void Source::disconnect(Sink* sink)

{

    Q_ASSERT(sinks.contains(sink));

    Q_ASSERT(sink->connectedSource() == this);

    sink->setSource(nullptr);

    sinks.removeOne(sink);

}

void Source::disconnectSinks()

{

    while (!sinks.isEmpty())

    {

        auto sink = sinks.takeFirst();

        sink->setSource(nullptr);

    }

}

void Source::feedOut(const SamplePack& data) const

{

    for (auto sink : sinks)

    {

        sink->feedIn(data);

    }

}

void Source::updateNumChannels() const

{

    for (auto sink : sinks)

    {

        sink->setNumChannels(numChannels(), hasX());

    }

}

/*

  Copyright © 2018 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 SOURCE_H

#define SOURCE_H

#include <QList>

#include "sink.h"

#include "samplepack.h"

class Source

{

public:

    /// Virtual destructor. Must be called by implementors to notify sinks.

    virtual ~Source();

    /// Returns true if source has X data

    virtual bool hasX() const = 0;

    /// Returns number of channels

    virtual unsigned numChannels() const = 0;

    void connectSink(Sink* sink);

    /// Disconnects an already connected sink. Trying to disconnect an

    /// unconnected sink is an error.

    void disconnect(Sink* sink);

    /// Disconnects all connected sinks.

    void disconnectSinks();

protected:

    /// Feeds "in" given data to connected sinks

    virtual void feedOut(const SamplePack& data) const;

    /// Updates "number of channels" of connected sinks. Must be

    /// called when num. channels or hasX changes.

    void updateNumChannels() const;

private:

    QList<Sink*> sinks;

};

#endif // SOURCE_H