HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r48:3cbbcb012d8d

Resizing of QGraphicItems now possible by resize signal from QChart

Tero Ahola -

r48:3cbbcb012d8d

parent child

Context file:

r48:3cbbcb012d8d

Collapse all files

src/qchart.cpp +26 -21

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qxychartseries.h"
             #include "xylinechartitem_p.h"
             #include "xyplotdomain_p.h"
             #include "axis_p.h"
             #include "xygrid_p.h"
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartPrivate
             {
             public:
                 QChartPrivate(QChart* parent):
                 m_axisX(new Axis(parent)),
                 m_axisY(new Axis(parent)),
                 m_grid(new XYGrid(parent)),
                 m_plotDataIndex(0),
                 m_marginSize(0){}
                 Axis* m_axisX;
                 Axis* m_axisY;
                 XYGrid* m_grid;
                 QRect m_rect;
                 QList<const QChartSeries*> m_series;
                 QList<XYPlotDomain> m_plotDomainList;
                 QList<XYLineChartItem*> m_xyLineChartItems;
                 QList<QGraphicsItem*> m_items;
                 int m_plotDataIndex;
                 int m_marginSize;
             };
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChart::QChart(QGraphicsItem* parent):QGraphicsItem(parent),
+            QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
-            d_ptr(new QChartPrivate(this))
+            d(new QChartPrivate(this))
             {
                 //  setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 // set axis
-                Q_D(QChart);
                 d->m_axisY->rotate(90);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
-                Q_D(const QChart);
                 return d->m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
-                Q_D(QChart);
+                // TODO: we should check the series not already added
                 d->m_series<<series;
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                     XYPlotDomain domain;
                     //TODO "nice numbers algorithm"
                     domain.m_ticksX=4;
                     domain.m_ticksY=4;
                     for (int i = 0 ; i < xyseries->count() ; i++)
                     {
                         qreal x = xyseries->x(i);
                         qreal y = xyseries->y(i);
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     XYLineChartItem* item = new XYLineChartItem(xyseries,this);
                     item->updateXYPlotDomain(domain);
                     d->m_plotDomainList<<domain;
                     d->m_xyLineChartItems<<item;
                     break;
                 }
                 case QChartSeries::SeriesTypeScatter: {
+                    QScatterSeries *scatter = qobject_cast<QScatterSeries *>(series);
+                    if (scatter) {
+                        scatter->d->setParentItem(this);
+                        scene()->addItem(scatter->d);
+                    }
                     break;
                 }
                 }
             }
             QChartSeries* QChart::createSeries(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type)
             {
-                Q_D(QChart);
+                // TODO: support also other types in addition to scatter
-                // TODO: support also other types
                 Q_ASSERT(type == QChartSeries::SeriesTypeScatter);
                 QChartSeries *series = 0;
                 switch (type) {
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = new QScatterSeries(x, y, this);
-                    d->m_items.append(scatterSeries->d);
+                    scatterSeries->d->setParentItem(this);
-                    scene()->addItem(scatterSeries->d);
-                    //series = qobject_cast<QChartSeries *>(scatterSeries);
                     break;
                 }
                 default:
                     break;
                 }
                 return series;
             }
             void QChart::setSize(const QSizeF& size)
             {
-                Q_D(QChart);
                 d->m_rect = QRect(QPoint(0,0),size.toSize());
-                d->m_rect.adjust(margin(),margin(),-margin(),-margin());
+                d->m_rect.adjust(margin(),margin(), -margin(), -margin());
                 d->m_grid->setPos(d->m_rect.topLeft());
                 d->m_grid->setSize(d->m_rect.size());
-                // TODO: line chart items would need to be updated separately as they don't support update
-                // via paint method
-                for (int i =0; i< d->m_plotDomainList.size();i++)
-                    d->m_plotDomainList[i].m_viewportRect = d->m_rect;
+                // TODO: calculate the scale
+                // TODO: calculate the origo
+                // TODO: not sure if emitting a signal here is the best from performance point of view
+                const qreal xscale = size.width() / 100;
+                const qreal yscale = size.height() / 100;
+                emit sizeChanged(QRectF(0, 0, size.width(), size.height()), xscale, yscale);
+                for (int i(0); i < d->m_plotDomainList.size(); i++)
+                    d->m_plotDomainList[i].m_viewportRect = d->m_rect;
+                // TODO: line chart items are updated separately as they don't support update
+                // via sizeChanged signal
                 foreach(XYLineChartItem* item , d->m_xyLineChartItems)
                     item->updateXYPlotDomain(d->m_plotDomainList.at(d->m_plotDataIndex));
                 d->m_grid->setXYPlotData(d->m_plotDomainList.at(d->m_plotDataIndex));
                 update();
             }
             int QChart::margin() const
             {
-                Q_D(const QChart);
                 return d->m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
-                Q_D(QChart);
                 d->m_marginSize = margin;
             }
+            #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +11 -11

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
-            #include <QGraphicsItem>
+            #include <QGraphicsObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Axis;
             class XYGrid;
             class QChartSeries;
             class XYPlotDomain;
             class QChartPrivate;
             // TODO: We don't need to have QChart tied to QGraphicsItem:
             //class QTCOMMERCIALCHART_EXPORT QChart
             //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
             // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
-            class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsItem, public QObject
+            class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsObject
             {
+                Q_OBJECT
             public:
-                QChart(QGraphicsItem* parent = 0);
+                QChart(QGraphicsObject* parent = 0);
-                virtual ~QChart();
+                ~QChart();
                 //from QGraphicsItem
-                virtual QRectF boundingRect() const;
+                QRectF boundingRect() const;
-                virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
+                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
                 void addSeries(QChartSeries* series);
                 //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
                 // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
                 QChartSeries* createSeries(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type);
                 virtual void setSize(const QSizeF& rect);
                 void setMargin(int margin);
                 int margin() const;
-            protected:
+            signals:
-                QChartPrivate * const d_ptr;
+                void sizeChanged(QRectF rect, qreal xscale, qreal yscale);
             private:
+            //    Q_DECLARE_PRIVATE(QChart)
                 Q_DISABLE_COPY(QChart)
-                Q_DECLARE_PRIVATE(QChart)
+                QChartPrivate *d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qscatterseries.cpp +26 -16

             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //#define QSeriesData QList<qreal>
             QScatterSeriesPrivate::QScatterSeriesPrivate(QList<qreal> x, QList<qreal> y, QGraphicsItem *parent) :
                 QGraphicsItem(parent),
                 m_x(x),
                 m_y(y)
             {
             }
-            void QScatterSeriesPrivate::setSize()
+            void QScatterSeriesPrivate::resize(QRectF rect, qreal xscale, qreal yscale)
             {
+                m_scenex.clear();
+                m_sceney.clear();
+                foreach(qreal x, m_x)
+                    m_scenex.append(rect.left() + x * xscale);
+                foreach(qreal y, m_y)
+                    m_sceney.append(rect.bottom() - y * yscale);
             }
             QRectF QScatterSeriesPrivate::boundingRect() const
             {
-                return QRectF(0, 0, 100, 100);
+                return QRectF(0, 0, 55, 100);
             }
             void QScatterSeriesPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 QPen pen = painter->pen();
                 QBrush brush = pen.brush();
                 // TODO: The opacity should be user definable...
                 brush.setColor(QColor(255, 82, 0, 50));
                 pen.setBrush(brush);
                 pen.setWidth(4);
                 painter->setPen(pen);
-                QTransform transform = painter->transform();
-                // TODO: get min and max values of the axes from the QChart (or some dedicated class)
-                const qreal xmin = 0.0;
-                const qreal xmax = 100.0;
-                const qreal xscale = scene()->width() / (xmax - xmin);
-                const qreal ymin = 0.0;
-                const qreal ymax = 100.0;
-                const qreal yscale = scene()->height() / (ymax - ymin);
-                for (int i(0); i < m_x.count() && i < m_y.count(); i++) {
+                // TODO: m_scenex and m_sceny are left empty during construction -> we would need a resize
-                    transform.reset();
+                // event right after construction or maybe given a size during initialization
-                    transform.translate(m_x.at(i) * xscale, m_y.at(i) * yscale);
+                for (int i(0); i < m_scenex.count() && i < m_sceney.count(); i++) {
-                    painter->setTransform(transform);
+                    if (scene()->width() > m_scenex.at(i) && scene()->height() > m_sceney.at(i))
-                    painter->drawArc(0, 0, 4, 4, 0, 5760);
+                        //painter->drawArc(m_scenex.at(i), m_sceney.at(i), 2, 2, 0, 5760);
+                        painter->drawPoint(m_scenex.at(i), m_sceney.at(i));
                 }
             }
             QScatterSeries::QScatterSeries(QList<qreal> x, QList<qreal> y, QObject *parent) :
                 QChartSeries(parent),
                 d(new QScatterSeriesPrivate(x, y, qobject_cast<QGraphicsItem *> (parent)))
             {
+                connect(parent, SIGNAL(sizeChanged(QRectF, qreal, qreal)), this, SLOT(chartSizeChanged(QRectF, qreal, qreal)));
+            }
+            void QScatterSeries::chartSizeChanged(QRectF rect, qreal xscale, qreal yscale)
+            {
+                // Recalculate scatter data point locations on the scene
+            //    d->transform().reset();
+            //    d->transform().translate();
+                d->resize(rect, xscale, yscale);
             }
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qscatterseries.h +4 0

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qchartseries.h"
+            #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 //QScatterSeries(QSeriesData *data, QObject *chart);
                 QScatterSeries(QList<qreal> x, QList<qreal> y, QObject *chart = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeScatter; }
+            public Q_SLOTS:
+                void chartSizeChanged(QRectF rect, qreal xscale, qreal yscale);
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
                 friend class QChart;
                 QScatterSeriesPrivate *const d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/qscatterseries_p.h +3 -1

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
             class QScatterSeriesPrivate : public QGraphicsItem
             {
             public:
                 QScatterSeriesPrivate(QList<qreal> x, QList<qreal> y, QGraphicsItem *parent);
             public: // from QGraphicsItem
-                void setSize();
+                void resize(QRectF rect, qreal xscale, qreal yscale);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 // TODO: use the chart data class instead of list of x and y values?
                 QList<qreal> m_x;
                 QList<qreal> m_y;
+                QList<qreal> m_scenex;
+                QList<qreal> m_sceney;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/src.pro 0 -1

             !include( ../common.pri ) {
             error( Couldn't find the common.pri file! )
             }
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 xylinechart/qxychartseries.cpp \
                 xylinechart/xylinechartitem.cpp \
                 xylinechart/xygrid.cpp \
                 xylinechart/xyplotdomain.cpp \
                 qscatterseries.cpp \
                 qchart.cpp \
                 axis.cpp \
                 qchartwidget.cpp
             PRIVATE_HEADERS += \
                 xylinechart/xylinechartitem_p.h \
                 xylinechart/xyplotdomain_p.h \
                 xylinechart/xygrid_p.h \
                 qscatterseries_p.h \
                 axis_p.h
             PUBLIC_HEADERS += \
                 qchartseries.h \
                 qscatterseries.h \
                 qchart.h \
                 qchartwidget.h \
                 qchartglobal.h \
                 xylinechart/qxychartseries.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             INCLUDEPATH += xylinechart \
                            .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_headers.name = bild_headers
             install_build_headers.output = $$CHART_BUILD_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_headers.input = PUBLIC_HEADERS
             install_build_headers.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} $$CHART_BUILD_HEADER_DIR
             install_build_headers.CONFIG += target_predeps no_link
             QMAKE_EXTRA_COMPILERS += install_build_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo "build_time" > $$chartversion.target;
             chartversion.depends = $$HEADERS $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN+= qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r $$CHART_BUILD_HEADER_DIR $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q $$CHART_BUILD_HEADER_DIR $$CHART_BUILD_LIB_DIR

src/xylinechart/xylinechartitem_p.h +1 -1

             #ifndef XYLINECHARTITEM_H
             #define XYLINECHARTITEM_H
             #include "qchartglobal.h"
-            #include "qchart.h"
+            #include <QGraphicsItem>
             #include "xyplotdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYChartSeries;
             class XYLineChartItem : public QGraphicsItem
             {
             public:
                 XYLineChartItem(QXYChartSeries* m_series,QGraphicsItem *parent = 0);
                 virtual ~ XYLineChartItem(){};
                 //from QGraphicsItem
                 virtual QRectF boundingRect() const;
                 virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void updateXYPlotDomain(const XYPlotDomain& data);
             private:
                 QPolygonF m_polyline;
                 QXYChartSeries* m_series;
                 XYPlotDomain m_xyPlotData;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/chartwidgettest/chartwidgettest.pro +23 -23

@@ -1,33 +1,33
1	!include( ../../common.pri ) {	1	!include( ../../common.pri ) {
2	error( Couldn't find the common.pri file! )	2	error( Couldn't find the common.pri file! )
3	}	3	}
4		4
5	!include( ../../integrated.pri ) {	5	!include( ../../integrated.pri ) {
6	error( Couldn't find the integrated.pri file! )	6	error( Couldn't find the integrated.pri file! )
7	}	7	}
8		8
9		9
10	TARGET = chartwidgettest	10	TARGET = chartwidgettest
11	TEMPLATE = app	11	TEMPLATE = app
12		12
13	QT += core gui	13	QT += core gui
14	contains(QT_MAJOR_VERSION, 5) {	14	contains(QT_MAJOR_VERSION, 5) {
15	QT += widgets	15	QT += widgets
16	}	16	}
17		17
18		18
19	OBJECTS_DIR = tmp	19	OBJECTS_DIR = tmp
20	MOC_DIR = tmp	20	MOC_DIR = tmp
21		21
22	SOURCES += main.cpp \	22	SOURCES += main.cpp \
23	mainwidget.cpp \	23	mainwidget.cpp \
24	# qscatterseries.cpp \	24	# qscatterseries.cpp \
25	# qseriespointgraphicsitem.cpp \	25	# qseriespointgraphicsitem.cpp \
26	dataseriedialog.cpp	26	dataseriedialog.cpp
27		27
28	HEADERS += \	28	HEADERS += \
29	mainwidget.h \	29	mainwidget.h \
30	# qscatterseries.h \	30	# qscatterseries.h \
31	# qseriespointgraphicsitem.h \	31	# qseriespointgraphicsitem.h \
32	dataseriedialog.h	32	dataseriedialog.h
33		33

test/chartwidgettest/mainwidget.cpp +14 -6

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include <qxychartseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 // Chart background
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("None");
                 backgroundCombo->addItem("TODO Grid");
                 backgroundCombo->addItem("TODO Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 // Axis
                 // TODO: multiple axes?
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 QGridLayout *grid = new QGridLayout();
                 QHBoxLayout *hbox = new QHBoxLayout();
                 //grid->addWidget(new QLabel("Add series:"), 0, 0);
                 grid->addWidget(addSeriesButton, 0, 1);
                 grid->addWidget(new QLabel("Background:"), 2, 0);
                 grid->addWidget(backgroundCombo, 2, 1);
                 grid->addWidget(m_autoScaleCheck, 3, 0);
                 grid->addWidget(new QLabel("x min:"), 4, 0);
                 grid->addWidget(m_xMinSpin, 4, 1);
                 grid->addWidget(new QLabel("x max:"), 5, 0);
                 grid->addWidget(m_xMaxSpin, 5, 1);
                 grid->addWidget(new QLabel("y min:"), 6, 0);
                 grid->addWidget(m_yMinSpin, 6, 1);
                 grid->addWidget(new QLabel("y max:"), 7, 0);
                 grid->addWidget(m_yMaxSpin, 7, 1);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), 8, 0);
                 grid->setRowStretch(8, 1);
                 hbox->addLayout(grid);
                 m_chartWidget = new QChartWidget(this);
                 //m_chartWidget->setColor(Qt::red);
                 hbox->addWidget(m_chartWidget);
             //    hbox->setStretch(1, 1);
                 setLayout(hbox);
                 m_autoScaleCheck->setChecked(true);
                 chartTypeChanged(4);
                 testDataChanged(0);
             }
             void MainWidget::addSeries()
             {
                 DataSerieDialog dialog(m_defaultSeries, this);
                 connect(&dialog, SIGNAL(accepted(QString, QString)), this, SLOT(addSeries(QString, QString)));
                 dialog.exec();
             }
             void MainWidget::addSeries(QString series, QString data)
             {
                 qDebug() << "addSeries: " << series << " data: " << data;
                 m_defaultSeries = series;
+                QXYChartSeries* series0 = QXYChartSeries::create();
                 // TODO: a dedicated data class for storing x and y values
                 QList<qreal> x;
                 QList<qreal> y;
                 if (data == "linear") {
-                    for (int i = 0; i < 10; i++) {
+                    for (int i = 0; i < 20; i++) {
                         x.append(i);
-                        y.append(10);
+                        y.append(i);
                     }
+                    for (int i = 0; i < 20; i++)
+                        series0->add(i, i);
                 } else if (data == "linear, 1M") {
                     for (int i = 0; i < 10000; i++) {
                         x.append(i);
                         y.append(20);
                     }
+                    for (int i = 0; i < 1000000; i++)
+                        series0->add(i, 10);
                 } else if (data == "SIN") {
                     for (int i = 0; i < 100; i++) {
                         x.append(i);
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                     }
+                    for (int i = 0; i < 100; i++)
+                        series0->add(i, abs(sin(3.14159265358979 / 50 * i) * 100));
                 } else if (data == "SIN + random") {
                     for (qreal i = 0; i < 100; i += 0.1) {
                         x.append(i + (rand() % 5));
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                     }
+                    for (qreal i = 0; i < 100; i += 0.1)
+                        series0->add(i + (rand() % 5), abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                 } else {
                     // TODO: check if data has a valid file name
                 }
                 // TODO: color of the series
                 if (series == "Scatter") {
-                    /*QChartSeries* scatterSeries = */m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypeScatter);
+                    /*QChartSeries* scatterSeries = */
+                    m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypeScatter);
                 } else if (series == "Line") {
-                    QXYChartSeries* series0 = QXYChartSeries::create();
-                    for (int i = 0; i < 1000000; i++)
-                        series0->add(i, 20);
                     m_chartWidget->addSeries(series0);
                 } else {
                     // TODO
                 }
             }
             void MainWidget::chartTypeChanged(int itemIndex)
             {
                 // TODO: change chart type
                 switch (itemIndex) {
                 case 4:
                     //m_chartWidget->setType(4);
                     break;
                 default: {
                     //m_chartWidget->setType(0);
                     break;
                 }
                 }
             }
             void MainWidget::testDataChanged(int itemIndex)
             {
                 qDebug() << "testDataChanged: " << itemIndex;
             //    switch (itemIndex) {
             //    case 0: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 20; x++) {
             //            data.append(QChartDataPoint() << x << x / 2);
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 1: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 100; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 2: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 1000; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    default:
             //        break;
             //    }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages