void Plot::setAxis(bool autoScaled, double yAxisMin, double yAxisMax)

{

    this->isAutoScaled = autoScaled;

    if (!autoScaled)

    {

        yMin = yAxisMin;

        yMax = yAxisMax;

    }

    zoomer.zoom(0);

    resetAxes();

}

void Plot::resetAxes()

{

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

        legend.setTextPen(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));

        legend.setTextPen(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;

  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/>.

*/

#ifndef PLOT_H

#define PLOT_H

#include <QColor>

#include <QList>

#include <QAction>

#include <qwt_plot.h>

#include <qwt_plot_grid.h>

#include <qwt_plot_shapeitem.h>

#include <qwt_plot_legenditem.h>

#include "zoomer.h"

#include "scalezoomer.h"

#include "plotsnapshotoverlay.h"

class Plot : public QwtPlot

{

    Q_OBJECT

public:

    Plot(QWidget* parent = 0);

    ~Plot();

    static QColor makeColor(unsigned int channelIndex);

private:

    bool isAutoScaled;

    double yMin, yMax;

    Zoomer zoomer;

    ScaleZoomer sZoomer;

    QwtPlotGrid grid;

    PlotSnapshotOverlay* snapshotOverlay;

    QwtPlotLegendItem legend;

    void resetAxes();

public slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

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

    void flashSnapshotOverlay();

private slots:

    void unzoomed();

};

#endif // PLOT_H

PlotManager::PlotManager(QWidget* plotArea, QObject *parent) :

    QObject(parent),

    _plotArea(plotArea),

    showGridAction("Grid", this),

    showMinorGridAction("Minor Grid", this),

    unzoomAction("Unzoom", this),

    darkBackgroundAction("Dark Background", this),

    showLegendAction("Legend", this)

{

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

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

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

    showGridAction.setCheckable(true);

    showMinorGridAction.setCheckable(true);

    darkBackgroundAction.setCheckable(true);

    showLegendAction.setCheckable(true);

    showGridAction.setChecked(false);

    showMinorGridAction.setChecked(false);

    darkBackgroundAction.setChecked(false);

    showLegendAction.setChecked(true);

    showMinorGridAction.setEnabled(false);

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

            this, &PlotManager::showGrid);

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

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

}

PlotManager::~PlotManager()

{

    while (curves.size())

    {

        delete curves.takeLast();

    }

    // remove all widgets

    while (plotWidgets.size())

    {

        delete plotWidgets.takeLast();

    }

    if (scrollArea != NULL) delete scrollArea;

}

void PlotManager::setMulti(bool enabled)

{

    if (enabled == isMulti) return;

    isMulti = enabled;

    // detach all curves

    for (auto curve : curves)

    {

        curve->detach();

    }

    // remove all widgets

    while (plotWidgets.size())

    {

        delete plotWidgets.takeLast();

    }

    // setup new layout

    setupLayout(isMulti);

    if (isMulti)

    {

        // add new widgets and attach

        for (auto curve : curves)

        {

            curve->attach(addPlotWidget());

        }

    }

    else

        for (auto curve : curves)

        {

            curve->attach(plot);

        }

    }

}

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

        auto scrolledPlotArea = new QWidget(scrollArea);

        scrollArea->setWidget(scrolledPlotArea);

        scrollArea->setWidgetResizable(true);

        _plotArea->setLayout(new QVBoxLayout());

        _plotArea->layout()->addWidget(scrollArea);

        layout = new QVBoxLayout(scrolledPlotArea);

    }

    else

    {

        // delete scrollArea left from multi layout

        if (scrollArea != NULL) delete scrollArea;

        layout = new QVBoxLayout(_plotArea);

    }

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

    return plot;

}

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

{

    Plot* plot;

    if (isMulti)

    {

        // create a new plot widget

        plot = addPlotWidget();

    }

    else

    {

        plot = plotWidgets[0];

    }

    // create the curve

    QwtPlotCurve* curve = new QwtPlotCurve(title);

    curves.append(curve);

    curve->setSamples(new FrameBufferSeries(buffer));

    unsigned index = curves.size()-1;

    curve->setPen(Plot::makeColor(index));

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

}

void PlotManager::setTitle(unsigned index, QString title)

{

    curves[index]->setTitle(title);

    plotWidget(index)->replot();

}

Plot* PlotManager::plotWidget(unsigned curveIndex)

{

    if (isMulti)

    {

        return plotWidgets[curveIndex];

    }

    else

    {

        return plotWidgets[0];

    }

}

void PlotManager::replot()

{

    for (auto plot : plotWidgets)

    {

        plot->replot();

    }

}

QList<QAction*> PlotManager::menuActions()

{

    QList<QAction*> actions;

    actions << &showGridAction;

    actions << &showMinorGridAction;

    actions << &unzoomAction;

    actions << &darkBackgroundAction;

    actions << &showLegendAction;

    return actions;

}

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::unzoom()

{

    for (auto plot : plotWidgets)

    {

        plot->unzoom();

    }

}

void PlotManager::darkBackground(bool enabled)

{

    for (auto plot : plotWidgets)

    {

        plot->darkBackground(enabled);

    }

}

    explicit PlotManager(QWidget* plotArea, QObject *parent = 0);

    ~PlotManager();

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

    /// automatically chosen for curve.

    void addCurve(QString title, FrameBuffer* buffer);

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

public slots:

    /// Enable/Disable multiple plot display

    void setMulti(bool enabled);

    /// Update all plot widgets

    void replot();

private:

    bool isMulti;

    QWidget* _plotArea;

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

    QScrollArea* scrollArea;

    QList<QwtPlotCurve*> curves;

    QList<Plot*> plotWidgets;

    // menu actions

    QAction showGridAction;

    QAction showMinorGridAction;

    QAction unzoomAction;

    QAction darkBackgroundAction;

    QAction showLegendAction;

    void setupLayout(bool multiPlot);

    Plot* addPlotWidget(); ///< inserts a new plot widget to the current layout

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

    Plot* plotWidget(unsigned curveIndex);

private slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

};

#endif // PLOTMANAGER_H