#

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

ExternalProject_Add(QCW

  PREFIX qcw

  GIT_REPOSITORY https://github.com/mbasaglia/Qt-Color-Widgets

  INSTALL_COMMAND "")

ExternalProject_Get_Property(QCW binary_dir source_dir)

set(QCW_LIBRARY ${binary_dir}/libColorWidgets-qt5.a)

set(QCW_INCLUDE_DIR ${source_dir}/include)

    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::ChannelInfo::ChannelInfo(unsigned index)

{

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

    visibility = true;

    color = colors[index % NUMOF_COLORS];

}

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)

  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>

class ChannelInfoModel : public QAbstractTableModel

{

    Q_OBJECT

public:

    enum ChannelInfoColumn

    {

        COLUMN_NAME = 0,

        COLUMN_VISIBILITY,

        COLUMN_COUNT

    };

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

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

  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"

    QObject(parent),

    _showAction(this),

    _deleteAction("&Delete", this)

{

    _name = name;

    _saved = false;

    view = NULL;

    mainWindow = parent;

    _showAction.setText(displayName());

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

QString Snapshot::name()

{

    return _name;

}

QString Snapshot::displayName()

{

    if (_saved)

    {

        return name();

    }

    else

    {

        return name() + "*";

    }

}

void Snapshot::setName(QString name)

{

    _name = name;

    _showAction.setText(_name);

    emit nameChanged(this);

}

QString Snapshot::channelName(unsigned 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++)

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

    QVector<QVector<QPointF>> data;

    QAction* showAction();

    QAction* deleteAction();

    QString name();

    QString displayName(); ///< `name()` plus '*' if snapshot is not saved

    void setName(QString name);

    QString channelName(unsigned channel);

    void save(QString fileName); ///< save snapshot data as CSV

    bool isSaved(); ///< snapshot has been saved at least once

signals:

    void deleteRequested(Snapshot*);

    void nameChanged(Snapshot*);

private:

    QString _name;

    QAction _showAction;

    QAction _deleteAction;

    QMainWindow* mainWindow;

    SnapshotView* view;

    bool _saved;

private slots:

    void show();

    void viewClosed();

    void onDeleteTriggered();

};

#endif /* SNAPSHOT_H */

    _takeSnapshotAction.setShortcut(QKeySequence("F5"));

    loadSnapshotAction.setToolTip("Load snapshots from CSV files");

    clearAction.setToolTip("Delete all snapshots");

    connect(&_takeSnapshotAction, SIGNAL(triggered(bool)),

            this, SLOT(takeSnapshot()));

    connect(&clearAction, SIGNAL(triggered(bool)),

            this, SLOT(clearSnapshots()));

    connect(&loadSnapshotAction, SIGNAL(triggered(bool)),

            this, SLOT(loadSnapshots()));

    updateMenu();

}

SnapshotManager::~SnapshotManager()

{

    for (auto snapshot : snapshots)

    {

        delete snapshot;

    }

}

Snapshot* SnapshotManager::makeSnapshot()

{

    QString name = QTime::currentTime().toString("'Snapshot ['HH:mm:ss']'");

    unsigned numOfChannels = _channelMan->numOfChannels();

    unsigned numOfSamples = _channelMan->numOfSamples();

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

    {

        snapshot->data.append(QVector<QPointF>(numOfSamples));

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

        {

            snapshot->data[ci][i] = QPointF(i, _channelMan->channelBuffer(ci)->sample(i));

        }

    }

    return snapshot;

}

void SnapshotManager::takeSnapshot()

{

    addSnapshot(makeSnapshot());

}

void SnapshotManager::addSnapshot(Snapshot* snapshot, bool update_menu)

{

    snapshots.append(snapshot);

    QObject::connect(snapshot, &Snapshot::deleteRequested,

                     this, &SnapshotManager::deleteSnapshot);

    if (update_menu) updateMenu();

}

void SnapshotManager::updateMenu()

{

    _menu.clear();

    _menu.addAction(&_takeSnapshotAction);

    _menu.addAction(&loadSnapshotAction);

    if (snapshots.size())

    {

        {

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

    }

    snapshot->data = data;

    addSnapshot(snapshot, false);

}

QMenu* SnapshotManager::menu()

{

    return &_menu;

}

QAction* SnapshotManager::takeSnapshotAction()

{

    return &_takeSnapshotAction;

}

bool SnapshotManager::isAllSaved()

{

    for (auto snapshot : snapshots)

    {

        if (!snapshot->isSaved()) return false;

    }

    return true;

}