{

            delete scrollArea;

            scrollArea = NULL;

        }

        layout = new QVBoxLayout(_plotArea);

    }

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

    layout->setSpacing(1);

}

Plot* PlotManager::addPlotWidget()

{

    auto plot = new Plot();

    plotWidgets.append(plot);

    layout->addWidget(plot);

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

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

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

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

    plot->setSymbols(_menu->showSymbols());

    plot->showDemoIndicator(isDemoShown);

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

    plot->setNumOfSamples(_numOfSamples);

    plot->setPlotWidth(_plotWidth);

    if (_xAxisAsIndex)

    {

        plot->setXAxis(0, _numOfSamples);

    }

    else

    {

        plot->setXAxis(_xMin, _xMax);

    }

    return plot;

}

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

{

    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;

    auto color = infoModel->color(index);

    curve->setPen(color);

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

    Plot* plot;

    if (isMulti)

    {

        // create a new plot widget

        plot = addPlotWidget();

    }

    else

    {

        plot = plotWidgets[0];

    }

    // show the curve

    curve->attach(plot);

    plot->replot();

}

void PlotManager::removeCurves(unsigned number)

{

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

    {

        if (!curves.isEmpty())

        {

            delete curves.takeLast();

            if (isMulti) // delete corresponding widget as well

            {

                delete plotWidgets.takeLast();

            }

        }

    }

}

unsigned PlotManager::numOfCurves()

{

    return curves.size();

}

Plot* PlotManager::plotWidget(unsigned curveIndex)

{

    if (isMulti)

    {

        return plotWidgets[curveIndex];

    }

    else

    {

        return plotWidgets[0];

    }

}

void PlotManager::replot()

{

    for (auto plot : plotWidgets)

    {

        plot->replot();

    }

}

void PlotManager::showGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showGrid(show);

    }

}

void PlotManager::showMinorGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showMinorGrid(show);

    }

}

void PlotManager::showLegend(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showLegend(show);

    }

}

void PlotManager::showDemoIndicator(bool show)

{

    isDemoShown = show;

    for (auto plot : plotWidgets)

    {

        plot->showDemoIndicator(show);

    }

}

void PlotManager::unzoom()

{

    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)

{

    _autoScaled = autoScaled;

    _yMin = yAxisMin;

    _yMax = yAxisMax;

    for (auto plot : plotWidgets)

    {

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

    }

}

void PlotManager::setXAxis(bool asIndex, double xMin, double xMax)

{

    _xAxisAsIndex = asIndex;

    _xMin = xMin;

    _xMax = xMax;

    for (auto curve : curves)

    {

        FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());

        series->setXAxis(asIndex, xMin, xMax);

    }

    for (auto plot : plotWidgets)

    {

        if (asIndex)

        {

            plot->setXAxis(0, _numOfSamples);

        }

        else

        {

            plot->setXAxis(xMin, xMax);

        }

    }

    replot();

}

void PlotManager::flashSnapshotOverlay()

{

    for (auto plot : plotWidgets)

    {

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

    }

}

void PlotManager::setNumOfSamples(unsigned value)

{

    _numOfSamples = value;

    for (auto plot : plotWidgets)

    {

        plot->setNumOfSamples(value);

        if (_xAxisAsIndex) plot->setXAxis(0, value);

    }

}

void PlotManager::setPlotWidth(double width)

{

    _plotWidth = width;

    for (auto plot : plotWidgets)

    {

        plot->setPlotWidth(width);

    }

}

/*

  Copyright © 2018 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 "stream.h"

#include "ringbuffer.h"

#include "indexbuffer.h"

Stream::Stream(unsigned nc, bool x, unsigned ns) :

    _infoModel(nc)

{

    _numSamples = ns;

    _paused = false;

    // create xdata buffer

    _hasx = x;

    if (x)

    {

        xData = new RingBuffer(ns);

    }

    else

    {

        xData = new IndexBuffer(ns);

    }

    // create channels

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

    {

        auto c = new StreamChannel(i, xData, new RingBuffer(ns), &_infoModel);

        channels.append(c);

    }

}

Stream::~Stream()

{

}

bool Stream::hasX() const

{

    return _hasx;

}

unsigned Stream::numChannels() const

{

    return channels.length();

}

unsigned Stream::numSamples() const

{

    return _numSamples;

}

const StreamChannel* Stream::channel(unsigned index) const

{

    Q_ASSERT(index < numChannels());

    return channels[index];

}

StreamChannel* Stream::channel(unsigned index)

{

    return const_cast<StreamChannel*>(static_cast<const Stream&>(*this).channel(index));

}

const ChannelInfoModel* Stream::infoModel() const

{

    return &_infoModel;

}

ChannelInfoModel* Stream::infoModel()

{

    return const_cast<ChannelInfoModel*>(static_cast<const Stream&>(*this).infoModel());

}

void Stream::setNumChannels(unsigned nc, bool x)

{

    unsigned oldNum = numChannels();

    if (oldNum == nc && x == _hasx) return;

    // adjust the number of channels

    if (nc > oldNum)

    {

        for (unsigned i = oldNum; i < nc; i++)

        {

            auto c = new StreamChannel(i, xData, new RingBuffer(_numSamples), &_infoModel);

            channels.append(c);

        }

    }

    else if (nc < oldNum)

    {

        for (unsigned i = oldNum-1; i > nc-1; i--)

        {

            delete channels.takeLast();

        }

    }

    // change the xdata

    if (x != _hasx)

    {

        if (x)

        {

            xData = new RingBuffer(_numSamples);

        }

        else

        {

            xData = new IndexBuffer(_numSamples);

        }

        for (auto c : channels)

        {

            c->setX(xData);

        }

        _hasx = x;

    }

    if (nc != oldNum)

    {

        _infoModel.setNumOfChannels(nc);

        emit numChannelsChanged(nc);

    }

    Sink::setNumChannels(nc, x);

}

void Stream::feedIn(const SamplePack& data)

{

    Q_ASSERT(data.numChannels() == numChannels() &&

             data.hasX() == hasX());

    if (_paused) return;

    unsigned ns = data.numSamples();

    if (_hasx)

    {

        static_cast<RingBuffer*>(xData)->addSamples(data.xData(), ns);

    }

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

    {

        static_cast<RingBuffer*>(channels[i]->yData())->addSamples(data.data(i), ns);

    }

    Sink::feedIn(data);

    emit dataAdded();

}

void Stream::pause(bool paused)

{

    _paused = paused;

}

void Stream::clear()

{

    for (auto c : channels)

    {

        static_cast<RingBuffer*>(c->yData())->clear();

    }

}

void Stream::setNumSamples(unsigned value)

{

    if (value == _numSamples) return;

    _numSamples = value;

    xData->resize(value);

    for (auto c : channels)

    {

        static_cast<RingBuffer*>(c->yData())->resize(value);

    }

}

void Stream::saveSettings(QSettings* settings) const

{

    _infoModel.saveSettings(settings);

}

void Stream::loadSettings(QSettings* settings)

{

    _infoModel.loadSettings(settings);

}