/*

  Copyright © 2016 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 <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 "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

const QMap<int, QString> panelSettingMap({

        {0, "Port"},

        {1, "DataFormat"},

        {2, "Plot"},

        {3, "Commands"}

    });

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    channelMan(1, 1, this),

    snapshotMan(this, &channelMan),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort, &channelMan)

{

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea);

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

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

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

    // init auto scale

    plotMan->setAxis(plotControlPanel.autoScale(),

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

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

    // load default settings

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

    loadAllSettings(&settings);

    // ensure command panel has 1 command if none loaded

    if (!commandPanel.numOfCommands())

    {

        commandPanel.newCommandAction()->trigger();

    }

}

MainWindow::~MainWindow()

{

    // save settings

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

    saveAllSettings(&settings);

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete plotMan;

    delete ui;

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

}

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::onPortError(QSerialPort::SerialPortError error)

{

    switch(error)

    {

        case QSerialPort::NoError :

            break;

        case QSerialPort::ResourceError :

            qWarning() << "Port error: resource unavaliable; most likely device removed.";

            if (serialPort.isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort.portName();

                portControl.togglePort();

            }

            portControl.loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort.portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

            qCritical() << "Device is not open!";

#include "plotmanager.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    void messageHandler(QtMsgType type, const QMessageLogContext &context,

                        const QString &msg);

private:

    Ui::MainWindow *ui;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    QList<QwtPlotCurve*> curves;

    ChannelManager channelMan;

    PlotManager* plotMan;

    SnapshotManager snapshotMan;

    QLabel spsLabel;

    CommandPanel commandPanel;

    DataFormatPanel dataFormatPanel;

    PlotControlPanel plotControlPanel;

    bool isDemoRunning();

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

private slots:

    void onPortToggled(bool open);

    void onPortError(QSerialPort::SerialPortError error);

    void onNumOfSamplesChanged(int value);

    void onNumOfChannelsChanged(unsigned value);

    void onChannelNameChanged(unsigned channel, QString name);

    void clearPlot();

    void onSpsChanged(unsigned sps);

    void enableDemo(bool enabled);

    void onExportCsv();

    void onSaveSettings();

    void onLoadSettings();

};

#endif // MAINWINDOW_H

/*

  Copyright © 2015 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 <stddef.h>

#include <QSaveFile>

#include <QTextStream>

#include "snapshot.h"

#include "snapshotview.h"

Snapshot::Snapshot(QMainWindow* parent, QString name) :

    QObject(parent),

    _showAction(name, this),

    _deleteAction("Delete", this)

{

    _name = name;

    view = NULL;

    mainWindow = parent;

    connect(&_showAction, &QAction::triggered, this, &Snapshot::show);

    _deleteAction.setToolTip(QString("Delete ") + _name);

    connect(&_deleteAction, &QAction::triggered, this, &Snapshot::onDeleteTriggered);

}

Snapshot::~Snapshot()

{

    if (view != NULL)

    {

        delete view;

    }

}

QAction* Snapshot::showAction()

{

    return &_showAction;

}

QAction* Snapshot::deleteAction()

{

    return &_deleteAction;

}

void Snapshot::show()

{

    if (view == NULL)

    {

        view = new SnapshotView(mainWindow, this);

        connect(view, &SnapshotView::closed, this, &Snapshot::viewClosed);

    }

    view->show();

    view->activateWindow();

    view->raise();

}

void Snapshot::viewClosed()

{

    view->deleteLater();

    view = NULL;

}

void Snapshot::onDeleteTriggered()

{

    emit deleteRequested(this);

    emit nameChanged(this);

}

void Snapshot::setChannelNames(QStringList names)

{

    _channelNames = names;

}

QString Snapshot::channelName(unsigned channel)

{

    return _channelNames[channel];

}

void Snapshot::save(QString fileName)

{

    // TODO: remove code duplication (MainWindow::onExportCsv)

    QSaveFile file(fileName);

    if (file.open(QIODevice::WriteOnly | QIODevice::Text))

    {

        QTextStream fileStream(&file);

        unsigned numOfChannels = data.size();

        unsigned numOfSamples = data[0].size();

        // print header

        for (unsigned int ci = 0; ci < numOfChannels; ci++)

        {

            fileStream << channelName(ci);

            if (ci != numOfChannels-1) fileStream << ",";

        }

        fileStream << '\n';

        // print rows

        for (unsigned int i = 0; i < numOfSamples; i++)

        {

            for (unsigned int ci = 0; ci < numOfChannels; ci++)

            {

                fileStream << data[ci][i].y();

                if (ci != numOfChannels-1) fileStream << ",";

            }

            fileStream << '\n';

        }

        if (!file.commit())

        {

            qCritical() << "File save error during snapshot save: " << file.error();

        }

    }

    else

    {

        qCritical() << "File open error during snapshot save: " << file.error();

    }

}

/*

  Copyright © 2015 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 SNAPSHOT_H

#define SNAPSHOT_H

#include <QObject>

#include <QMainWindow>

#include <QAction>

#include <QVector>

#include <QString>

#include <QStringList>

class SnapshotView;

class Snapshot : public QObject

{

    Q_OBJECT

public:

    Snapshot(QMainWindow* parent, QString name);

    ~Snapshot();

    QVector<QVector<QPointF>> data;

    QAction* showAction();

    QAction* deleteAction();

    QString name();

    void setName(QString name);

    void setChannelNames(QStringList names); // must be called when setting data!

    QString channelName(unsigned channel);

signals:

    void deleteRequested(Snapshot*);

    void nameChanged(Snapshot*);

private:

    QString _name;

    QStringList _channelNames;

    QAction _showAction;

    QAction _deleteAction;

    QMainWindow* mainWindow;

    SnapshotView* view;

private slots:

    void show();

    void viewClosed();

    void onDeleteTriggered();

};

#endif /* SNAPSHOT_H */

    unsigned lineNum = 1;

    while (file.canReadLine())

    {

        // parse line

        auto line = QString(file.readLine());

        auto split = line.split(',');

        if (split.size() != (int) numOfChannels)

        {

            qCritical() << "Parsing error at line " << lineNum

                        << ": number of columns is not consistent.";

            return;

        }

        for (unsigned ci = 0; ci < numOfChannels; ci++)

        {

            // parse column

            bool ok;

            double y = split[ci].toDouble(&ok);

            if (!ok)

            {

                qCritical() << "Parsing error at line " << lineNum

                            << ", column " << ci

                            << ": can't convert \"" << split[ci]

                            << "\" to double.";

                return;

            }

            data[ci].append(QPointF(lineNum-1, y));

        }

        lineNum++;

    }

    auto snapshot = new Snapshot(_mainWindow, QFileInfo(fileName).baseName());

    snapshot->data = data;

    snapshot->setChannelNames(channelNames);

    addSnapshot(snapshot, false);

}

QMenu* SnapshotManager::menu()

{

    return &_menu;

}

QAction* SnapshotManager::takeSnapshotAction()

{

    return &_takeSnapshotAction;

}

/*

  Copyright © 2015 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 SNAPSHOTMANAGER_H

#define SNAPSHOTMANAGER_H

#include <QObject>

#include <QAction>

#include <QMenu>

#include "framebuffer.h"

#include "channelmanager.h"

#include "snapshot.h"

class SnapshotManager : public QObject

{

    Q_OBJECT

public:

    SnapshotManager(QMainWindow* mainWindow, ChannelManager* channelMan);

    ~SnapshotManager();

    QMenu* menu();

    QAction* takeSnapshotAction();

    /// Creates a dynamically allocated snapshot object but doesn't record it in snapshots list.

    /// @note Caller is responsible for deletion of the returned `Snapshot` object.

    Snapshot* makeSnapshot();

private:

    QMainWindow* _mainWindow;

    ChannelManager* _channelMan;

    QList<Snapshot*> snapshots;

    QMenu _menu;

    QAction _takeSnapshotAction;

    QAction loadSnapshotAction;

    QAction clearAction;

    void addSnapshot(Snapshot* snapshot, bool update_menu=true);

    void updateMenu();

private slots:

    void takeSnapshot();

    void clearSnapshots();

    void deleteSnapshot(Snapshot* snapshot);

    void loadSnapshots();

    void loadSnapshotFromFile(QString fileName);

};

#endif /* SNAPSHOTMANAGER_H */