update();

    connect(_channelMan, &ChannelManager::dataAdded, this, &BarPlot::update);

    connect(_channelMan, &ChannelManager::numOfChannelsChanged, this, &BarPlot::update);

}

void BarPlot::update()

{

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

    setAxisScale(QwtPlot::xBottom, 0, _channelMan->numOfChannels()-0.99, 1);

    barChart.resample();

    replot();

}

{

    Q_OBJECT

public:

    explicit BarPlot(ChannelManager* channelMan, QWidget* parent = 0);

private:

    ChannelManager* _channelMan;

    BarChart barChart;

    QVector<double> chartData() const;

private slots:

    void update();

};

#endif // BARPLOT_H

        {0, "Port"},

        {1, "DataFormat"},

        {2, "Plot"},

        {3, "Commands"}

    });

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    channelMan(1, 1, this),

    snapshotMan(this, &channelMan),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort, &channelMan, &recorder),

    recordPanel(&recorder, &channelMan),

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

    ui->tabWidget->setCurrentIndex(0);

    auto tbPortControl = portControl.toolBar();

    addToolBar(tbPortControl);

    addToolBar(recordPanel.toolbar());

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

    {

        commandPanel.newCommandAction()->trigger();

    }

    // Important: This should be after newCommandAction is triggered

    // (above) we don't want user to be greeted with command panel on

    // the very first run.

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

            {

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

                this->ui->tabWidget->showTabs();

            });

}

MainWindow::~MainWindow()

{

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete plotMan;

    delete ui;

#include <qwt_plot_curve.h>

#include "portcontrol.h"

#include "commandpanel.h"

#include "dataformatpanel.h"

#include "plotcontrolpanel.h"

#include "recordpanel.h"

#include "ui_about_dialog.h"

#include "framebuffer.h"

#include "channelmanager.h"

#include "snapshotmanager.h"

#include "plotmanager.h"

#include "datarecorder.h"

#include "updatecheckdialog.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    QList<QwtPlotCurve*> curves;

    ChannelManager channelMan;

    PlotManager* plotMan;

    SnapshotManager snapshotMan;

    DataRecorder recorder;       // operated by `recordPanel`

    QLabel spsLabel;

    CommandPanel commandPanel;

    DataFormatPanel dataFormatPanel;

    RecordPanel recordPanel;

    PlotControlPanel plotControlPanel;

    UpdateCheckDialog updateCheckDialog;

    bool isDemoRunning();

    /// Stores settings for all modules

#include <algorithm>

#include <QActionGroup>

#include <QMetaEnum>

#include <QtDebug>

#include "qwt_symbol.h"

#include "plot.h"

#include "plotmanager.h"

#include "utils.h"

#include "setting_defines.h"

    QObject(parent),

    _plotArea(plotArea),

    showGridAction("&Grid", this),

    showMinorGridAction("&Minor Grid", this),

    unzoomAction("&Unzoom", this),

    darkBackgroundAction("&Dark Background", this),

    showLegendAction("&Legend", this),

    showMultiAction("Multi &Plot", this),

    setSymbolsAction("Symbols", this)

{

    _autoScaled = true;

    _yMin = 0;

    _yMax = 1;

    _xAxisAsIndex = true;

    isDemoShown = false;

    _infoModel = infoModel;

    _numOfSamples = 1;

    _plotWidth = 1;

    showSymbols = Plot::ShowSymbolsAuto;

    emptyPlot = NULL;

    // initalize layout and single widget

    isMulti = false;

    scrollArea = NULL;

    setupLayout(isMulti);

    addPlotWidget();

    // initialize menu actions

    showGridAction.setToolTip("Show Grid");

    showMinorGridAction.setToolTip("Show Minor Grid");

    unzoomAction.setToolTip("Unzoom the Plot");

    darkBackgroundAction.setToolTip("Enable Dark Plot Background");

    showLegendAction.setToolTip("Display the Legend on Plot");

    showMultiAction.setToolTip("Display All Channels Separately");

    setSymbolsAction.setToolTip("Show/Hide symbols");

    showGridAction.setShortcut(QKeySequence("G"));

    showMinorGridAction.setShortcut(QKeySequence("M"));

    showGridAction.setCheckable(true);

    showMinorGridAction.setCheckable(true);

    darkBackgroundAction.setCheckable(true);

    showLegendAction.setCheckable(true);

    showMultiAction.setCheckable(true);

    showGridAction.setChecked(false);

    showMinorGridAction.setChecked(false);

    darkBackgroundAction.setChecked(false);

    showLegendAction.setChecked(true);

    showMultiAction.setChecked(false);

    showMinorGridAction.setEnabled(false);

    // setup symbols menu

    setSymbolsAutoAct = setSymbolsMenu.addAction("Show When Zoomed");

    setSymbolsAutoAct->setCheckable(true);

    setSymbolsAutoAct->setChecked(true);

    connect(setSymbolsAutoAct, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            [this](bool checked)

            {

                if (checked) setSymbols(Plot::ShowSymbolsAuto);

            });

            &showMinorGridAction, &QAction::setEnabled);

    connect(&showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showMinorGrid);

    connect(&unzoomAction, &QAction::triggered, this, &PlotManager::unzoom);

    connect(&darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::darkBackground);

    connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showLegend);

    connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showLegend);

    connect(&showMultiAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::setMulti);

    // connect to channel info model

    if (_infoModel != NULL)     // TODO: remove when snapshots have 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

        auto plot = addPlotWidget();

        // attach all curves

        for (auto curve : curves)

        {

            curve->attach(plot);

        }

    }

    checkNoVisChannels();

}

void PlotManager::setupLayout(bool multiPlot)

{

    // delete previous layout if it exists

    if (_plotArea->layout() != 0)

    {

        delete _plotArea->layout();

    }

    if (multiPlot)

    {

        // setup a scroll area

        scrollArea = new QScrollArea();

    }

}

QList<QAction*> PlotManager::menuActions()

{

    QList<QAction*> actions;

    actions << &showGridAction;

    actions << &showMinorGridAction;

    actions << &unzoomAction;

    actions << &darkBackgroundAction;

    actions << &showLegendAction;

    actions << &showMultiAction;

    actions << &setSymbolsAction;

    return actions;

}

void PlotManager::showGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showGrid(show);

    }

}

    for (auto plot : plotWidgets)

    {

        plot->unzoom();

    }

}

void PlotManager::darkBackground(bool enabled)

{

    for (auto plot : plotWidgets)

    {

        plot->darkBackground(enabled);

    }

}

void PlotManager::setSymbols(Plot::ShowSymbols shown)

{

    showSymbols = shown;

    for (auto plot : plotWidgets)

    {

        plot->setSymbols(shown);

    }

}

void PlotManager::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)

#ifndef PLOTMANAGER_H

#define PLOTMANAGER_H

#include <QObject>

#include <QWidget>

#include <QScrollArea>

#include <QVBoxLayout>

#include <QList>

#include <QSettings>

#include <QAction>

#include <QMenu>

#include <qwt_plot_curve.h>

#include "plot.h"

#include "framebufferseries.h"

#include "channelinfomodel.h"

struct PlotViewSettings

{

    bool showGrid;

    bool showMinorGrid;

    bool darkBackground;

    bool showLegend;

    bool showMulti;

    Plot::ShowSymbols showSymbols;

};

class PlotManager : public QObject

{

    Q_OBJECT

public:

    ~PlotManager();

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

    /// automatically chosen for curve.

    void addCurve(QString title, FrameBuffer* buffer);

    /// Alternative of `addCurve` for static curve data (snapshots).

    void addCurve(QString title, QVector<QPointF> data);

    /// Set the displayed title for a curve

    void setTitle(unsigned index, QString title);

    /// Removes curves from the end

    void removeCurves(unsigned number);

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

    unsigned numOfCurves();

    /// Returns the list of actions to be inserted into the `View` menu

    QList<QAction*> menuActions();

    /// Returns current status of menu actions

    PlotViewSettings viewSettings() const;

    /// Set the current state of view

    void setViewSettings(const PlotViewSettings& settings);

    /// Stores plot settings into a `QSettings`.

    void saveSettings(QSettings* settings);

    /// Loads plot settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    /// Update all plot widgets

    void replot();

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

    void showDemoIndicator(bool show = true);

    /// Set the Y axis

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

    /// Set the X axis

    void setXAxis(bool asIndex, double xMin = 0 , double xMax = 1);

    /// Display an animation for snapshot

    void flashSnapshotOverlay();

    /// Should be called to update zoom base

    void setNumOfSamples(unsigned value);

    /// Maximum width of X axis (limit of hscroll)

    void setPlotWidth(double width);

private:

    bool isMulti;

    QWidget* _plotArea;

    QVBoxLayout* layout; ///< layout of the `plotArea`

    QScrollArea* scrollArea;

    QList<QwtPlotCurve*> curves;

    QList<Plot*> plotWidgets;

    Plot* emptyPlot;  ///< for displaying when all channels are hidden

    ChannelInfoModel* _infoModel;

    bool isDemoShown;

    bool _autoScaled;

    double _yMin;

    double _yMax;

    bool _xAxisAsIndex;

    double _xMin;

    double _xMax;

    unsigned _numOfSamples;

    double _plotWidth;

    Plot::ShowSymbols showSymbols;

    // menu actions

    QAction showGridAction;

    QAction showMinorGridAction;

    QAction unzoomAction;

    QAction darkBackgroundAction;

    QAction showLegendAction;

    QAction showMultiAction;

    QAction setSymbolsAction;

    QMenu setSymbolsMenu;

    QAction* setSymbolsAutoAct;

    QAction* setSymbolsShowAct;

    QAction* setSymbolsHideAct;

    void setupLayout(bool multiPlot);

    /// Inserts a new plot widget to the current layout.

    Plot* addPlotWidget();

    /// Returns the plot widget that given curve is attached to

    Plot* plotWidget(unsigned curveIndex);

    /// Common part of overloaded `addCurve` functions

    void _addCurve(QwtPlotCurve* curve);

    void setSymbols(Plot::ShowSymbols shown);

    /// Check and make sure "no visible channels" text is shown

    void checkNoVisChannels();

private slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

    void onChannelInfoChanged(const QModelIndex & topLeft,

                              const QModelIndex & bottomRight,

                              const QVector<int> & roles = QVector<int> ());

};

#endif // PLOTMANAGER_H

#include "snapshotview.h"

#include "ui_snapshotview.h"

SnapshotView::SnapshotView(MainWindow* parent, Snapshot* snapshot) :

    QMainWindow(parent),

    ui(new Ui::SnapshotView),

    renameDialog(this)

{

    _snapshot = snapshot;

    ui->setupUi(this);

    plotMan->setViewSettings(parent->viewSettings());

    ui->menuSnapshot->insertAction(ui->actionClose, snapshot->deleteAction());

    this->setWindowTitle(snapshot->displayName());

    // initialize curves

    unsigned numOfChannels = snapshot->data.size();

    unsigned numOfSamples = snapshot->data[0].size();

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

    {

        plotMan->addCurve(snapshot->channelName(ci), snapshot->data[ci]);

    }