#

#

# 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

  src/portcontrol.cpp

  src/plot.cpp

  src/zoomer.cpp

  src/scrollzoomer.cpp

  src/scrollbar.cpp

  src/hidabletabwidget.cpp

  src/scalepicker.cpp

  src/scalezoomer.cpp

  src/portlist.cpp

  src/snapshot.cpp

  src/snapshotview.cpp

  src/snapshotmanager.cpp

  src/dataformatpanel.cpp

  src/plotcontrolpanel.cpp

  src/recordpanel.cpp

  src/datarecorder.cpp

  src/tooltipfilter.cpp

  src/sneakylineedit.cpp

  src/channelinfomodel.cpp

  src/framebufferseries.cpp

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

/*

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

#include <qwt_scale_map.h>

#include "barchart.h"

{

    setSpacing(0);

}

void BarChart::resample()

{

    setSamples(chartData());

}

QVector<double> BarChart::chartData() const

{

    QVector<double> data(numChannels);

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

    {

    }

    return data;

}

QwtColumnSymbol* BarChart::specialSymbol(int sampleIndex, const QPointF& sample) const

{

    if (sampleIndex < 0 || sampleIndex > (int) numChannels)

    {

        return NULL;

    }

    QwtColumnSymbol* symbol = new QwtColumnSymbol(QwtColumnSymbol::Box);

    symbol->setLineWidth(1);

    symbol->setFrameStyle(QwtColumnSymbol::Plain);

    symbol->setPalette(QPalette(color));

/*

  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

#ifndef BARCHART_H

#define BARCHART_H

#include <qwt_plot_barchart.h>

#include <qwt_column_symbol.h>

class BarChart : public QwtPlotBarChart

{

public:

    void resample();

    QwtColumnSymbol* specialSymbol(int sampleIndex, const QPointF&) const;

    void drawSample(

        QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap,

        const QRectF &canvasRect, const QwtInterval &boundingInterval,

        int index, const QPointF &sample ) const;

private:

    QVector<double> chartData() const;

};

#endif // BARCHART_H

/*

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

#include "barscaledraw.h"

#include "utils.h"

{

    barChart.attach(this);

    setAxisMaxMinor(QwtPlot::xBottom, 0);

    update();

    // connect to menu

    connect(&menu->darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

            this, &BarPlot::darkBackground);

    darkBackground(menu->darkBackgroundAction.isChecked());

}

void BarPlot::update()

{

    // Note: -0.99 is used instead of -1 to handle the case of `numOfChannels==1`

    barChart.resample();

    replot();

}

void BarPlot::setYAxis(bool autoScaled, double yMin, double yMax)

{

/*

  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

#ifndef BARPLOT_H

#define BARPLOT_H

#include <qwt_plot.h>

#include "plotmenu.h"

#include "barchart.h"

class BarPlot : public QwtPlot

{

    Q_OBJECT

public:

                     PlotMenu* menu,

                     QWidget* parent = 0);

public slots:

    /// Set the Y axis

    void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);

    /// Enable/disable dark background

    void darkBackground(bool enabled);

private:

    PlotMenu* _menu;

    BarChart barChart;

    QVector<double> chartData() const;

private slots:

/*

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

#include <QtDebug>

{

    enableComponent(Backbone, false);

    setLabelRotation(-90);

    setLabelAlignment(Qt::AlignLeft | Qt::AlignVCenter);

            [this]()

            {

                invalidateCache();

            });

}

QwtText BarScaleDraw::label(double value) const

{

    int index = value;

    if (index >=0 && index < (int) numChannels)

    {

    }

    else

    {

        return QString("");

    }

}

/*

  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

#define BARSCALEDRAW_H

#include <QStringList>

#include <qwt_scale_draw.h>

#include <qwt_text.h>

class BarScaleDraw : public QwtScaleDraw

{

public:

    QwtText label(double value) const;

private:

};

#endif // BARSCALEDRAW_H

{

    return currentReader->numChannels();

}

Source* DataFormatPanel::activeSource()

{

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

    currentReader->pause(enabled);

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

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

        emit sourceChanged(currentReader);

    ui->horizontalLayout->removeWidget(currentReader->settingsWidget());

    currentReader->settingsWidget()->hide();

    ui->horizontalLayout->addWidget(reader->settingsWidget(), 1);

    reader->settingsWidget()->show();

    // notify if number of channels is different

    {

    }

    reader->pause(paused);

    currentReader = reader;

    emit sourceChanged(currentReader);

}

void DataFormatPanel::saveSettings(QSettings* settings)

public slots:

    void pause(bool);

    /// Sets the number of channels, this doesn't trigger a `numOfChannelsChanged` signal.

    void setNumOfChannels(unsigned value);

private:

    bool paused;

    unsigned _numChannels;

    QTimer timer;

    int count;

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

*/

#include <math.h>

#include "framebufferseries.h"

{

    xAsIndex = true;

    _xmin = 0;

    _xmax = 1;

    _buffer = buffer;

    int_index_start = 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

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    secondaryPlot(NULL),

    commandPanel(&serialPort),

    updateCheckDialog(this)

{

    ui->setupUi(this);

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

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

    ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");

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

    ui->tabWidget->insertTab(4, &recordPanel, "Record");

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

                     this, SLOT(clearPlot()));

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

                     plotMan, &PlotManager::flashSnapshotOverlay);

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

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

                     [this](bool enabled)

                     {

                         if (enabled && !recordPanel.recordPaused())

                         {

    connect(&serialPort, &QIODevice::aboutToClose,

            &recordPanel, &RecordPanel::onPortClose);

    // init data arrays and plot

    numOfSamples = plotControlPanel.numOfSamples();

    // init scales

    plotMan->setYAxis(plotControlPanel.autoScale(),

                      plotControlPanel.yMin(), plotControlPanel.yMax());

    plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),

                      plotControlPanel.xMin(), plotControlPanel.xMax());

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

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

}

void MainWindow::clearPlot()

{

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    plotMan->replot();

}

void MainWindow::onSpsChanged(unsigned sps)

{

    spsLabel.setText(QString::number(sps) + "sps");

}

void MainWindow::showBarPlot(bool show)

{

    if (show)

    {

        plot->setYAxis(plotControlPanel.autoScale(),

                       plotControlPanel.yMin(),

                       plotControlPanel.yMax());

        connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

                plot, &BarPlot::setYAxis);

        showSecondary(plot);

void MainWindow::saveAllSettings(QSettings* settings)

{

    saveMWSettings(settings);

    portControl.saveSettings(settings);

    dataFormatPanel.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

    plotMenu.saveSettings(settings);

    commandPanel.saveSettings(settings);

    recordPanel.saveSettings(settings);

    updateCheckDialog.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

    plotMenu.loadSettings(settings);

    commandPanel.loadSettings(settings);

    recordPanel.loadSettings(settings);

    updateCheckDialog.loadSettings(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 "portcontrol.h"

#include "commandpanel.h"

#include "dataformatpanel.h"

#include "plotcontrolpanel.h"

#include "recordpanel.h"

#include "ui_about_dialog.h"

#include "snapshotmanager.h"

#include "plotmanager.h"

#include "plotmenu.h"

#include "datarecorder.h"

#include "updatecheckdialog.h"

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    QList<QwtPlotCurve*> curves;

    PlotManager* plotMan;

    QWidget* secondaryPlot;

    SnapshotManager snapshotMan;

    DataRecorder recorder;       // operated by `recordPanel`

    QLabel spsLabel;

    void closeEvent(QCloseEvent * event);

private slots:

    void onPortToggled(bool open);

    void onNumOfSamplesChanged(int value);

    void clearPlot();

    void onSpsChanged(unsigned sps);

    void enableDemo(bool enabled);

    void showBarPlot(bool show);

#include "setting_defines.h"

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

                         const Stream* stream, QObject* parent) :

    QObject(parent)

{

    _menu = menu;

    _plotArea = plotArea;

    _autoScaled = true;

    _yMin = 0;

    _yMax = 1;

    _xAxisAsIndex = true;

    isDemoShown = false;

    _numOfSamples = 1;

    _plotWidth = 1;

    showSymbols = Plot::ShowSymbolsAuto;

    emptyPlot = NULL;

    // initalize layout and single widget

    // initial settings from menu actions

    showGrid(menu->showGridAction.isChecked());

    showMinorGrid(menu->showMinorGridAction.isChecked());

    darkBackground(menu->darkBackgroundAction.isChecked());

    showLegend(menu->showLegendAction.isChecked());

    setMulti(menu->showMultiAction.isChecked());

}

PlotManager::~PlotManager()

{

    while (curves.size())

    {

    }

    if (scrollArea != NULL) delete scrollArea;

    if (emptyPlot != NULL) delete emptyPlot;

}

void PlotManager::onChannelInfoChanged(const QModelIndex &topLeft,

                                       const QModelIndex &bottomRight,

                                       const QVector<int> &roles)

{

    int start = topLeft.row();

    int end = bottomRight.row();

        plot->setXAxis(_xMin, _xMax);

    }

    return plot;

}

{

    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;

    curve->setPen(color);

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

    Plot* plot;

    if (isMulti)

    {