QObject::connect(serialPort, &QSerialPort::readyRead,

                         this, &DataFormatPanel::onDataReady);

    }

    emit skipByteEnabledChanged(skipByteEnabled());

}

bool DataFormatPanel::skipByteEnabled()

{

    return numberFormat != NumberFormat_ASCII;

}

unsigned DataFormatPanel::numOfChannels()

{

    return _numOfChannels;

}

void DataFormatPanel::onNumOfChannelsSP(int value)

{

    _numOfChannels = value;

    emit numOfChannelsChanged(value);

}

void DataFormatPanel::requestSkipByte()

{

    skipByteRequested = true;

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

}

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoTimer.start();

    }

    else

    {

        demoTimer.stop();

    }

}

void DataFormatPanel::spsTimerTimeout()

{

    unsigned currentSps = _samplesPerSecond;

    if (currentSps != _samplesPerSecond)

    {

        emit samplesPerSecondChanged(_samplesPerSecond);

    }

    sampleCount = 0;

}

void DataFormatPanel::demoTimerTimeout()

{

    const double period = 100;

    demoCount++;

    if (demoCount >= 100) demoCount = 0;

    if (!paused)

    {

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

        {

            // we are calculating the fourier components of square wave

            double value = 4*sin(2*M_PI*double((ci+1)*demoCount)/period)/((2*(ci+1))*M_PI);

            addChannelData(ci, &value, 1);

        }

        emit dataAdded();

    }

}

void DataFormatPanel::onDataReady()

{

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

    int packageSize = sampleSize * _numOfChannels;

    int bytesAvailable = serialPort->bytesAvailable();

    int numOfPackagesToRead =

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

    if (paused)

    {

        // read and discard data

        serialPort->read(numOfPackagesToRead*packageSize);

        return;

    }

    if (bytesAvailable > 0 && skipByteRequested)

    {

        serialPort->read(1);

        skipByteRequested = false;

        bytesAvailable--;

    }

/*

  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 <QByteArray>

#include <QApplication>

#include <QFileDialog>

#include <QFile>

#include <QTextStream>

#include <QMenu>

#include <QtDebug>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include <plot.h>

#include "framebufferseries.h"

#include "utils.h"

#include "version.h"

#if defined(Q_OS_WIN) && defined(QT_STATIC)

#include <QtPlugin>

Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

#endif

struct Range

{

    double rmin;

    double rmax;

};

Q_DECLARE_METATYPE(Range);

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    channelMan(1, 1, this),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort, &channelMan),

    snapshotMan(this, &channelMan)

{

    ui->setupUi(this);

    ui->tabWidget->insertTab(0, &portControl, "Port");

    ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");

    ui->tabWidget->insertTab(3, &commandPanel, "Commands");

    ui->tabWidget->setCurrentIndex(0);

    addToolBar(portControl.toolBar());

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

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

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

    connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()

            {

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

            });

    setupAboutDialog();

    // init view menu

    for (auto a : ui->plot->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

    // menu signals

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

              &aboutDialog, &QWidget::show);

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

                     this, &MainWindow::onExportCsv);

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

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

                     &dataFormatPanel, &DataFormatPanel::requestSkipByte);

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

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

                     ui->plot, &Plot::flashSnapshotOverlay);

    // init port signals

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

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

    // 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 format and reader

    QObject::connect(&dataFormatPanel, &DataFormatPanel::dataAdded,

                     ui->plot, &QwtPlot::replot);

            this, &MainWindow::onNumOfChannelsChanged);

    connect(&channelMan, &ChannelManager::channelNameChanged,

            this, &MainWindow::onChannelNameChanged);

    ui->lvChannelNames->setModel(channelMan.channelNames());

    // init curve list

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

    {

        curves.append(new QwtPlotCurve(channelMan.channelName(i)));

        curves[i]->setSamples(

            new FrameBufferSeries(channelMan.channelBuffer(i)));

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

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

    }

    // init auto scale

    ui->plot->setAxis(ui->cbAutoScale->isChecked(),

                      ui->spYmin->value(), ui->spYmax->value());

    // init scale range preset list

    for (int nbits = 8; nbits <= 24; nbits++) // signed binary formats

    {

        int rmax = pow(2, nbits-1)-1;

        int rmin = -rmax-1;

        Range r = {double(rmin),  double(rmax)};

        ui->cbRangePresets->addItem(

            QString().sprintf("Signed %d bits %d to +%d", nbits, rmin, rmax),

            QVariant::fromValue(r));

    }

    for (int nbits = 8; nbits <= 24; nbits++) // unsigned binary formats

    {

        int rmax = pow(2, nbits)-1;

        ui->cbRangePresets->addItem(

            QString().sprintf("Unsigned %d bits %d to +%d", nbits, 0, rmax),

            QVariant::fromValue(Range{0, double(rmax)}));

    }

    ui->cbRangePresets->addItem("-1 to +1", QVariant::fromValue(Range{-1, +1}));

    ui->cbRangePresets->addItem("0 to +1", QVariant::fromValue(Range{0, +1}));

    ui->cbRangePresets->addItem("-100 to +100", QVariant::fromValue(Range{-100, +100}));

    ui->cbRangePresets->addItem("0 to +100", QVariant::fromValue(Range{0, +100}));

    QObject::connect(ui->cbRangePresets, SIGNAL(activated(int)),

                     this, SLOT(onRangeSelected()));

    // Init sps (sample per second) counter

    spsLabel.setText("0sps");

    ui->statusBar->addPermanentWidget(&spsLabel);

    QObject::connect(&dataFormatPanel,

                     &DataFormatPanel::samplesPerSecondChanged,

                     this, &MainWindow::onSpsChanged);

    // init demo

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

                     this, &MainWindow::enableDemo);

    {   // init demo indicator

        QwtText demoText(" DEMO RUNNING ");  // looks better with spaces

        demoText.setColor(QColor("white"));

        demoText.setBackgroundBrush(Qt::darkRed);

        demoText.setBorderRadius(4);

        demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignTop);

        demoIndicator.setText(demoText);

        demoIndicator.hide();

        demoIndicator.attach(ui->plot);

    }

}

MainWindow::~MainWindow()

{

    for (auto curve : curves)

    {

        // also deletes respective FrameBuffer

        delete curve;

    }

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete ui;

    ui = NULL; // we check if ui is deleted in messageHandler

}

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

      </widget>

      <widget class="QWidget" name="tabLog">

       <attribute name="title">

        <string>Log</string>

       </attribute>

       <attribute name="toolTip">

        <string>Error and Warning Messages</string>

       </attribute>

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

        <property name="leftMargin">

         <number>4</number>

        </property>

        <property name="topMargin">

         <number>4</number>

        </property>

        <property name="rightMargin">

         <number>4</number>

        </property>

        <property name="bottomMargin">

         <number>4</number>

        </property>

        <item>

         <widget class="QPlainTextEdit" name="ptLog">

          <property name="readOnly">

           <bool>true</bool>

          </property>

         </widget>

        </item>

       </layout>

      </widget>

     </widget>

    </item>

   </layout>

  </widget>

  <widget class="QMenuBar" name="menuBar">

   <property name="geometry">

    <rect>

     <x>0</x>

     <y>0</y>

     <width>653</width>

     <height>27</height>

    </rect>

   </property>

   <widget class="QMenu" name="menuHelp">

    <property name="title">

     <string>Help</string>

    </property>

    <addaction name="actionDemoMode"/>

    <addaction name="actionHelpAbout"/>

   </widget>

   <widget class="QMenu" name="menuFile">

    <property name="title">

     <string>File</string>

    </property>

    <addaction name="actionExportCsv"/>

    <addaction name="separator"/>

    <addaction name="actionQuit"/>

   </widget>

   <widget class="QMenu" name="menuView">

    <property name="title">

     <string>View</string>

    </property>

   </widget>

   <addaction name="menuFile"/>

   <addaction name="menuView"/>

   <addaction name="menuHelp"/>

  </widget>

  <widget class="QToolBar" name="plotToolBar">

   <property name="windowTitle">

    <string>Plot Toolbar</string>

   </property>

   <attribute name="toolBarArea">

    <enum>TopToolBarArea</enum>

   </attribute>

   <attribute name="toolBarBreak">

    <bool>false</bool>

   </attribute>

   <addaction name="actionPause"/>

   <addaction name="actionClear"/>

  </widget>

  <widget class="QStatusBar" name="statusBar"/>

  <action name="actionPause">

   <property name="checkable">

    <bool>true</bool>

   </property>

   <property name="checked">

    <bool>false</bool>

   </property>

   <property name="text">

    <string>Pause</string>

   </property>

   <property name="toolTip">

    <string>Pause Plotting</string>

   </property>

   <property name="shortcut">

    <string>P</string>

   </property>

  </action>

  <action name="actionClear">

   <property name="text">

    <string>Clear</string>

   </property>

   <property name="shortcut">

    <string>Ctrl+K</string>

   </property>

  </action>

  <action name="actionHelpAbout">

   <property name="text">

    <string>About</string>

   </property>

  </action>

  <action name="actionDemoMode">

   <property name="checkable">

    <bool>true</bool>

   </property>

   <property name="text">

    <string>Demo Mode</string>

   </property>

   <property name="toolTip">

    <string>Toggle Demo Mode</string>

   </property>

  </action>

  <action name="actionExportCsv">

   <property name="text">

    <string>Export CSV</string>

   </property>

   <property name="toolTip">

    <string>Export plot data to CSV</string>

   </property>

  </action>

  <action name="actionQuit">

   <property name="text">

    <string>Quit</string>

   </property>

   <property name="shortcut">

    <string>Ctrl+Q</string>

   </property>

  </action>

 </widget>

 <layoutdefault spacing="6" margin="11"/>

 <customwidgets>

  <customwidget>

   <class>Plot</class>

   <extends>QWidget</extends>

   <header>plot.h</header>

   <container>1</container>

  </customwidget>

  <customwidget>

   <class>HidableTabWidget</class>

   <extends>QTabWidget</extends>

   <header>hidabletabwidget.h</header>

   <container>1</container>

  </customwidget>

 </customwidgets>

 <resources/>

 <connections/>

</ui>

    if (isAutoScaled)

    {

        setAxisAutoScale(QwtPlot::yLeft);

    }

    else

    {

        setAxisScale(QwtPlot::yLeft, yMin, yMax);

    }

    replot();

}

void Plot::unzoomed()

{

    setAxisAutoScale(QwtPlot::xBottom);

    resetAxes();

}

void Plot::showGrid(bool show)

{

    grid.enableX(show);

    grid.enableY(show);

    replot();

}

void Plot::showMinorGrid(bool show)

{

    grid.enableXMin(show);

    grid.enableYMin(show);

    replot();

}

void Plot::unzoom()

{

    zoomer.zoom(0);

}

void Plot::darkBackground(bool enabled)

{

    QColor gridColor;

    if (enabled)

    {

        setCanvasBackground(QBrush(Qt::black));

        gridColor.setHsvF(0, 0, 0.25);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::white));

        zoomer.setTrackerPen(QPen(Qt::white));

        sZoomer.setPickerPen(QPen(Qt::white));

    }

    else

    {

        setCanvasBackground(QBrush(Qt::white));

        gridColor.setHsvF(0, 0, 0.80);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::black));

        zoomer.setTrackerPen(QPen(Qt::black));

        sZoomer.setPickerPen(QPen(Qt::black));

    }

    replot();

}

/*

  Below crude drawing demostrates how color selection occurs for

  given channel index

  0°                     <--Hue Value-->                           360°

  |* . o . + . o . * . o . + . o . * . o . + . o . * . o . + . o . |

  * -> 0-3

  + -> 4-7

  o -> 8-15

  . -> 16-31

 */

QColor Plot::makeColor(unsigned int channelIndex)

{

    auto i = channelIndex;

    if (i < 4)

    {

        return QColor::fromHsv(360*i/4, 255, 230);

    }

    else

    {

        double p = floor(log2(i));

        double n = pow(2, p);

        i = i - n;

        return QColor::fromHsv(360*i/n + 360/pow(2,p+1), 255, 230);

    }

}

void Plot::flashSnapshotOverlay()

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

    QColor color;

    if (darkBackgroundAction.isChecked())

    {

        color = QColor(Qt::white);

    }

    else

    {

        color = QColor(Qt::black);

    }