/*

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

            });

/*

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

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

#include <QMetaEnum>

#include <QtDebug>

#include "qwt_symbol.h"

#include "plot.h"

#include "plotmanager.h"

#include "utils.h"

#include "setting_defines.h"

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

                         const Stream* stream, QObject* parent) :

    QObject(parent)

{

    construct(plotArea, menu);

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

    }

}

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

                         Snapshot* snapshot, QObject *parent) :

    QObject(parent)

{

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

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

#ifndef PLOTMANAGER_H

#define PLOTMANAGER_H

#include <QObject>

#include <QWidget>

#include <QScrollArea>

#include <QVBoxLayout>

#include <QList>

#include <QSettings>

#include <QMenu>

#include <qwt_plot_curve.h>

#include "plot.h"

#include "framebufferseries.h"

#include "stream.h"

#include "snapshot.h"

#include "plotmenu.h"

class PlotManager : public QObject

{

    Q_OBJECT

public:

    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

                         QObject *parent = 0);

    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

                         Snapshot* snapshot,

                         QObject *parent = 0);

    ~PlotManager();

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

    /// automatically chosen for curve.

    void addCurve(QString title, const FrameBuffer* buffer);

    /// Removes curves from the end

    void removeCurves(unsigned number);

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

    unsigned numOfCurves();

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

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

    PlotMenu* _menu;

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

    QScrollArea* scrollArea;

    QList<QwtPlotCurve*> curves;

    QList<Plot*> plotWidgets;

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

    const ChannelInfoModel* infoModel;

    bool isDemoShown;

    bool _autoScaled;

    double _yMin;

    double _yMax;

    bool _xAxisAsIndex;

    double _xMin;

    double _xMax;

    unsigned _numOfSamples;

    double _plotWidth;

    Plot::ShowSymbols showSymbols;

    /// Common constructor

    void construct(QWidget* plotArea, PlotMenu* menu);

    /// Setups the layout for multi or single plot

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

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

    void checkNoVisChannels();

#include "channelinfomodel.h"

#include "streamchannel.h"

#include "framebuffer.h"

/**

 * Main waveform storage class. It consists of channels. Channels are

 * 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 = 0, bool x = false, unsigned ns = 0);

    ~Stream();

    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.

/*

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

StreamChannel::StreamChannel(unsigned i, const FrameBuffer* x,

              FrameBuffer* y, ChannelInfoModel* info)

{

    _index = i;

    _x = x;

    _y = y;

    _info = info;

}

StreamChannel::~StreamChannel()

{

    delete _y;

}

unsigned StreamChannel::index() const {return _index;}

QString StreamChannel::name() const {return _info->name(_index);};

QColor StreamChannel::color() const {return _info->color(_index);};

bool StreamChannel::visible() const {return _info->isVisible(_index);};

const FrameBuffer* StreamChannel::xData() const {return _x;}

const FrameBuffer* StreamChannel::yData() const {return _y;}

FrameBuffer* StreamChannel::yData() {return _y;}

const ChannelInfoModel* StreamChannel::info() const {return _info;}

void StreamChannel::setX(const FrameBuffer* x) {_x = x;};

    /**

     * Creates a stream channel.

     *

     * @param i index of the channel

     * @param x x axis buffer

     * @param y data buffer of this channel, takes ownership

     * @param info channel info model

     */

    StreamChannel(unsigned i,

                  const FrameBuffer* x,

                  FrameBuffer* y,

                  ChannelInfoModel* info);

    ~StreamChannel();

    unsigned index() const;

    QString name() const;

    QColor color() const;

    bool visible() const;

    const FrameBuffer* xData() const;

    FrameBuffer* yData();

    const FrameBuffer* yData() const;

    const ChannelInfoModel* info() const;

    void setX(const FrameBuffer* x);

private:

    unsigned _index;

    const FrameBuffer* _x;

    FrameBuffer* _y;

    ChannelInfoModel* _info;

};

#endif // STREAMCHANNEL_H

/*

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

#include <qwt_plot.h>

#include <QtDebug>

#include <QMouseEvent>

    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

}

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::widgetMousePressEvent(QMouseEvent* mouseEvent)

{

    if (mouseEvent->modifiers() & Qt::ControlModifier)

    {

        is_panning = true;

        parentWidget()->setCursor(Qt::ClosedHandCursor);

        pan_point = invTransform(mouseEvent->pos());

    }

    else

    {

        ScrollZoomer::widgetMousePressEvent(mouseEvent);

    }

}

void Zoomer::widgetMouseMoveEvent(QMouseEvent* mouseEvent)

{

    if (is_panning)

    {

        auto cur_point = invTransform(mouseEvent->pos());

        auto delta = cur_point - pan_point;

        moveBy(-delta.x(), -delta.y());

        pan_point = invTransform(mouseEvent->pos());

    }

    else

/*

  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

class Zoomer : public ScrollZoomer

{

    Q_OBJECT

public:

    void zoom(int up);

signals:

    void unzoomed();

protected:

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

    QwtText trackerTextF(const QPointF &pos) const;

    /// Re-implemented for alpha background

    void drawRubberBand(QPainter* painter) const;

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

};

#endif // ZOOMER_H