&aboutDialog, &QWidget::show);

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

                     [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});

    // File menu signals

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

                     this, &MainWindow::onExportCsv);

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

                     this, &MainWindow::onSaveSettings);

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

                     this, &MainWindow::onLoadSettings);

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

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            this, &MainWindow::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            plotMan, &PlotManager::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

            plotMan, &PlotManager::setYAxis);

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

                     this, SLOT(clearPlot()));

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

                     plotMan, &PlotManager::flashSnapshotOverlay);

    // init port signals

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

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

    // init data format and reader

    QObject::connect(&channelMan, &ChannelManager::dataAdded,

                     plotMan, &PlotManager::replot);

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

                     &channelMan, &ChannelManager::pause);

    QObject::connect(&recordPanel, &RecordPanel::recordStarted,

                     &dataFormatPanel, &DataFormatPanel::startRecording);

    QObject::connect(&recordPanel, &RecordPanel::recordStopped,

                     &dataFormatPanel, &DataFormatPanel::stopRecording);

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

Q_DECLARE_METATYPE(Range);

PlotControlPanel::PlotControlPanel(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::PlotControlPanel),

    resetAct(tr("Reset"), this),

    resetNamesAct(tr("Reset Names"), this),

    resetColorsAct(tr("Reset Colors"), this),

    showAllAct(tr("Show All"), this),

    resetMenu(tr("Reset Menu"), this)

{

    ui->setupUi(this);

    warnNumOfSamples = true;    // TODO: load from settings

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

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

    // connect signals

    connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

            this, SLOT(onNumOfSamples(int)));

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

            this, &PlotControlPanel::onAutoScaleChecked);

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

            this, SLOT(onYScaleChanged()));

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

            this, SLOT(onYScaleChanged()));

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

bool PlotControlPanel::autoScale()

{

    return ui->cbAutoScale->isChecked();

}

double PlotControlPanel::yMax()

{

    return ui->spYmax->value();

}

double PlotControlPanel::yMin()

{

    return ui->spYmin->value();

}

void PlotControlPanel::onRangeSelected()

{

    Range r = ui->cbRangePresets->currentData().value<Range>();

    ui->spYmin->setValue(r.rmin);

    ui->spYmax->setValue(r.rmax);

    ui->cbAutoScale->setChecked(false);

}

void PlotControlPanel::setChannelInfoModel(ChannelInfoModel* model)

{

    ui->tvChannelInfo->setModel(model);

    // channel color selector

    connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::currentRowChanged,

            [this](const QModelIndex &current, const QModelIndex &previous)

            {

                // TODO: duplicate with below lambda

                QColor color(0,0,0,0); // transparent

                if (current.isValid())

                {

                    ui->colorSelector->setEnabled(true);

                    auto model = ui->tvChannelInfo->model();

                    color = model->data(current, Qt::ForegroundRole).value<QColor>();

                }

                else

                {

                    ui->colorSelector->setDisabled(true);

                }

                // temporarily block signals because `setColor` emits `colorChanged`

                bool wasBlocked = ui->colorSelector->blockSignals(true);

class PlotControlPanel : public QWidget

{

    Q_OBJECT

public:

    explicit PlotControlPanel(QWidget *parent = 0);

    ~PlotControlPanel();

    unsigned numOfSamples();

    bool autoScale();

    double yMax();

    double yMin();

    void setChannelInfoModel(ChannelInfoModel* model);

    /// Stores plot settings into a `QSettings`

    void saveSettings(QSettings* settings);

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

    void loadSettings(QSettings* settings);

signals:

    void numOfSamplesChanged(int value);

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

private:

    Ui::PlotControlPanel *ui;

    /// Holds 'number of samples' after the confirmation

    unsigned _numOfSamples;

    /// User can disable this setting in the checkbox

    bool warnNumOfSamples;

    QAction resetAct, resetNamesAct, resetColorsAct, showAllAct;

    QMenu resetMenu;

    /// Show a confirmation dialog before setting #samples to a big value

    bool askNSConfirmation(int value);

private slots:

    void onNumOfSamples(int value);

    void onAutoScaleChecked(bool checked);

    void onYScaleChanged();

    void onRangeSelected();

};

#endif // PLOTCONTROLPANEL_H

    layout->setContentsMargins(2,2,2,2);

    layout->setSpacing(1);

}

Plot* PlotManager::addPlotWidget()

{

    auto plot = new Plot();

    plotWidgets.append(plot);

    layout->addWidget(plot);

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

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

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

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

    plot->showDemoIndicator(isDemoShown);

    plot->setAxis(_autoScaled, _yMin, _yMax);

    return plot;

}

void PlotManager::addCurve(QString title, FrameBuffer* buffer)

{

    auto curve = new QwtPlotCurve(title);

    auto series = new FrameBufferSeries(buffer);

    curve->setSamples(series);

    _addCurve(curve);

}

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

{

    auto curve = new QwtPlotCurve(title);

    curve->setSamples(data);

    _addCurve(curve);

}

void PlotManager::_addCurve(QwtPlotCurve* curve)

{

    // store and init the curve

    curves.append(curve);

    unsigned index = curves.size()-1;

    auto color = _infoModel->color(index);

    curve->setPen(color);

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

    Plot* plot;

    if (isMulti)

    {

    {

        plot->unzoom();

    }

}

void PlotManager::darkBackground(bool enabled)

{

    for (auto plot : plotWidgets)

    {

        plot->darkBackground(enabled);

    }

}

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

{

    _autoScaled = autoScaled;

    _yMin = yAxisMin;

    _yMax = yAxisMax;

    for (auto plot : plotWidgets)

    {

        plot->setAxis(autoScaled, yAxisMin, yAxisMax);

    }

}

void PlotManager::flashSnapshotOverlay()

{

    for (auto plot : plotWidgets)

    {

        plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());

    }

}

void PlotManager::onNumOfSamplesChanged(unsigned value)

{

    for (auto plot : plotWidgets)

    {

        plot->onNumOfSamplesChanged(value);

    }

}

void PlotManager::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    settings->setValue(SG_Plot_DarkBackground, darkBackgroundAction.isChecked());

    settings->setValue(SG_Plot_Grid, showGridAction.isChecked());

    settings->setValue(SG_Plot_MinorGrid, showMinorGridAction.isChecked());

    settings->setValue(SG_Plot_Legend, showLegendAction.isChecked());

    settings->setValue(SG_Plot_MultiPlot, showMultiAction.isChecked());

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

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

    void saveSettings(QSettings* settings);

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

    void loadSettings(QSettings* settings);

public slots:

    /// Enable/Disable multiple plot display

    void setMulti(bool enabled);

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

    /// Display an animation for snapshot

    void flashSnapshotOverlay();

    /// Should be called to update zoom base

    void onNumOfSamplesChanged(unsigned value);

private:

    bool isMulti;

    QWidget* _plotArea;

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

    QScrollArea* scrollArea;

    QList<QwtPlotCurve*> curves;

    QList<Plot*> plotWidgets;

    ChannelInfoModel* _infoModel;

    bool isDemoShown;

    bool _autoScaled;

    double _yMin;

    double _yMax;

    // menu actions

    QAction showGridAction;

    QAction showMinorGridAction;

    QAction unzoomAction;

    QAction darkBackgroundAction;

    QAction showLegendAction;

    QAction showMultiAction;

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

private slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);