#

#

# 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

include(BuildQColorWidgets)

# includes

include_directories("./src" ${QWT_INCLUDE_DIR} ${QCW_INCLUDE_DIR})

# wrap UI and resource files

qt5_wrap_ui(UI_FILES

  src/mainwindow.ui

  src/portcontrol.ui

  src/about_dialog.ui

  src/snapshotview.ui

  src/commandpanel.ui

  src/commandwidget.ui

  src/dataformatpanel.ui

  src/plotcontrolpanel.ui

  src/numberformatbox.ui

  src/endiannessbox.ui

  src/binarystreamreadersettings.ui

  src/asciireadersettings.ui

  src/framedreadersettings.ui

  )

  src/plotsnapshotoverlay.cpp

  src/commandpanel.cpp

  src/commandwidget.cpp

  src/commandedit.cpp

  src/dataformatpanel.cpp

  src/plotcontrolpanel.cpp

  src/tooltipfilter.cpp

  src/sneakylineedit.cpp

  src/channelmanager.cpp

  src/channelinfomodel.cpp

  src/framebufferseries.cpp

  src/numberformatbox.cpp

include(ExternalProject)

ExternalProject_Add(QCW

  PREFIX qcw

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

  PATCH_COMMAND patch -t -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/qt_5_2_moc_creation_namespace_fix.diff

  UPDATE_COMMAND ""

  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)

    src/binarystreamreadersettings.cpp \

    src/asciireadersettings.cpp \

    src/asciireader.cpp \

    src/demoreader.cpp \

    src/framedreader.cpp \

    src/plotmanager.cpp \

HEADERS += \

    src/mainwindow.h \

    src/utils.h \

    src/portcontrol.h \

    src/floatswap.h \

    src/asciireadersettings.h \

    src/asciireader.h \

    src/demoreader.h \

    src/framedreader.h \

    src/plotmanager.h \

    src/setting_defines.h \

FORMS += \

    src/mainwindow.ui \

    src/about_dialog.ui \

    src/portcontrol.ui \

    src/snapshotview.ui \

    src/dataformatpanel.ui \

    src/plotcontrolpanel.ui \

    src/numberformatbox.ui \

    src/endiannessbox.ui \

    src/framedreadersettings.ui \

    src/binarystreamreadersettings.ui \

INCLUDEPATH += qmake/ src/

CONFIG += c++11

RESOURCES += misc/icons.qrc

/*

  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

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "abstractreader.h"

    QObject(parent)

{

    _device = device;

    _channelMan = channelMan;

    // initialize sps counter

    sampleCount = 0;

    samplesPerSecond = 0;

    QObject::connect(&spsTimer, &QTimer::timeout,

                     this, &AbstractReader::spsTimerTimeout);

    if (currentSps != samplesPerSecond)

    {

        emit samplesPerSecondChanged(samplesPerSecond);

    }

    sampleCount = 0;

}

/*

  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

#include <QObject>

#include <QIODevice>

#include <QWidget>

#include <QTimer>

#include "channelmanager.h"

/**

 * All reader classes must inherit this class.

 */

class AbstractReader : public QObject

{

    Q_OBJECT

public:

    /**

     * Returns a widget to be shown in data format panel when reader

     * is selected.

     */

    virtual QWidget* settingsWidget() = 0;

    virtual unsigned numOfChannels() = 0;

    /// Reader should only read when enabled. Default state should be

    /// 'disabled'.

    virtual void enable(bool enabled = true) = 0;

signals:

    void numOfChannelsChanged(unsigned);

    void samplesPerSecondChanged(unsigned);

public slots:

    /**

     * Pauses the reading.

     *

     * synchronization but shouldn't commit data.

     */

    virtual void pause(bool) = 0;

protected:

    QIODevice* _device;

private:

    const int SPS_UPDATE_TIMEOUT = 1;  // second

    unsigned samplesPerSecond;

    QTimer spsTimer;

private slots:

    void spsTimerTimeout();

};

#include "asciireader.h"

/// If set to this value number of channels is determined from input

#define NUMOFCHANNELS_AUTO   (0)

{

    paused = false;

    discardFirstLine = true;

    _numOfChannels = _settingsWidget.numOfChannels();

    autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            [this](unsigned value)

                qWarning() << "Data parsing error for channel: " << ci;

                channelSamples[ci] = 0;

            }

        }

        // commit data

        delete[] channelSamples;

    }

}

void AsciiReader::saveSettings(QSettings* settings)

/*

  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

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

#include <QtEndian>

#include <QtDebug>

#include "binarystreamreader.h"

#include "floatswap.h"

{

    paused = false;

    skipByteRequested = false;

    skipSampleRequested = false;

    _numOfChannels = _settingsWidget.numOfChannels();

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::numOfChannelsChanged);

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::onNumOfChannelsChanged);

        {

            // channelSamples[ci].replace(i, (this->*readSample)());

            channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();

        }

    }

    delete[] channelSamples;

}

template<typename T> double BinaryStreamReader::readSampleAs()

{

 * that should be manually triggered by user.

 */

class BinaryStreamReader : public AbstractReader

{

    Q_OBJECT

public:

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

{

    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

    };

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

ChannelManager::ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent) :

    QObject(parent),

    _infoModel(numberOfChannels)

{

    _numOfChannels = numberOfChannels;

    _numOfSamples = numberOfSamples;

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

    {

        channelBuffers.append(new FrameBuffer(numberOfSamples));

    }

        channelBuffers[ci]->resize(_numOfSamples);

    }

    emit numOfSamplesChanged(number);

}

FrameBuffer* ChannelManager::channelBuffer(unsigned channel)

{

    return channelBuffers[channel];

}

ChannelInfoModel* ChannelManager::infoModel()

}

void ChannelManager::addData(double* data, unsigned size)

{

    Q_ASSERT(size % _numOfChannels == 0);

    int n = size / _numOfChannels;

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

    {

        channelBuffers[ci]->addSamples(&data[ci*n], n);

    }

}

void ChannelManager::saveSettings(QSettings* settings)

{

    _infoModel.saveSettings(settings);

}

    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)

    QStringList channelNames();

signals:

    void numOfChannelsChanged(unsigned value);

    void numOfSamplesChanged(unsigned value);

    void channelNameChanged(unsigned channel, QString name);

public slots:

    void setNumOfChannels(unsigned number);

    void setNumOfSamples(unsigned number);

    /**

     * Add data for all channels.

     *

     * @param data samples for all channels

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

     */

    void addData(double* data, unsigned size);

private:

    unsigned _numOfChannels;

    unsigned _numOfSamples;

    QList<FrameBuffer*> channelBuffers;

    // QStringListModel _channelNames;

    ChannelInfoModel _infoModel;

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

/*

  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

#include "utils.h"

#include "setting_defines.h"

#include "floatswap.h"

DataFormatPanel::DataFormatPanel(QSerialPort* port,

                                 ChannelManager* channelMan,

                                 QWidget *parent) :

    QWidget(parent),

    ui(new Ui::DataFormatPanel),

{

    ui->setupUi(this);

    serialPort = port;

    _channelMan = channelMan;

    paused = false;

    // initalize default reader

    currentReader = &bsReader;

    bsReader.enable();

    ui->rbBinary->setChecked(true);

    ui->horizontalLayout->addWidget(bsReader.settingsWidget(), 1);

    connect(&bsReader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(&bsReader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // initalize reader selection buttons

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

        disconnect(&demoReader, 0, this, 0);

    }

}

void DataFormatPanel::selectReader(AbstractReader* reader)

{

    currentReader->enable(false);

    reader->enable();

    // re-connect signals

    disconnect(currentReader, 0, this, 0);

    connect(reader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(reader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // switch the settings widget

    // notify if number of channels is different

    if (currentReader->numOfChannels() != reader->numOfChannels())

    {

        emit numOfChannelsChanged(reader->numOfChannels());

    }

    reader->pause(paused);

    currentReader = reader;

}

void DataFormatPanel::saveSettings(QSettings* settings)

{

/*

  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

#include "framebuffer.h"

#include "channelmanager.h"

#include "binarystreamreader.h"

#include "asciireader.h"

#include "demoreader.h"

#include "framedreader.h"

namespace Ui {

class DataFormatPanel;

}

class DataFormatPanel : public QWidget

{

    Q_OBJECT

public:

    explicit DataFormatPanel(QSerialPort* port,

                             ChannelManager* channelMan,

    ~DataFormatPanel();

    /// Returns currently selected number of channels

    unsigned numOfChannels();

    /// Stores data format panel settings into a `QSettings`

    void saveSettings(QSettings* settings);

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

    void enableDemo(bool); // demo shouldn't be enabled when port is open

signals:

    void numOfChannelsChanged(unsigned);

    void samplesPerSecondChanged(unsigned);

private:

    Ui::DataFormatPanel *ui;

    QSerialPort* serialPort;

    ChannelManager* _channelMan;

    AbstractReader* currentReader;

    /// Disable current reader and enable a another one

    void selectReader(AbstractReader* reader);

    bool paused;

    DemoReader demoReader;

};

#endif // DATAFORMATPANEL_H