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

#include <QKeySequence>

#include <QColor>

#include <qwt_symbol.h>

#include <qwt_plot_curve.h>

#include <math.h>

#include <algorithm>

#include "plot.h"

#include "utils.h"

static const int SYMBOL_SHOW_AT_WIDTH = 5;

static const int SYMBOL_SIZE_MAX = 7;

    QwtPlot(parent),

    sZoomer(this, &zoomer)

{

    isAutoScaled = true;

    symbolSize = 0;

    numOfSamples = 1;

    plotWidth = 1;

    showSymbols = Plot::ShowSymbolsAuto;

    QObject::connect(&zoomer, &Zoomer::unzoomed, this, &Plot::unzoomed);

    zoomer.setZoomBase();

    grid.attach(this);

    legend.attach(this);

    showGrid(false);

    darkBackground(false);

    snapshotOverlay = NULL;

    connect(&zoomer, &QwtPlotZoomer::zoomed,

            [this](const QRectF &rect)

            {

                onXScaleChanged();

            });

    demoText.setColor(QColor("white"));

    demoText.setBackgroundBrush(Qt::darkRed);

    demoText.setBorderRadius(4);

    demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignBottom);

    demoIndicator.setText(demoText);

    demoIndicator.hide();

    demoIndicator.attach(this);

    // init no channels are visible indicator

    QwtText noChannelText(" No Visible Channels ");

    noChannelText.setColor(QColor("white"));

    noChannelText.setBackgroundBrush(Qt::darkBlue);

    noChannelText.setBorderRadius(4);

    noChannelText.setRenderFlags(Qt::AlignHCenter | Qt::AlignVCenter);

    noChannelIndicator.setText(noChannelText);

    noChannelIndicator.hide();

    noChannelIndicator.attach(this);

}

Plot::~Plot()

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

}

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

{

    this->isAutoScaled = autoScaled;

    if (!autoScaled)

    {

        yMin = yAxisMin;

        yMax = yAxisMax;

    }

    zoomer.zoom(0);

    resetAxes();

}

void Plot::setXAxis(double xMin, double xMax)

{

    _xMin = xMin;

    _xMax = xMax;

    zoomer.setXLimits(xMin, xMax);

    zoomer.zoom(0); // unzoom

    // set axis

    // setAxisScale(QwtPlot::xBottom, xMin, xMax);

#include <qwt_plot.h>

#include <qwt_plot_grid.h>

#include <qwt_plot_shapeitem.h>

#include <qwt_plot_legenditem.h>

#include <qwt_plot_textlabel.h>

#include "zoomer.h"

#include "scalezoomer.h"

#include "plotsnapshotoverlay.h"

class Plot : public QwtPlot

{

    Q_OBJECT

    friend class PlotManager;

public:

    enum ShowSymbols

    {

        ShowSymbolsAuto,

        ShowSymbolsShow,

        ShowSymbolsHide

    };

    ~Plot();

public slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void showDemoIndicator(bool show = true);

    void showNoChannel(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

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

    void setXAxis(double xMin, double xMax);

    void setSymbols(ShowSymbols shown);

    /**

     * Displays an animation for snapshot.

     *

     * @param light show a light colored (white) animation or the opposite

     */

    void flashSnapshotOverlay(bool light);

    void setNumOfSamples(unsigned value);

    void setPlotWidth(double width);

protected:

    _stream = stream;

    construct(plotArea, menu);

    if (_stream == nullptr) return;

    // connect to ChannelInfoModel

    infoModel = _stream->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

                                     {}); // roles ignored

            });

    connect(stream, &Stream::numChannelsChanged, this, &PlotManager::onNumChannelsChanged);

    connect(stream, &Stream::dataAdded, this, &PlotManager::replot);

    // add initial curves if any?

    for (unsigned int i = 0; i < stream->numChannels(); i++)

    {

        addCurve(stream->channel(i)->name(), stream->channel(i)->xData(), stream->channel(i)->yData());

    }

}

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

                         Snapshot* snapshot, QObject *parent) :

    QObject(parent)

{

    _stream = nullptr;

    construct(plotArea, menu);

    setNumOfSamples(snapshot->numSamples());

    setPlotWidth(snapshot->numSamples());

    infoModel = snapshot->infoModel();

    for (unsigned ci = 0; ci < snapshot->numChannels(); ci++)

    {

        addCurve(snapshot->channelName(ci), snapshot->xData[ci], snapshot->yData[ci]);

    }

    connect(infoModel, &QAbstractItemModel::dataChanged,

            this, &PlotManager::onChannelInfoChanged);

}

void PlotManager::construct(QWidget* plotArea, PlotMenu* menu)

{

    _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

    isMulti = false;

    scrollArea = NULL;

    // connect to  menu

    connect(menu, &PlotMenu::symbolShowChanged, this, &PlotManager:: setSymbols);

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

            this, &PlotManager::showGrid);

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

            this, &PlotManager::showMinorGrid);

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

            this, &PlotManager::darkBackground);

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

            this, &PlotManager::showLegend);

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

            this, &PlotManager::setMulti);

    connect(&menu->unzoomAction, &QAction::triggered,

            this, &PlotManager::unzoom);

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

}

    if (!isMulti)

    {

        plotWidgets[0]->updateSymbols();

        plotWidgets[0]->updateLegend();

        replot();

    }

}

void PlotManager::checkNoVisChannels()

{

    // if all channels are hidden show indicator

    bool allhidden = std::none_of(curves.cbegin(), curves.cend(),

                                  [](QwtPlotCurve* c) {return c->isVisible();});

    plotWidgets[0]->showNoChannel(allhidden);

    if (isMulti)

    {

        plotWidgets[0]->showNoChannel(allhidden);

        plotWidgets[0]->setVisible(true);

    }

}

void PlotManager::setMulti(bool enabled)

{

    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)

        {

            auto plot = addPlotWidget();

            plot->setVisible(curve->isVisible());

            curve->attach(plot);

        }

    }

    else

    {

        // add a single widget

        auto plot = addPlotWidget();

        // attach all curves

        for (auto curve : curves)

        {

            curve->attach(plot);

        }

    }

    // will skip if no plot widgets exist (can happen during constructor)

    if (plotWidgets.length())

    {

        checkNoVisChannels();

    }

}

void PlotManager::setupLayout(bool multiPlot)

{

    // delete previous layout if it exists

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

    {

        delete _plotArea->layout();

    }

    if (multiPlot)

    {

        _plotArea->setLayout(new QVBoxLayout());

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

        _plotArea->layout()->setContentsMargins(0,0,0,0);

        layout = new QVBoxLayout(scrolledPlotArea);

    }

    else

    {

        // delete scrollArea left from multi layout

        if (scrollArea != NULL)

        {

            delete scrollArea;

            scrollArea = NULL;

        }

        layout = new QVBoxLayout(_plotArea);

    }

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

    layout->setSpacing(1);

}

Plot* PlotManager::addPlotWidget()

{

    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 XFrameBuffer* xBuf, const FrameBuffer* yBuf)

{

    auto curve = new QwtPlotCurve(title);

    auto series = new FrameBufferSeries(xBuf, yBuf);

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

        }

    }

 * synchronized with each other.

 *

 * Implements `Sink` class for data entry. It's expected to be

 * connected to a `Device` source.

 */

class Stream : public QObject, public Sink

{

    Q_OBJECT

public:

    /**

     * @param nc number of channels

     * @param x has X data input

     * @param ns number of samples

     */

    Stream(unsigned nc = 1, bool x = false, unsigned ns = 2);

    ~Stream();

    bool hasX() const;

    unsigned numChannels() const;

    unsigned numSamples() const;

    const StreamChannel* channel(unsigned index) const;

    StreamChannel* channel(unsigned index);

    const ChannelInfoModel* infoModel() const;

    ChannelInfoModel* infoModel();

    /// Saves channel information

    void saveSettings(QSettings* settings) const;

    /// Load channel information

    void loadSettings(QSettings* settings);

protected:

    // implementations for `Sink`

    virtual void setNumChannels(unsigned nc, bool x);

    virtual void feedIn(const SamplePack& pack);

signals:

    void numChannelsChanged(unsigned value);

    void numSamplesChanged(unsigned value);

    void channelAdded(const StreamChannel* chan);

    void channelNameChanged(unsigned channel, QString name); // TODO: does it stay?

    void dataAdded(); ///< emitted when data added to channel man.

public slots:

    /// Change number of samples (buffer size)

    void setNumSamples(unsigned value);

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

#include <qwt_plot.h>

#include <QPen>

#include <QMouseEvent>

#include <QtMath>

static const int VALUE_POINT_DIAM = 4;

static const int VALUE_TEXT_MARGIN = VALUE_POINT_DIAM + 2;

    ScrollZoomer(widget)

{

    is_panning = false;

    setTrackerMode(AlwaysOn);

    // set corner widget between the scrollbars with default background color

    auto cornerWidget = new QWidget();

    auto bgColor = cornerWidget->palette().color(QPalette::Window).name();

    auto styleSheet = QString("background-color:%1;").arg(bgColor);

    cornerWidget->setStyleSheet(styleSheet);

    ScrollZoomer::setCornerWidget(cornerWidget);

}

void Zoomer::zoom(int up)

{

    ScrollZoomer::zoom(up);

    if(zoomRectIndex() == 0)

    {

        emit unzoomed();

    }

}

void Zoomer::zoom( const QRectF & rect)

{

    // set the zoom base when user zooms in to first level

    if (zoomRectIndex() == 0)

    {

        this->setZoomBase(false);

    }

    ScrollZoomer::zoom(rect);

}

QwtText Zoomer::trackerTextF(const QPointF& pos) const

{

    QwtText b = ScrollZoomer::trackerTextF(pos);

    const QPolygon pa = selection();

    if (!isActive() || pa.count() < 2)

    {

        return b;

    }

    const QRectF rect = invTransform(QRect(pa.first(), pa.last()).normalized());

    QString sizeText = QString(" [%1, %2]").\

        arg(rect.width(), 0, 'g', 4).\

        arg(rect.height(), 0, 'g', 4);

    b.setText(b.text() + sizeText);

    return b;

}

void Zoomer::drawRubberBand(QPainter* painter) const

{

    const double FILL_ALPHA = 0.2;

    QColor color = painter->pen().color();

    color.setAlphaF(FILL_ALPHA);

    painter->setBrush(color);

    ScrollZoomer::drawRubberBand(painter);

}

QRegion Zoomer::rubberBandMask() const

{

    const QPolygon pa = selection();

    if (pa.count() < 2)

    {

        return QRegion();

    }

    const QRect r = QRect(pa.first(), pa.last()).normalized().adjusted(0, 0, 1, 1);

    return QRegion(r);

}

void Zoomer::drawTracker(QPainter* painter) const

{

    if (isActive())

    {

        QwtPlotZoomer::drawTracker(painter);

    }

    {

        drawValues(painter);

    }

}

void Zoomer::drawValues(QPainter* painter) const

{

    painter->save();

    double x = invTransform(trackerPosition()).x();

    auto values = findValues(x);

    // draw vertical line

    auto linePen = QPen(Qt::DotLine);

    linePen.setColor(Qt::white);

    painter->setPen(linePen);

    const QRect pRect = pickArea().boundingRect().toRect();

    int px = trackerPosition().x();

    painter->drawLine(px, pRect.top(), px, pRect.bottom());

    // draw sample values

    for (int ci = 0; ci < values.size(); ci++)

    {

        double val = values[ci];

        if (!std::isnan(val))

        {

            auto p = transform(QPointF(x, val));

            painter->setPen(Qt::NoPen);

            painter->drawEllipse(p, VALUE_POINT_DIAM, VALUE_POINT_DIAM);

            painter->setPen(Qt::white);

            // We give a very small (1x1) rectangle but disable clipping

            painter->drawText(QRectF(p.x() + VALUE_TEXT_MARGIN, p.y(), 1, 1),

                              Qt::AlignVCenter | Qt::TextDontClip,

                              QString("%1").arg(val));

        }

    }

    painter->restore();

}

QVector<double> Zoomer::findValues(double x) const

{

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

    {

    }

}

QRect Zoomer::trackerRect(const QFont& font) const

{

    if (isActive())

    {

        return QwtPlotZoomer::trackerRect(font);

    }

    else

    {

        return valueTrackerRect(font);

    }

}

QRect Zoomer::valueTrackerRect(const QFont& font) const

{

    // TODO: consider using actual tracker values for width calculation

    const int textWidth = qCeil(QwtText("-8.8888888").textSize(font).width());

    const int width = textWidth + VALUE_POINT_DIAM + VALUE_TEXT_MARGIN;

    const int x = trackerPosition().x() - VALUE_POINT_DIAM;

    const auto pickRect = pickArea().boundingRect();

    return QRect(x, pickRect.y(), width, pickRect.height());

}

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

*/

#ifndef ZOOMER_H

#define ZOOMER_H

#include <QVector>

#include <QRect>

#include "scrollzoomer.h"

class Zoomer : public ScrollZoomer

{

    Q_OBJECT

public:

    void zoom(int up);

    void zoom(const QRectF&);

signals:

    void unzoomed();

protected:

    /// Re-implemented to display selection size in the tracker text.

    QwtText trackerTextF(const QPointF &pos) const override;

    /// Re-implemented for sample value tracker

    QRect trackerRect(const QFont&) const override;

    /// Re-implemented for alpha background

    void drawRubberBand(QPainter* painter) const override;

    /// Re-implemented to draw sample values

    void drawTracker(QPainter* painter) const override;

    /// Re-implemented for alpha background (masking is basically disabled)

    QRegion rubberBandMask() const;

    /// Overloaded for panning

    void widgetMousePressEvent(QMouseEvent* mouseEvent);

    /// Overloaded for panning

    void widgetMouseReleaseEvent(QMouseEvent* mouseEvent);

    /// Overloaded for panning

    void widgetMouseMoveEvent(QMouseEvent* mouseEvent);

private:

    bool is_panning;

    QPointF pan_point;

    /// Draw sample values

    void drawValues(QPainter* painter) const;

    /// Find sample values for given X value

    QVector<double> findValues(double x) const;

    /// Returns trackerRect for value tracker

    QRect valueTrackerRect(const QFont& font) const;

};

#endif // ZOOMER_H