#include <stdlib.h>
#include <cmath>
#include <qwt_painter.h>
#include <qwt_plot_canvas.h>
#include <qwt_plot_marker.h>
#include <qwt_plot_curve.h>
#include <qwt_scale_widget.h>
#include <qwt_legend.h>
#include <qwt_scale_draw.h>
#include <qwt_math.h>
#include "signal.h"
#include <qwt_plot_grid.h>
#include <qwt_plot_marker.h>
#include <qpainter.h>
#include <QSpinBox>
#include "stat.h"

// Инцилизируем график
DataPlot::DataPlot(QWidget *parent):

    QwtPlot(parent),
    d_interval(0),
    d_timerId(-1)
{
QwtPlotGrid *grid = new QwtPlotGrid;//создание сетки
grid->setMajPen(QPen(Qt::gray, 1));// устанавливается цвет пера которым рисуем сетку
grid->attach(this);
grid->setZ(-100);//глубина залегания сетки по сравнению со стробом и сигналом

    curve = new QwtPlotCurve();//создание строба
    curve->attach(this);
    //Начальное положение строба
     posX = 1.0;
     posY = 5.0;
     lenX = 5.0;

    alignScales();//
    f = 5;
    for (int i = 0; i< PLOT_SIZE; i++)
    {
        d_x[i] = 0.5 * i;     // time axis
        d_y[i] = 0;
        d_z[i] = 0;
    }
    setTitle("Graphic");//устанавливается название графика
    setCanvasColor(Qt::black);//устанавливается фон графика
    QwtPlotCurve *cRight = new QwtPlotCurve();//cоздаётся сигнал
    cRight->attach(this);

    cRight->setPen(QPen(Qt::red));//устанавливается цвет пера которым рисуется сигнал

    cRight->setRawData(d_x, d_y, PLOT_SIZE);

    setAxisTitle(QwtPlot::xBottom, "Time/seconds");//название  шкалы
    setAxisScaleDraw(QwtPlot::xBottom,
        new TimeScaleDraw(cpuStat.upTime()));
    setAxisScale(QwtPlot::xBottom, 0, 100,10); // масштаб шкалы
   strob();
    setAxisTitle(QwtPlot::yLeft, "Amplituda");//название Y шкалы
    setAxisScale(QwtPlot::yLeft, 0, 10,1); //масштаб шкалы

    setTimerInterval(0.0);

}
//Создание шкалы
void DataPlot::alignScales()
{

    canvas()->setFrameStyle(QFrame::Box | QFrame::Plain );
    canvas()->setLineWidth(2);

    for ( int i = 0; i < QwtPlot::axisCnt; i++ )
    {
        QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(i);
        if ( scaleWidget )
            scaleWidget->setMargin(2);
        QwtScaleDraw *scaleDraw = (QwtScaleDraw *)axisScaleDraw(i);
        if ( scaleDraw )
            scaleDraw->enableComponent(QwtAbstractScaleDraw::Backbone,false);
    }
}
//Cоздание сигнала в динамике
void DataPlot::setTimerInterval(double ms)
{
    d_interval = qRound(ms);

    if ( d_timerId >= 0 )
    {
        killTimer(d_timerId);
        d_timerId = -1;
    }
    if (d_interval >= 0 )
        d_timerId = startTimer(d_interval);
}

void DataPlot::timerEvent(QTimerEvent *)
{
    static double phase = 0.0;

    if (phase > (M_PI - 0.0001))
        phase = 0.0;
    for ( int i = PLOT_SIZE - 1; i > 0; i-- )
        d_y[i] = d_y[i-1];
    d_y[0] = sin(phase) * (-1.0 + 8.0 * double(rand()) / double(RAND_MAX));

    for ( int j = 0; j < PLOT_SIZE - 1; j++ )
        d_z[j] = d_z[j+1];

    d_z[PLOT_SIZE - 1] = 0.8 - (8.0 * phase/M_PI) + 0.4 *
        double(rand()) / double(RAND_MAX);
    replot();
    phase += M_PI*0.02;
}
// В данной функции устанавливается фон графика ( функция использована выше )
void DataPlot::setCanvasColor(const QColor &c)
{
    setCanvasBackground(c);
    replot();
}
// В данной функции создаётся строб
void DataPlot::strob()
{

  curve->setPen(QPen(Qt::blue,3));
  curve->setZ(1000);
double x[2],y[2];
x[0]=posX;
y[0]=posY;
x[1]=posX+lenX;
y[1]=posY;
  curve->setData(x, y, sizeof(x) / sizeof(x[0]));
  replot();
}
// Изменяется координата X строба
void DataPlot::setLenX(double LenX)
{
    lenX=LenX;
    strob();
}
// Изменяется координата Y строба
void DataPlot::setPosY(double PosY)
{
  posY = PosY;
  strob();
}
//Изменяется длина строба
void DataPlot::setPosX(double PosX)
{
    posX=PosX;
    strob();
}
void CpuPlot::timerEvent(QTimerEvent *)
{
    for ( int i = dataCount; i > 0; i-- )
    {
        for ( int c = 0; c < NCpuData; c++ )
        {
            if ( i < HISTORY )
                data[c].data[i] = data[c].data[i-1];
        }
    }

    cpuStat.statistic(data[User].data[0], data[System].data[0]);

    data[Total].data[0] = data[User].data[0] +
        data[System].data[0];
    data[Idle].data[0] = 100.0 - data[Total].data[0];

    if ( dataCount < HISTORY )
        dataCount++;

    for ( int j = 0; j < HISTORY; j++ )
        timeData[j]++;

    setAxisScale(QwtPlot::xBottom,
        timeData[HISTORY - 1], timeData[0]);

    for ( int c = 0; c < NCpuData; c++ )
    {
        data[c].curve->setRawData(
            timeData, data[c].data, dataCount);
    }

    replot();
}

#ifndef STAT_H
#define STAT_H
class CpuStat
{
public:
    CpuStat();
    void statistic(double &user, double &system);
    QTime upTime() const;

    enum Value
    {
        User,
        Nice,
        System,
        Idle,

        NValues
    };

private:
    void lookUp(double[NValues]) const;
    double procValues[NValues];
};
CpuStat::CpuStat()
{
    lookUp(procValues);
}

//QTime CpuStat::upTime() const
//{
//    QTime t;
//    for ( int i = 0; i < NValues; i++ )
//        t = t.addSecs(int(procValues[i] / 100));
//
//    return t;
//}
//};

#endif // STAT_H

#ifndef _DATA_PLOT_H
#define _DATA_PLOT_H

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_scale_draw.h>
#include  "stat.h"
#include <QTime>
#include <QLocale>
#define HISTORY 60 // seconds
class QwtPlotMarker;
class QwtPlotCurve;
const int PLOT_SIZE = 201;      // 0 to 200

class DataPlot : public QwtPlot
{
    Q_OBJECT

public:
    DataPlot(QWidget* = NULL);
 double l;
 double f;
 double posX ;
 double posY ;
 double lenX ;
QwtPlotCurve *curve;
public slots:
    void setTimerInterval(double interval);
    void setCanvasColor(const QColor &);
void strob();
void  setPosX(double);
void  setPosY(double);
void  setLenX(double);
protected:
    virtual void timerEvent(QTimerEvent *e);
private:
    void alignScales();
    double d_x[PLOT_SIZE];
    double d_y[PLOT_SIZE];
    double d_z[PLOT_SIZE];
    int d_interval; // timer in ms
    int d_timerId;
};
class TimeScaleDraw: public QwtScaleDraw
{
public:
    TimeScaleDraw() {}

    virtual QwtText label(double v) const
    {
        QTime time((int)v, 0);
        QString format = QLocale::system().timeFormat(QLocale::ShortFormat);
        return time.toString(format);
    }
};

// то что сейчас добавил
class CpuPlot : public QwtPlot
{
    Q_OBJECT
public:
    enum CpuData
    {
        User,
        System,
        Total,
        Idle,

        NCpuData
    };

    CpuPlot(QWidget * = 0);
    const QwtPlotCurve *cpuCurve(int id) const
        { return data[id].curve; }

protected:
    void timerEvent(QTimerEvent *e);

private slots:
    void showCurve(QwtPlotItem *, bool on);

private:
    struct
    {
        QwtPlotCurve *curve;
        double data[HISTORY];
    } data[NCpuData];
    double timeData[HISTORY];

    int dataCount;
    CpuStat cpuStat;
};

#endif