#

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

#

cmake_minimum_required(VERSION 2.8.11)

project(serialplot)

# Find includes in corresponding build directories

set(CMAKE_INCLUDE_CURRENT_DIR ON)

# Instruct CMake to run moc automatically when needed.

set(CMAKE_AUTOMOC ON)

# add local path for cmake modules

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")

# Find the QtWidgets library

find_package(Qt5Widgets)

# Find QWT or use static

set(QWT_USE_STATIC false CACHE BOOL "Use a static version of Qwt provided by user.")

set(QWT_STATIC_LIBRARY "" CACHE FILEPATH "Path to the static Qwt library, libqwt.a.")

set(QWT_STATIC_INCLUDE "" CACHE PATH "Path to the Qwt include directory when building Qwt static.")

if (QWT_USE_STATIC)

  set(QWT_LIBRARY ${QWT_STATIC_LIBRARY})

  set(QWT_INCLUDE_DIR ${QWT_STATIC_INCLUDE})

else (QWT_USE_STATIC)

  find_package(Qwt 6.1 REQUIRED)

endif (QWT_USE_STATIC)

# includes

include_directories(${QWT_INCLUDE_DIR})

# wrap UI files

qt5_wrap_ui(UI_FILES mainwindow.ui about_dialog.ui)

# Tell CMake to create the helloworld executable

add_executable(serialplot main.cpp mainwindow.cpp customcheckablebutton.cpp ${UI_FILES})

# Use the Widgets module from Qt 5.

target_link_libraries(serialplot ${QWT_LIBRARY})

qt5_use_modules(serialplot Widgets SerialPort Svg)

# Enable C++11 support, fail if not supported

include(CheckCXXCompilerFlag)

CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

if(COMPILER_SUPPORTS_CXX11)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

elseif(COMPILER_SUPPORTS_CXX0X)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

else()

  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

endif()

# configure version file

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")

# add make run target

add_custom_target(run

    COMMAND serialplot

    DEPENDS serialplot

    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

)

# installing

install(TARGETS serialplot DESTINATION bin)

# install menu item and icon

find_program(XDG-DESKTOP-MENU xdg-desktop-menu)

find_program(XDG-ICON-RESOURCE xdg-icon-resource)

# first copy files to share/serialplot/

install(FILES

  ${CMAKE_SOURCE_DIR}/misc/serialplot.desktop

  ${CMAKE_SOURCE_DIR}/misc/serialplot.png

  DESTINATION share/serialplot)

# install copyright file (in debian format)

install(FILES

  ${CMAKE_SOURCE_DIR}/debian/copyright

  DESTINATION share/doc/serialplot/)

install(CODE "

  execute_process(COMMAND ${XDG-DESKTOP-MENU} install --novendor ${CMAKE_INSTALL_PREFIX}/share/serialplot/serialplot.desktop)

  execute_process(COMMAND ${XDG-ICON-RESOURCE} install --novendor --size 256 ${CMAKE_INSTALL_PREFIX}/share/serialplot/serialplot.png)

")

# uninstalling

configure_file(

  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

  IMMEDIATE @ONLY)

add_custom_target(uninstall

  COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake

  COMMAND ${XDG-DESKTOP-MENU} uninstall --novendor serialplot.desktop

  COMMAND ${XDG-ICON-RESOURCE} uninstall --novendor --size 256 serialplot)

# packaging

set(CPACK_GENERATOR "DEB")

include(InstallRequiredSystemLibraries)

set(CPACK_PACKAGE_NAME "serialplot")

set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

set(CPACK_PACKAGE_VERSION_MAJOR ${MAJOR_VERSION})

set(CPACK_PACKAGE_VERSION_MINOR ${MINOR_VERSION})

set(CPACK_PACKAGE_VERSION_PATCH ${PATCH_VERSION})

set(CPACK_STRIP_FILES TRUE)

set(CPACK_PACKAGE_EXECUTABLES "serialplot")

set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

if (NOT QWT_USE_STATIC)

  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

endif (NOT QWT_USE_STATIC)

set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/debian/postinst" "${CMAKE_SOURCE_DIR}/debian/postrm")

# set debian package name

string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_PACKAGE_NAME_LOWERCASE)

find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")

if(DPKG_PROGRAM)

  execute_process(

    COMMAND ${DPKG_PROGRAM} --print-architecture

    OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE

    OUTPUT_STRIP_TRAILING_WHITESPACE)

  set(CPACK_PACKAGE_FILE_NAME

	"${CPACK_PACKAGE_NAME_LOWERCASE}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")

else(DPKG_PROGRAM)

  set(CPACK_PACKAGE_FILE_NAME

	"${CPACK_PACKAGE_NAME_LOWERCASE}_${PROJECT_VERSION}-${PROJECT_VERSION_REVISION}_${CMAKE_SYSTEM_NAME}")

endif(DPKG_PROGRAM)

include(CPack)

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>AboutDialog</class>

 <widget class="QDialog" name="AboutDialog">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>487</width>

   </rect>

  </property>

  <property name="windowTitle">

   <string>About</string>

  </property>

  <layout class="QVBoxLayout" name="verticalLayout">

   <item>

    <widget class="QLabel" name="lbAbout">

     <property name="text">

     </property>

     <property name="wordWrap">

      <bool>true</bool>

     </property>

     <property name="openExternalLinks">

      <bool>true</bool>

     </property>

    </widget>

   </item>

   <item>

    <layout class="QHBoxLayout" name="horizontalLayout">

     <item>

      <widget class="QPushButton" name="pbAboutQt">

       <property name="text">

        <string>About Qt</string>

       </property>

      </widget>

     </item>

     <item>

      <widget class="QDialogButtonBox" name="buttonBox">

       <property name="orientation">

        <enum>Qt::Horizontal</enum>

       </property>

       <property name="standardButtons">

        <set>QDialogButtonBox::Close</set>

       </property>

      </widget>

     </item>

    </layout>

   </item>

  </layout>

 </widget>

 <resources/>

 <connections>

  <connection>

   <sender>buttonBox</sender>

   <signal>accepted()</signal>

   <receiver>AboutDialog</receiver>

   <slot>accept()</slot>

   <hints>

    <hint type="sourcelabel">

     <x>248</x>

     <y>254</y>

    </hint>

    <hint type="destinationlabel">

     <x>157</x>

     <y>274</y>

    </hint>

   </hints>

  </connection>

  <connection>

   <sender>buttonBox</sender>

   <signal>rejected()</signal>

   <receiver>AboutDialog</receiver>

   <slot>reject()</slot>

   <hints>

    <hint type="sourcelabel">

     <x>316</x>

     <y>260</y>

    </hint>

    <hint type="destinationlabel">

     <x>286</x>

     <y>274</y>

    </hint>

   </hints>

  </connection>

 </connections>

</ui>

/*

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

#include "ui_mainwindow.h"

#include <QSerialPortInfo>

#include <QByteArray>

#include <QApplication>

#include <QtDebug>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include "utils.h"

#include "version.h"

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow)

{

    ui->setupUi(this);

    setupAboutDialog();

    // init UI signals

    // menu signals

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

              &aboutDialog, &QWidget::show);

    // port tab signals

    QObject::connect(ui->pbReloadPorts, &QPushButton::clicked,

                     this, &MainWindow::loadPortList);

    QObject::connect(ui->pbOpenPort, &QPushButton::clicked,

                     this, &MainWindow::togglePort);

    QObject::connect(this, &MainWindow::portToggled,

                     this, &MainWindow::onPortToggled);

    QObject::connect(ui->cbPortList,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

                     this, &MainWindow::selectPort);

    QObject::connect(ui->cbBaudRate,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

                     this, &MainWindow::selectBaudRate);

    QObject::connect(ui->spNumOfSamples, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

                     this, &MainWindow::onNumOfSamplesChanged);

    QObject::connect(ui->cbAutoScale, &QCheckBox::toggled,

                     this, &MainWindow::onAutoScaleChecked);

    QObject::connect(ui->spYmin, SIGNAL(valueChanged(double)),

                     this, SLOT(onYScaleChanged()));

    QObject::connect(ui->spYmax, SIGNAL(valueChanged(double)),

                     this, SLOT(onYScaleChanged()));

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

                     this, SLOT(clearPlot()));

    // setup number of channels spinbox

    QObject::connect(ui->spNumOfChannels,

                     SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

                     this, &MainWindow::onNumOfChannelsChanged);

    // setup number format buttons

    numberFormatButtons.addButton(ui->rbUint8,  NumberFormat_uint8);

    numberFormatButtons.addButton(ui->rbUint16, NumberFormat_uint16);

    numberFormatButtons.addButton(ui->rbUint32, NumberFormat_uint32);

    numberFormatButtons.addButton(ui->rbInt8,   NumberFormat_int8);

    numberFormatButtons.addButton(ui->rbInt16,  NumberFormat_int16);

    numberFormatButtons.addButton(ui->rbInt32,  NumberFormat_int32);

    numberFormatButtons.addButton(ui->rbASCII,  NumberFormat_ASCII);

    QObject::connect(&numberFormatButtons, SIGNAL(buttonToggled(int, bool)),

                     this, SLOT(onNumberFormatButtonToggled(int, bool)));

    // setup parity selection buttons

    parityButtons.addButton(ui->rbNoParity, (int) QSerialPort::NoParity);

    parityButtons.addButton(ui->rbEvenParity, (int) QSerialPort::EvenParity);

    parityButtons.addButton(ui->rbOddParity, (int) QSerialPort::OddParity);

    QObject::connect(&parityButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &MainWindow::selectParity);

    // setup data bits selection buttons

    dataBitsButtons.addButton(ui->rb8Bits, (int) QSerialPort::Data8);

    dataBitsButtons.addButton(ui->rb7Bits, (int) QSerialPort::Data7);

    dataBitsButtons.addButton(ui->rb6Bits, (int) QSerialPort::Data6);

    dataBitsButtons.addButton(ui->rb5Bits, (int) QSerialPort::Data5);

    QObject::connect(&dataBitsButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &MainWindow::selectDataBits);

    // setup stop bits selection buttons

    stopBitsButtons.addButton(ui->rb1StopBit, (int) QSerialPort::OneStop);

    stopBitsButtons.addButton(ui->rb2StopBit, (int) QSerialPort::TwoStop);

    QObject::connect(&stopBitsButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &MainWindow::selectStopBits);

    // setup flow control selection buttons

    flowControlButtons.addButton(ui->rbNoFlowControl,

                                 (int) QSerialPort::NoFlowControl);

    flowControlButtons.addButton(ui->rbHardwareControl,

                                 (int) QSerialPort::HardwareControl);

    flowControlButtons.addButton(ui->rbSoftwareControl,

                                 (int) QSerialPort::SoftwareControl);

    QObject::connect(&flowControlButtons,

                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

                     this, &MainWindow::selectFlowControl);

    // init port signals

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

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

    // init skip byte button

    skipByteRequested = false;

    QObject::connect(ui->pbSkipByte, &QPushButton::clicked,

                     this, &MainWindow::skipByte);

    loadPortList();

    loadBaudRateList();

    ui->cbBaudRate->setCurrentIndex(ui->cbBaudRate->findText("9600"));

    // set limits for axis limit boxes

    ui->spYmin->setRange((-1) * std::numeric_limits<double>::max(),

                         std::numeric_limits<double>::max());

    ui->spYmax->setRange((-1) * std::numeric_limits<double>::max(),

                         std::numeric_limits<double>::max());

    // init data arrays and plot

    numOfSamples = ui->spNumOfSamples->value();

    numOfChannels = 1;

    dataX.resize(numOfSamples);

    for (int i = 0; i < dataX.size(); i++)

    {

        dataX[i] = i;

    }

    // init channel data and curve list

    for (int i = 0; i < numOfChannels; i++)

    {

        channelsData.append(DataArray(numOfSamples, 0.0));

        curves.append(new QwtPlotCurve());

        curves[i]->setSamples(dataX, channelsData[i]);

        curves[i]->setPen(makeColor(i));

        curves[i]->attach(ui->plot);

    }

    // init number format

    if (numberFormatButtons.checkedId() >= 0)

    {

        selectNumberFormat((NumberFormat) numberFormatButtons.checkedId());

    }

    else

    {

        selectNumberFormat(NumberFormat_uint8);

    }

    // Init demo mode

    demoCount = 0;

    demoTimer.setInterval(100);

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

                     this, &MainWindow::demoTimerTimeout);

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     this, &MainWindow::enableDemo);

}

MainWindow::~MainWindow()

{

    for (auto curve : curves)

    {

        delete curve;

    }

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete ui;

}

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

    uiAboutDialog.lbAbout->setText(aboutText);

}

void MainWindow::loadPortList()

{

    QString currentSelection = ui->cbPortList->currentText();

    ui->cbPortList->clear();

    for (auto port : QSerialPortInfo::availablePorts())

    {

        ui->cbPortList->addItem(port.portName());

    }

    // find current selection in the new list, maybe it doesn't exist anymore?

    int currentSelectionIndex = ui->cbPortList->findText(currentSelection);

    if (currentSelectionIndex >= 0)

    {

        ui->cbPortList->setCurrentIndex(currentSelectionIndex);

    }

    else // our port doesn't exist anymore, close port if it's open

    {

        if (serialPort.isOpen()) togglePort();

    }

}

void MainWindow::loadBaudRateList()

{

    ui->cbBaudRate->clear();

    for (auto baudRate : QSerialPortInfo::standardBaudRates())

    {

        ui->cbBaudRate->addItem(QString::number(baudRate));

    }

}

void MainWindow::togglePort()

{

    if (serialPort.isOpen())

    {

        serialPort.close();

        qDebug() << "Port closed, " << serialPort.portName();

        emit portToggled(false);

    }

    else

    {

        serialPort.setPortName(ui->cbPortList->currentText());

        // open port

        if (serialPort.open(QIODevice::ReadWrite))

        {

            qDebug() << "Port opened, " << serialPort.portName();

            emit portToggled(true);

            // set baud rate

            if (!serialPort.setBaudRate(ui->cbBaudRate->currentText().toInt()))

            {

                qDebug() << "Set baud rate failed during port opening: "

                         << serialPort.error();

            }

        }

        else

        {

            qDebug() << "Port open error: " << serialPort.error();

        }

    }

}

void MainWindow::selectPort(QString portName)

{

    // has selection actually changed

    if (portName != serialPort.portName())

    {

        // if another port is already open, close it by toggling

        if (serialPort.isOpen())

        {

            togglePort();

            // open new selection by toggling

            togglePort();

        }

    }

}

void MainWindow::selectBaudRate(QString baudRate)

{

    if (serialPort.isOpen())

    {

        if (!serialPort.setBaudRate(baudRate.toInt()))

        {

            qDebug() << "Set baud rate failed during select: "

                     << serialPort.error();

        }

        else

        {

            qDebug() << "Baud rate changed: " << serialPort.baudRate();

        }

    }

}

void MainWindow::selectParity(int parity)

{

    if (serialPort.isOpen())

    {

        if(!serialPort.setParity((QSerialPort::Parity) parity))

        {

            qDebug() << "Set parity failed: " << serialPort.error();

        }

    }

}

void MainWindow::selectDataBits(int dataBits)

{

    if (serialPort.isOpen())

    {

        if(!serialPort.setDataBits((QSerialPort::DataBits) dataBits))

        {

            qDebug() << "Set data bits failed: " << serialPort.error();

        }

    }

}

void MainWindow::selectStopBits(int stopBits)

{

    if (serialPort.isOpen())

    {

        if(!serialPort.setStopBits((QSerialPort::StopBits) stopBits))

        {

            qDebug() << "Set stop bits failed: " << serialPort.error();

        }

    }

}

void MainWindow::selectFlowControl(int flowControl)

{

    if (serialPort.isOpen())

    {

        if(!serialPort.setFlowControl((QSerialPort::FlowControl) flowControl))

        {

            qDebug() << "Set flow control failed: " << serialPort.error();

        }

    }

}

void MainWindow::onPortToggled(bool open)

{

    ui->pbOpenPort->setChecked(open);

    // make sure demo mode is disabled

    if (open && isDemoRunning()) enableDemo(false);

    ui->actionDemoMode->setEnabled(!open);

}

void MainWindow::onDataReady()

{

    if (!ui->actionPause->isChecked())

    {

        // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

        int packageSize = sampleSize * numOfChannels;

        int bytesAvailable = serialPort.bytesAvailable();

        if (bytesAvailable > 0 && skipByteRequested)

        {

            serialPort.read(1);

            skipByteRequested = false;

            bytesAvailable--;

        }

        if (bytesAvailable < packageSize)

        {

            return;

        }

        else

        {

            int numOfPackagesToRead =

                (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;

            QVector<DataArray> channelSamples(numOfChannels);

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

            {

                channelSamples[ci].resize(numOfPackagesToRead);

            }

            int i = 0;

            while(i < numOfPackagesToRead)

            {

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

                {

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

                }

                i++;

            }

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

            {

                addChannelData(ci, channelSamples[ci]);

            }

        }

    }

    else

    {

        serialPort.clear(QSerialPort::Input);

    }

}

void MainWindow::onDataReadyASCII()

{

    while(serialPort.canReadLine())

    {

        QByteArray line = serialPort.readLine();

        line = line.trimmed();

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

        if (separatedValues.length() >= numOfChannels)

        {

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

            {

                double channelSample = separatedValues[ci].toDouble();

                addChannelData(ci, DataArray({channelSample}));

            }

        }

        else // there is missing channel data

        {

            qDebug() << "Incoming data is missing data for some channels!";

            for (int ci = 0; ci < separatedValues.length(); ci++)

            {

                double channelSample = separatedValues[ci].toDouble();

                addChannelData(ci, DataArray({channelSample}));

            }

        }

    }

}

void MainWindow::onPortError(QSerialPort::SerialPortError error)

{

    switch(error)

    {

        case QSerialPort::NoError :

            break;

        case QSerialPort::ResourceError :

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

            if (serialPort.isOpen())

            {

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

                togglePort();

            }

            loadPortList();

            break;

        default:

            qDebug() << "Unhandled port error: " << error;

            break;

    }

}

void MainWindow::skipByte()

{

    skipByteRequested = true;

}

void MainWindow::addChannelData(unsigned int channel, DataArray data)

{

    DataArray* channelDataArray = &(channelsData[channel]);

    int offset = numOfSamples - data.size();

    if (offset < 0)

    {

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

        {

            (*channelDataArray)[i] = data[i - offset];

        }

    }

    else if (offset == 0)

    {

        (*channelDataArray) = data;

    }

    else

    {

        // shift old samples

        int shift = data.size();

        for (int i = 0; i < offset; i++)

        {

            (*channelDataArray)[i] = (*channelDataArray)[i + shift];

        }

        // place new samples

        for (int i = 0; i < data.size(); i++)

        {

            (*channelDataArray)[offset + i] = data[i];

        }

    }

    // update plot

    curves[channel]->setSamples(dataX, (*channelDataArray));

    ui->plot->replot(); // TODO: replot after all channel data updated

}

void MainWindow::clearPlot()

{

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

    {

        channelsData[ci].fill(0.0);

        curves[ci]->setSamples(dataX, channelsData[ci]);

    }

    // update plot

    ui->plot->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    unsigned int oldNum = this->numOfSamples;

    numOfSamples = value;

    // resize data arrays

    if (numOfSamples < oldNum)

    {

        dataX.resize(numOfSamples);

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

        {

            channelsData[ci].remove(0, oldNum - numOfSamples);

        }

    }

    else if(numOfSamples > oldNum)

    {

        dataX.resize(numOfSamples);

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

        {

            dataX[i] = i;

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

            {

                channelsData[ci].prepend(0);

            }

        }

    }

}

void MainWindow::onNumOfChannelsChanged(int value)

{

    unsigned int oldNum = this->numOfChannels;

    this->numOfChannels = value;

    if (numOfChannels > oldNum)

    {

        // add new channels

        for (int i = 0; i < numOfChannels - oldNum; i++)

        {

            channelsData.append(DataArray(numOfSamples, 0.0));

            curves.append(new QwtPlotCurve());

            curves.last()->setSamples(dataX, channelsData.last());

            curves.last()->setPen(makeColor(curves.length()-1));

            curves.last()->attach(ui->plot);

        }

    }

    else if(numOfChannels < oldNum)

    {

        // remove channels

        for (int i = 0; i < oldNum - numOfChannels; i++)

        {

            channelsData.removeLast();

            auto curve = curves.takeLast();

            curve->detach();

            delete curve;

        }

    }

}

void MainWindow::onAutoScaleChecked(bool checked)

{

    if (checked)

    {

        ui->plot->setAxisAutoScale(QwtPlot::yLeft);

        ui->lYmin->setEnabled(false);

        ui->lYmax->setEnabled(false);

        ui->spYmin->setEnabled(false);

        ui->spYmax->setEnabled(false);

    }

    else

    {

        ui->lYmin->setEnabled(true);

        ui->lYmax->setEnabled(true);