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

#include "setting_defines.h"

#define NUMOF_COLORS  (32)

const QColor colors[NUMOF_COLORS] =

{

    QColor("#ff0056"),

    QColor("#7e2dd2"),

    QColor("#00ae7e"),

    QColor("#fe8900"),

    QColor("#ff937e"),

    QColor("#6a826c"),

    QColor("#ff029d"),

    QColor("#00b917"),

    QColor("#7a4782"),

    QColor("#85a900"),

    QColor("#a42400"),

    QColor("#683d3b"),

    QColor("#bdc6ff"),

    QColor("#263400"),

    QColor("#bdd393"),

    QColor("#d5ff00"),

    QColor("#9e008e"),

    QColor("#001544"),

    QColor("#c28c9f"),

    QColor("#ff74a3"),

    QColor("#01d0ff"),

    QColor("#004754"),

    QColor("#e56ffe"),

    QColor("#788231"),

    QColor("#0e4ca1"),

    QColor("#91d0cb"),

    QColor("#be9970"),

    QColor("#968ae8"),

    QColor("#bb8800"),

    QColor("#43002c"),

    QColor("#deff74"),

    QColor("#00ffc6")

};

ChannelInfoModel::ChannelInfoModel(unsigned numberOfChannels, QObject* parent) :

    QAbstractTableModel(parent)

{

    _numOfChannels = 0;

    setNumOfChannels(numberOfChannels);

}

ChannelInfoModel::ChannelInfoModel(const ChannelInfoModel& other) :

    ChannelInfoModel(other.rowCount(), other.parent())

{

    for (int i = 0; i < other.rowCount(); i++)

    {

        setData(index(i, COLUMN_NAME),

                other.data(other.index(i, COLUMN_NAME), Qt::EditRole),

                Qt::EditRole);

        setData(index(i, COLUMN_NAME),

                other.data(other.index(i, COLUMN_NAME), Qt::ForegroundRole),

                Qt::ForegroundRole);

        setData(index(i, COLUMN_VISIBILITY),

                other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),

                Qt::CheckStateRole);

    }

}

ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :

    ChannelInfoModel(channelNames.length(), NULL)

{

    for (int i = 0; i < channelNames.length(); i++)

    {

        setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);

    }

}

ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)

{

    name = tr("Channel %1").arg(index + 1);

    visibility = true;

    color = colors[index % NUMOF_COLORS];

}

{

    return infos[i].name;

}

{

    return infos[i].color;

}

{

    return infos[i].visibility;

}

int ChannelInfoModel::rowCount(const QModelIndex &parent) const

{

    return _numOfChannels;

}

int ChannelInfoModel::columnCount(const QModelIndex & parent) const

{

    return COLUMN_COUNT;

}

Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const

{

    if (index.column() == COLUMN_NAME)

    {

        return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;

    }

    else if (index.column() == COLUMN_VISIBILITY)

    {

        return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;

    }

    return Qt::NoItemFlags;

}

QVariant ChannelInfoModel::data(const QModelIndex &index, int role) const

{

    // check index

    if (index.row() >= (int) _numOfChannels || index.row() < 0)

    {

        return QVariant();

    }

    // get color

    if (role == Qt::ForegroundRole)

    {

        return infos[index.row()].color;

    }

    // get name

    if (index.column() == COLUMN_NAME)

    {

        if (role == Qt::DisplayRole || role == Qt::EditRole)

        {

            return QVariant(infos[index.row()].name);

        }

    } // get visibility

    else if (index.column() == COLUMN_VISIBILITY)

    {

        if (role == Qt::CheckStateRole)

        {

            bool visible = infos[index.row()].visibility;

            return visible ? Qt::Checked : Qt::Unchecked;

        }

    }

    return QVariant();

}

QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const

{

    if (orientation == Qt::Horizontal)

    {

        if (role == Qt::DisplayRole)

        {

            if (section == COLUMN_NAME)

            {

                return tr("Channel");

            }

            else if (section == COLUMN_VISIBILITY)

            {

                return tr("Visible");

            }

        }

    }

    else                        // vertical

    {

        if (section < (int) _numOfChannels && role == Qt::DisplayRole)

        {

            return QString::number(section + 1);

        }

    }

    return QVariant();

}

bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)

{

    // check index

    if (index.row() >= (int) _numOfChannels || index.row() < 0)

    {

        return false;

    }

    // set color

    if (role == Qt::ForegroundRole)

    {

/*

  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/>.

*/

#ifndef CHANNELINFOMODEL_H

#define CHANNELINFOMODEL_H

#include <QAbstractTableModel>

#include <QColor>

#include <QSettings>

#include <QStringList>

class ChannelInfoModel : public QAbstractTableModel

{

    Q_OBJECT

public:

    enum ChannelInfoColumn

    {

        COLUMN_NAME = 0,

        COLUMN_VISIBILITY,

        COLUMN_COUNT

    };

    explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);

    ChannelInfoModel(const ChannelInfoModel& other);

    explicit ChannelInfoModel(const QStringList& channelNames);

    // implemented from QAbstractItemModel

    int           rowCount(const QModelIndex &parent = QModelIndex()) const;

    int           columnCount(const QModelIndex &parent = QModelIndex()) const;

    QVariant      data(const QModelIndex &index, int role = Qt::DisplayRole) const;

    bool          setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);

    Qt::ItemFlags flags(const QModelIndex &index) const;

    QVariant      headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;

    void setNumOfChannels(unsigned number);

    /// Stores all channel info into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads all channel info from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    /// reset all channel info (names, color etc.)

    void resetInfos();

    /// reset all channel names

    void resetNames();

    /// reset all channel colors

    void resetColors();

    /// reset visibility

    void resetVisibility();

private:

    struct ChannelInfo

    {

        explicit ChannelInfo(unsigned index);

        QString name;

        bool visibility;

        QColor color;

    };

    unsigned _numOfChannels;     ///< @note this is not necessarily the length of `infos`

    /**

     * Channel info is added here but never removed so that we can

     * remember user entered info (names, colors etc.).

     */

    QList<ChannelInfo> infos;

};

#endif // CHANNELINFOMODEL_H

/*

  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/>.

*/

#ifndef CHANNELMANAGER_H

#define CHANNELMANAGER_H

#include <QObject>

#include <QStringList>

#include <QModelIndex>

#include <QVector>

#include <QSettings>

#include "framebuffer.h"

#include "channelinfomodel.h"

class ChannelManager : public QObject

{

    Q_OBJECT

public:

    explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);

    ~ChannelManager();

    unsigned numOfChannels();

    unsigned numOfSamples();

    FrameBuffer* channelBuffer(unsigned channel);

    QString channelName(unsigned channel);

    /// Stores channel names into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads channel names from a `QSettings`.

    void loadSettings(QSettings* settings);

    /// Returns a model that manages channel information (name, color etc)

    ChannelInfoModel* infoModel();

    /// Returns a list of channel names

    QStringList channelNames();

signals:

    void numOfChannelsChanged(unsigned value);

    void numOfSamplesChanged(unsigned value);

    void channelNameChanged(unsigned channel, QString name);

    void dataAdded(); ///< emitted when data added to channel man.

public slots:

    void setNumOfChannels(unsigned number);

    void setNumOfSamples(unsigned number);

    /**

     * Add data for all channels.

     *

     * All channels data is provided in a single array which contains equal

     * number of samples for all channels. Structure is as shown below:

     *

     * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]

     *

     * @param data samples for all channels

     * @param size size of `data`, must be multiple of `numOfChannels`

     */

    void addData(double* data, unsigned size);

    /// When paused `addData` does nothing.

    void pause(bool paused);

private:

    unsigned _numOfChannels;

    unsigned _numOfSamples;

    bool _paused;

    QList<FrameBuffer*> channelBuffers;

    // QStringListModel _channelNames;

    ChannelInfoModel _infoModel;

    void addChannelName(QString name); ///< appends a new channel name at the end of list

private slots:

    void onChannelInfoChanged(const QModelIndex & topLeft,

                              const QModelIndex & bottomRight,

                              const QVector<int> & roles = QVector<int> ());

};

#endif // CHANNELMANAGER_H

/*

  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 "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 "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, &recorder),

{

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());

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

    auto tbPortControl = portControl.toolBar();

    addToolBar(tbPortControl);

    addToolBar(recordPanel.toolbar());

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

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

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

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

            {

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

            });

    tbPortControl->setObjectName("tbPortControl");

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

    setupAboutDialog();

    // init view menu

    for (auto a : plotMan->menuActions())

    {

        ui->menuView->addAction(a);

    }

    ui->menuView->addSeparator();

    QMenu* tbMenu = ui->menuView->addMenu("Toolbars");

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

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

    // init UI signals

    // Help menu signals

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

              &aboutDialog, &QWidget::show);

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

                     [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});

    // File menu signals

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

                     this, &MainWindow::onExportCsv);

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

                     this, &MainWindow::onSaveSettings);

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

                     this, &MainWindow::onLoadSettings);

    ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);

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

                     this, &MainWindow::close);

    // port control signals

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

                     this, &MainWindow::onPortToggled);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            this, &MainWindow::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            plotMan, &PlotManager::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::scaleChanged,

            plotMan, &PlotManager::setAxis);

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

                     this, SLOT(clearPlot()));

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

                     plotMan, &PlotManager::flashSnapshotOverlay);

    // init port signals

    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

    // init data format and reader

    QObject::connect(&channelMan, &ChannelManager::dataAdded,

                     plotMan, &PlotManager::replot);

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

                     &channelMan, &ChannelManager::pause);

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

/*

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

#include "ui_recordpanel.h"

#include <QIcon>

#include <QFile>

#include <QFileInfo>

#include <QMessageBox>

#include <QFileDialog>

#include <QRegularExpression>

#include <QtDebug>

    QWidget(parent),

    ui(new Ui::RecordPanel),

    recordToolBar(tr("Record Toolbar")),

    recordAction(QIcon::fromTheme("media-record"), tr("Record"), this)

{

    overwriteSelected = false;

    _recorder = recorder;

    ui->setupUi(this);

    recordToolBar.setObjectName("tbRecord");

    recordAction.setCheckable(true);

    recordToolBar.addAction(&recordAction);

    ui->pbRecord->setDefaultAction(&recordAction);

    connect(ui->pbBrowse, &QPushButton::clicked,

            this, &RecordPanel::selectFile);

    connect(&recordAction, &QAction::triggered,

            this, &RecordPanel::onRecord);

    connect(ui->cbRecordPaused, SIGNAL(toggled(bool)),

            this, SIGNAL(recordPausedChanged(bool)));

    connect(ui->cbDisableBuffering, &QCheckBox::toggled,

            [this](bool enabled)

            {

                _recorder->disableBuffering = enabled;

            });

}

RecordPanel::~RecordPanel()

{

    delete ui;

}

QToolBar* RecordPanel::toolbar()

{

    return &recordToolBar;

}

bool RecordPanel::isRecording()

{

    return recordAction.isChecked();

}

bool RecordPanel::recordPaused()

{

    return ui->cbRecordPaused->isChecked();

}

bool RecordPanel::selectFile()

{

    QString fileName = QFileDialog::getSaveFileName(

        parentWidget(), tr("Select recording file"));

    if (fileName.isEmpty())

    {

        return false;

    }

    else

    {

        selectedFile = fileName;

        ui->lbFileName->setText(selectedFile);

        overwriteSelected = QFile::exists(fileName);

        return true;

    }

}

void RecordPanel::onRecord(bool start)

{

    if (!start)

    {

        stopRecording();

        return;

    }

    // check file name

    bool canceled = false;

    if (selectedFile.isEmpty() && !selectFile())

    {

        canceled = true;

    }

    if (!overwriteSelected && QFile::exists(selectedFile))

    {

        if (ui->cbAutoIncrement->isChecked())

        {

            // TODO: should we increment even if user selected to replace?

            canceled = !incrementFileName();

        }

        else

        {

            canceled = !confirmOverwrite(selectedFile);

        }

    }

    overwriteSelected = false;

    if (canceled)

    {

        recordAction.setChecked(false);

    }

    else

    {

        startRecording();

    }

}

bool RecordPanel::incrementFileName(void)

{

    QFileInfo fileInfo(selectedFile);

    QString base = fileInfo.completeBaseName();

    QRegularExpression regex("(.*?)(\\d+)(?!.*\\d)(.*)");

    auto match = regex.match(base);

    if (match.hasMatch())

    {

        bool ok;

        int fileNum = match.captured(2).toInt(&ok);

        base = match.captured(1) + QString::number(fileNum + 1) + match.captured(3);

    }

    else

    {

        base += "_1";

    }

    QString suffix = fileInfo.suffix();;

    if (!suffix.isEmpty())

    {

        suffix = "." + suffix;

    }

    QString autoFileName = fileInfo.path() + "/" + base + suffix;

    // check if auto generated file name exists, ask user another name

    if (QFile::exists(autoFileName))

    {

        if (!confirmOverwrite(autoFileName))

        {

            return false;

        }

    }

    else

    {

        selectedFile = autoFileName;

    }

    ui->lbFileName->setText(selectedFile);

    return true;

}

bool RecordPanel::confirmOverwrite(QString fileName)

{

    // prepare message box

    QMessageBox mb(parentWidget());

    mb.setWindowTitle(tr("File Already Exists"));

    mb.setIcon(QMessageBox::Warning);

    mb.setText(tr("File (%1) already exists. How to continue?").arg(fileName));

    auto bCancel    = mb.addButton(QMessageBox::Cancel);

    auto bOverwrite = mb.addButton(tr("Overwrite"), QMessageBox::DestructiveRole);

    mb.addButton(tr("Select Another File"), QMessageBox::YesRole);

    mb.setEscapeButton(bCancel);

    // show message box

    mb.exec();

    if (mb.clickedButton() == bCancel)

    {

        return false;

    }

    else if (mb.clickedButton() == bOverwrite)

    {

        selectedFile = fileName;

        return true;

    }

    else                    // select button

    {

        return selectFile();

    }

}

void RecordPanel::startRecording(void)

{

    emit recordStarted();

}

void RecordPanel::stopRecording(void)

{

    emit recordStopped();

    _recorder->stopRecording();

}

void RecordPanel::onPortClose()

{

    if (recordAction.isChecked() && ui->cbStopOnClose->isChecked())

    {

        stopRecording();

        recordAction.setChecked(false);

    }

}

/*

  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/>.

*/

#ifndef RECORDPANEL_H

#define RECORDPANEL_H

#include <QWidget>

#include <QString>

#include <QToolBar>

#include <QAction>

#include "datarecorder.h"

namespace Ui {

class RecordPanel;

}

class RecordPanel : public QWidget

{

    Q_OBJECT

public:

    ~RecordPanel();