src/dataformatpanel.cpp

  src/plotcontrolpanel.cpp

  src/recordpanel.cpp

  src/datarecorder.cpp

  src/tooltipfilter.cpp

  src/sneakylineedit.cpp

  src/stream.cpp

  src/streamchannel.cpp

  src/channelinfomodel.cpp

  src/ringbuffer.cpp

  src/ringbuffer.cpp

  src/indexbuffer.cpp

  src/framebufferseries.cpp

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

  src/asciireader.cpp

  src/asciireadersettings.cpp

  src/demoreader.cpp

  src/demoreadersettings.cpp

  src/framedreader.cpp

  src/framedreadersettings.cpp

    // connect to ChannelInfoModel

    infoModel = _stream->infoModel();

    connect(infoModel, &QAbstractItemModel::dataChanged,

                this, &PlotManager::onChannelInfoChanged);

    connect(infoModel, &QAbstractItemModel::modelReset,

            [this]()

            {

                onChannelInfoChanged(infoModel->index(0, 0), // start

                                     infoModel->index(infoModel->rowCount()-1, 0), // end

                                     {}); // roles ignored

            });

    connect(stream, &Stream::numChannelsChanged, this, &PlotManager::onNumChannelsChanged);

    connect(stream, &Stream::dataAdded, this, &PlotManager::replot);

    // add initial curves if any?

    for (unsigned int i = 0; i < stream->numChannels(); i++)

    {

        addCurve(stream->channel(i)->name(), stream->channel(i)->yData());

    }

}

PlotManager::PlotManager(QWidget* plotArea, PlotMenu* menu,

                         Snapshot* snapshot, QObject *parent) :

    QObject(parent)

{

    construct(plotArea, menu);

    setNumOfSamples(snapshot->numSamples());

    setPlotWidth(snapshot->numSamples());

    infoModel = snapshot->infoModel();

    for (unsigned ci = 0; ci < snapshot->numChannels(); ci++)

    {

    }

    connect(infoModel, &QAbstractItemModel::dataChanged,

            this, &PlotManager::onChannelInfoChanged);

}

void PlotManager::construct(QWidget* plotArea, PlotMenu* menu)

{

    _menu = menu;

    _plotArea = plotArea;

    _autoScaled = true;

    _yMin = 0;

    return plot;

}

void PlotManager::addCurve(QString title, const FrameBuffer* buffer)

{

    auto curve = new QwtPlotCurve(title);

    auto series = new FrameBufferSeries(buffer);

    series->setXAxis(_xAxisAsIndex, _xMin, _xMax);

    curve->setSamples(series);

    _addCurve(curve);

}

void PlotManager::_addCurve(QwtPlotCurve* curve)

{

    // store and init the curve

    curves.append(curve);

    unsigned index = curves.size()-1;

    auto color = infoModel->color(index);

    curve->setPen(color);

    // create the plot for the curve if we are on multi display

    Plot* plot;

    if (isMulti)

public:

    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

                         const Stream* stream = NULL,

                         QObject *parent = 0);

    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

                         Snapshot* snapshot,

                         QObject *parent = 0);

    ~PlotManager();

    /// Add a new curve with title and buffer. A color is

    /// automatically chosen for curve.

    void addCurve(QString title, const FrameBuffer* buffer);

    /// Removes curves from the end

    void removeCurves(unsigned number);

    /// Returns current number of curves known by plot manager

    unsigned numOfCurves();

public slots:

    /// Enable/Disable multiple plot display

    void setMulti(bool enabled);

    /// Update all plot widgets

    void replot();

    /// Enable display of a "DEMO" label on each plot

    void showDemoIndicator(bool show = true);

/*

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

ReadOnlyBuffer::ReadOnlyBuffer(const FrameBuffer* source) :

    ReadOnlyBuffer(source, 0, source->size())

{

}

ReadOnlyBuffer::ReadOnlyBuffer(const FrameBuffer* source, unsigned start, unsigned n)

{

    Q_ASSERT(source->size() > 0);

    Q_ASSERT(start + n <= source->size());

    _size = n;

    data = new double[_size];

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

    {

        data[i] = source->sample(start + i);

    }

    /// if not exact copy of source re-calculate limits

    if (start == 0 && n == source->size())

    {

        _limits = source->limits();

    }

    else

    {

            }

        }

}

ReadOnlyBuffer::~ReadOnlyBuffer()

{

    delete[] data;

}

unsigned ReadOnlyBuffer::size() const

{

    return _size;

}

double ReadOnlyBuffer::sample(unsigned i) const

{

    return data[i];

}

Range ReadOnlyBuffer::limits() const

{

    return _limits;

}

    /// empty.

    ReadOnlyBuffer(const FrameBuffer* source);

    /// Creates a buffer from a slice of the `source`.

    ///

    /// @param start start of the slice

    /// @param n number of samples

    ///

    /// @important (start + n) should be smaller or equal than `source->size()`,

    /// otherwise it's an error.

    ReadOnlyBuffer(const FrameBuffer* source, unsigned start, unsigned n);

    ~ReadOnlyBuffer();

    virtual unsigned size() const;

    virtual double sample(unsigned i) const;

    virtual Range limits() const;

private:

    double* data;    ///< data storage

    unsigned _size;  ///< data size

    Range _limits;   ///< limits cache

};

#endif // READONLYBUFFER_H

    }

}

void Snapshot::setName(QString name)

{

    _name = name;

    _showAction.setText(_name);

    emit nameChanged(this);

}

unsigned Snapshot::numChannels() const

{

}

unsigned Snapshot::numSamples() const

{

}

const ChannelInfoModel* Snapshot::infoModel() const

{

    return &cInfoModel;

}

ChannelInfoModel* Snapshot::infoModel()

{

    return const_cast<ChannelInfoModel*>(static_cast<const Snapshot&>(*this).infoModel());

}

QString Snapshot::channelName(unsigned channel)

{

    return cInfoModel.name(channel);

}

void Snapshot::save(QString fileName)

{

    QSaveFile file(fileName);

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

    {

        QTextStream fileStream(&file);

        // print header

        {

            fileStream << channelName(ci);

        }

        fileStream << '\n';

        // print rows

        {

            {

            }

            fileStream << '\n';

        }

        if (!file.commit())

        {

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

        }

        else

        {

            _saved = true;

            _showAction.setText(displayName());

*/

#ifndef SNAPSHOT_H

#define SNAPSHOT_H

#include <QObject>

#include <QAction>

#include <QVector>

#include <QString>

#include <QStringList>

#include "channelinfomodel.h"

class SnapshotView;

class MainWindow;

class Snapshot : public QObject

{

    Q_OBJECT

public:

    Snapshot(MainWindow* parent, QString name, ChannelInfoModel infoModel, bool saved = false);

    ~Snapshot();

    QAction* showAction();

    QAction* deleteAction();

    QString name();

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

    unsigned numChannels() const; ///< number of channels in this snapshot

    unsigned numSamples() const;  ///< number of samples in every channel

    const ChannelInfoModel* infoModel() const;

    ChannelInfoModel* infoModel();

    void setName(QString name);

    QString channelName(unsigned channel);

{

    for (auto snapshot : snapshots)

    {

        delete snapshot;

    }

}

Snapshot* SnapshotManager::makeSnapshot() const

{

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

    auto snapshot = new Snapshot(_mainWindow, name, *(_stream->infoModel()));

    {

    }

    return snapshot;

}

void SnapshotManager::takeSnapshot()

{

    addSnapshot(makeSnapshot());

}

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

{

    {

        qCritical() << "Couldn't open file: " << fileName;

        qCritical() << file.errorString();

        return;

    }

    // read first row as headlines and determine number of channels

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

    QStringList channelNames = headLine.split(',');

    unsigned numOfChannels = channelNames.size();

    // read data

    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;

        {

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

            }

        }

        lineNum++;

    }

    auto snapshot = new Snapshot(

        _mainWindow, QFileInfo(fileName).baseName(),

        ChannelInfoModel(channelNames), true);

    addSnapshot(snapshot, false);

}

QMenu* SnapshotManager::menu()

{

    return &_menu;

}

QAction* SnapshotManager::takeSnapshotAction()

{

    return &_takeSnapshotAction;