HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r19:b231f8e5fa43

Started to refactor the API to allow integrating different plot types

Tero Ahola -

r19:b231f8e5fa43

parent child

Context file:

r19:b231f8e5fa43

Collapse all files

src/qchartwidget.cpp created 644 +53 0

@@ -0,0 +1,53
	1	#include "qchartwidget.h"
	2	#include "qxyseries.h"
	3	#include "xylinechart_p.h"
	4	#include <QGraphicsView>
	5	#include <QGraphicsScene>
	6
	7	QCHART_BEGIN_NAMESPACE
	8
	9	class QChartWidgetPrivate
	10	{
	11	public:
	12	QChartWidgetPrivate(QWidget *parent) : m_view(0), m_scene(0), m_chart(0) {
	13	m_scene = new QGraphicsScene();
	14	m_view = new QGraphicsView(m_scene, parent);
	15	m_view->resize(490, 300);
	16	m_view->show();
	17	}
	18	~QChartWidgetPrivate() {
	19	delete m_view;
	20	delete m_scene;
	21	}
	22
	23	QGraphicsView *m_view;
	24	QGraphicsScene *m_scene;
	25	QChart* m_chart;
	26	};
	27
	28	QChartWidget::QChartWidget(QWidget *parent) :
	29	QWidget(parent),
	30	d(new QChartWidgetPrivate(this))
	31	{
	32	setMinimumSize(d->m_view->size());
	33	}
	34
	35	QChartWidget::~QChartWidget()
	36	{
	37	delete d;
	38	}
	39
	40	void QChartWidget::addDataSeries(
	41	QChart::DataSeriesType dataSeriesType,
	42	QList<QXYSeries*> dataset)
	43	{
	44	// TODO: implement management of several data series of different types
	45
	46	d->m_chart = QChart::createXYLineChart(dataset);
	47	d->m_scene->addItem(d->m_chart);
	48	d->m_chart->setSize(this->size());
	49	}
	50
	51	#include "moc_qchartwidget.cpp"
	52
	53	QCHART_END_NAMESPACE

src/qchartwidget.h created 644 +36 0

@@ -0,0 +1,36
	1	#ifndef QCHARTWIDGET_H
	2	#define QCHARTWIDGET_H
	3
	4	#include "qchartconfig.h"
	5	#include "qchart.h"
	6	#include <QWidget>
	7
	8	QCHART_BEGIN_NAMESPACE
	9
	10	class QXYSeries;
	11	class QChartWidgetPrivate;
	12
	13	class QCHART_EXPORT QChartWidget : public QWidget
	14	{
	15	Q_OBJECT
	16	public:
	17	explicit QChartWidget(QWidget *parent = 0);
	18	~QChartWidget();
	19	// TODO: replace QXYSeries list with a charts data API
	20	// TODO: return QChartDataSeries
	21	void addDataSeries(QChart::DataSeriesType dataSeriesType, QList<QXYSeries*> dataset);
	22
	23	signals:
	24
	25	public slots:
	26
	27	private:
	28	friend class QChartWidgetPrivate;
	29	Q_DISABLE_COPY(QChartWidget)
	30	// Q_DECLARE_PRIVATE(QChartWidget)
	31	QChartWidgetPrivate * const d;
	32	};
	33
	34	QCHART_END_NAMESPACE
	35
	36	#endif // QCHARTWIDGET_H

test/chartwidgettest/dataseriedialog.cpp created 644 +24 0

@@ -0,0 +1,24
	1	#include "dataseriedialog.h"
	2	#include <QDialogButtonBox>
	3	#include <QAbstractButton>
	4	#include <QDebug>
	5
	6	DataSerieDialog::DataSerieDialog(QWidget *parent) :
	7	QDialog(parent)
	8	{
	9	QDialogButtonBox *addSeriesBox = new QDialogButtonBox(Qt::Vertical, this);
	10	addSeriesBox->addButton("Line", QDialogButtonBox::AcceptRole);
	11	addSeriesBox->addButton("Area", QDialogButtonBox::AcceptRole);
	12	addSeriesBox->addButton("Bar", QDialogButtonBox::AcceptRole);
	13	addSeriesBox->addButton("Pie", QDialogButtonBox::AcceptRole);
	14	addSeriesBox->addButton("Scatter", QDialogButtonBox::AcceptRole);
	15	addSeriesBox->addButton("Spline", QDialogButtonBox::AcceptRole);
	16	connect(addSeriesBox, SIGNAL(clicked(QAbstractButton )), this, SLOT(addSeries(QAbstractButton )));
	17	this->setFixedSize(addSeriesBox->sizeHint());
	18	}
	19
	20	void DataSerieDialog::addSeries(QAbstractButton *button)
	21	{
	22	addSeries(button->text().toAscii());
	23	accept();
	24	}

test/chartwidgettest/dataseriedialog.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef DATASERIEDIALOG_H
	2	#define DATASERIEDIALOG_H
	3
	4	#include <QDialog>
	5
	6	class QAbstractButton;
	7
	8	class DataSerieDialog : public QDialog
	9	{
	10	Q_OBJECT
	11	public:
	12	explicit DataSerieDialog(QWidget *parent = 0);
	13
	14	signals:
	15	void addSeries(QString series);
	16
	17	public slots:
	18	void addSeries(QAbstractButton *button);
	19	};
	20
	21	#endif // DATASERIEDIALOG_H

src/axis.cpp ~~src/xylinechart/axis.cpp~~ renamed 0 0

NO CONTENT: file renamed from src/xylinechart/axis.cpp to src/axis.cpp

src/axis_p.h ~~src/xylinechart/axis_p.h~~ renamed 0 0

NO CONTENT: file renamed from src/xylinechart/axis_p.h to src/axis_p.h

src/qchart.cpp ~~src/xylinechart/qchart.cpp~~ renamed 0 -1

             #include "qchart.h"
             #include "xylinechart_p.h"
             QCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem* parent):QGraphicsItem(parent),
             m_marginSize(0)
             {
               //  setFlags(QGraphicsItem::ItemClipsChildrenToShape);
             }
             QChart::~QChart(){}
             QChart* QChart::createXYLineChart(const QList<QXYSeries*>& dataset)
             {
                 XYLineChart* chart = new XYLineChart();
                 foreach (const QXYSeries* series,dataset) {
                     chart->addXYSeries(series);
                 }
                 return chart;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             QCHART_END_NAMESPACE

src/qchart.h ~~src/xylinechart/qchart.h~~ renamed +9 0

             #ifndef CHART_H
             #define CHART_H
             #include <qchartconfig.h>
             #include <qxyseries.h>
             #include <QGraphicsItem>
             QCHART_BEGIN_NAMESPACE
             class QCHART_EXPORT QChart : public QGraphicsItem
             {
+            public:
+                enum DataSeriesType {
+                    DataSeriesTypeLine = 0,
+                    DataSeriesTypeArea,
+                    DataSeriesTypeBar,
+                    DataSeriesTypePie,
+                    DataSeriesTypeScatter,
+                    DataSeriesTypeSpline
+                };
             protected:
                 QChart(QGraphicsItem* parent =0);
             public:
                 virtual ~QChart();
                 static QChart* createXYLineChart(const QList<QXYSeries*>& dataset);
                 virtual void setSize(const QSizeF& rect)=0;
                 void setMargin(int margin);
                 int margin() const { return m_marginSize;}
             private:
                 int m_marginSize;
             };
             QCHART_END_NAMESPACE
             #endif

src/src.pro +11 -10

             TARGET = QChart
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QChartd
             SOURCES += \
-                xylinechart/qchartwidget.cpp \
+                xylinechart/qchartgraphicswidget.cpp \
-                xylinechart/qchart.cpp \
                 xylinechart/qxyseries.cpp \
-                xylinechart/axis.cpp \
                 xylinechart/xylinechart.cpp \
                 xylinechart/xygrid.cpp \
-                xylinechart/xyplotdata.cpp
+                xylinechart/xyplotdata.cpp \
+                qchart.cpp \
+                axis.cpp \
+                qchartwidget.cpp
             PRIVATE_HEADERS += \
                 xylinechart/xylinechart_p.h \
-                xylinechart/axis_p.h \
                 xylinechart/xygrid_p.h \
-                xylinechart/xyplotdata_p.h
+                xylinechart/xyplotdata_p.h \
+                axis_p.h
             PUBLIC_HEADERS += \
-                xylinechart/qchart.h \
                 xylinechart/qxyseries.h \
-                xylinechart/qchartwidget.h \
+                xylinechart/qchartgraphicswidget.h \
+                qchart.h \
+                qchartwidget.h \
                 qchartconfig.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             INCLUDEPATH += xylinechart \
                            .
             OBJECTS_DIR = ../build/lib
             MOC_DIR = ../build/lib
             UI_DIR = ../build/lib
             RCC_DIR = ../build/lib
             DEFINES += QCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QCharts
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers

src/xylinechart/qchartgraphicswidget.cpp ~~src/xylinechart/qchartwidget.cpp~~ renamed +8 -8

-            #include "qchartwidget.h"
+            #include "qchartgraphicswidget.h"
             #include "qchart.h"
             QCHART_BEGIN_NAMESPACE
-            class QChartWidgetPrivate
+            class QChartGraphicsWidgetPrivate
             {
             public:
                 QChart* chart;
                 //Q_DECLARE_PUBLIC(ChartWidget)
-                QChartWidgetPrivate() {}
+                QChartGraphicsWidgetPrivate() {}
             };
             ////////////////////////////////////////////////////////////////////////////
-            QChartWidget::QChartWidget(QGraphicsItem *parent,Qt::WindowFlags wFlags)
+            QChartGraphicsWidget::QChartGraphicsWidget(QGraphicsItem *parent,Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent,wFlags),
-                  d_ptr(new QChartWidgetPrivate())
+                  d_ptr(new QChartGraphicsWidgetPrivate())
             {
             }
-            QChartWidget::~QChartWidget()
+            QChartGraphicsWidget::~QChartGraphicsWidget()
             {
                 delete d_ptr;
             }
-            void QChartWidget::addChart(QChart *chart)
+            void QChartGraphicsWidget::addChart(QChart *chart)
             {
                 d_ptr->chart=chart;
                 chart->setParentItem(this);
             }
-            void QChartWidget::setGeometry(const QRectF & rect)
+            void QChartGraphicsWidget::setGeometry(const QRectF & rect)
             {
                 d_ptr->chart->setSize(rect.size());
                 QGraphicsWidget::setGeometry(rect);
             }
             QCHART_END_NAMESPACE

src/xylinechart/qchartgraphicswidget.h ~~src/xylinechart/qchartwidget.h~~ renamed +9 -9

-            #ifndef QCHARTWIDGET_H
+            #ifndef QCHARTGRAPHICSWIDGET_H
-            #define QCHARTWIDGET_H
+            #define QCHARTGRAPHICSWIDGET_H
             #include <qchartconfig.h>
             #include <QGraphicsWidget>
             class QGraphicsItem;
             QCHART_BEGIN_NAMESPACE
             class QChart;
-            class QChartWidgetPrivate;
+            class QChartGraphicsWidgetPrivate;
-            class QCHART_EXPORT QChartWidget : public QGraphicsWidget
+            class QCHART_EXPORT QChartGraphicsWidget : public QGraphicsWidget
             {
             public:
-                explicit QChartWidget(QGraphicsItem *parent = 0,Qt::WindowFlags wFlags = 0);
+                explicit QChartGraphicsWidget(QGraphicsItem *parent = 0,Qt::WindowFlags wFlags = 0);
-                ~QChartWidget();
+                ~QChartGraphicsWidget();
                 QChart* chart() const;
                 void addChart(QChart* chart);
                 virtual void setGeometry(const QRectF & rect);
             private:
-                Q_DISABLE_COPY(QChartWidget)
+                Q_DISABLE_COPY(QChartGraphicsWidget)
-                Q_DECLARE_PRIVATE(QChartWidget)
+                Q_DECLARE_PRIVATE(QChartGraphicsWidget)
-                QChartWidgetPrivate * const d_ptr;
+                QChartGraphicsWidgetPrivate * const d_ptr;
             };
             QCHART_END_NAMESPACE
             #endif

src/xylinechart/qxyseries.cpp +4 0

             #include "qxyseries.h"
+            QCHART_BEGIN_NAMESPACE
             QXYSeries::QXYSeries():
                 m_color(Qt::black)
             {
             }
             QXYSeries::~QXYSeries()
             {
             }
             void QXYSeries::setColor(const QColor& color)
             {
             	m_color = color;
             }
             void QXYSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
             }
             void QXYSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             qreal QXYSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             qreal QXYSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             int QXYSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             QDebug operator<< (QDebug debug, const QXYSeries series)
             {
             	Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
+            QCHART_END_NAMESPACE

src/xylinechart/qxyseries.h +6 -1

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
+            #include "qchartconfig.h"
             #include <QDebug>
             #include <QColor>
+            QCHART_BEGIN_NAMESPACE
-            class QXYSeries
+            class QCHART_EXPORT QXYSeries
             {
             public:
                 QXYSeries();
                 virtual ~QXYSeries();
                 void add(qreal x, qreal y);
                 void clear();
                 void setColor(const QColor& color);
                 const QColor& color() const { return m_color;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QXYSeries series);
             private:
                 QColor m_color;
                 QList<qreal> m_x;
                 QList<qreal> m_y;
             };
+            QCHART_END_NAMESPACE
             #endif

test/chartwidgettest/chartwidgettest.pro +8 -7

             TARGET = chartwidgettest
             TEMPLATE = app
             QT += core gui
             contains(QT_MAJOR_VERSION, 5) {
                 QT += widgets
             }
             CONFIG += charts
-            CHARTS += widget
             OBJECTS_DIR = tmp
             MOC_DIR = tmp
             SOURCES += main.cpp \
                 mainwidget.cpp \
-                qscatterseries.cpp \
+            #    qscatterseries.cpp \
-                qchartwidget.cpp \
+            #    qseriespointgraphicsitem.cpp \
-                qseriespointgraphicsitem.cpp
+                dataseriedialog.cpp
             HEADERS += \
                 mainwidget.h \
-                qscatterseries.h \
+            #    qscatterseries.h \
-                qchartwidget.h \
+            #    qseriespointgraphicsitem.h \
-                qseriespointgraphicsitem.h
+                dataseriedialog.h

test/chartwidgettest/mainwidget.cpp +76 -46

             #include "mainwidget.h"
-            #include "qchartwidget.h"
+            #include "dataseriedialog.h"
-            //#include <chartwidget.h>
+            #include <qxyseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
+            QCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 m_chartWidget = new QChartWidget(this);
             //    m_chartWidget->resize(QSize(200,200));
             //    m_chartWidget->setColor(Qt::red);
                 // Chart type
                 // TODO: How about multiple types?
                 // Should the type be a property of a graph instead of the chart?
-                QComboBox *chartTypeCombo = new QComboBox(this);
+            //    QComboBox *chartTypeCombo = new QComboBox(this);
-                chartTypeCombo->addItem("Line");
+            //    chartTypeCombo->addItem("Line");
-                chartTypeCombo->addItem("Area");
+            //    chartTypeCombo->addItem("Area");
-                chartTypeCombo->addItem("Bar");
+            //    chartTypeCombo->addItem("Bar");
-                chartTypeCombo->addItem("Pie");
+            //    chartTypeCombo->addItem("Pie");
-                chartTypeCombo->addItem("Scatter");
+            //    chartTypeCombo->addItem("Scatter");
-                chartTypeCombo->addItem("Spline");
+            //    chartTypeCombo->addItem("Spline");
-                connect(chartTypeCombo, SIGNAL(currentIndexChanged(int)),
+            //    connect(chartTypeCombo, SIGNAL(currentIndexChanged(int)),
-                        this, SLOT(chartTypeChanged(int)));
+            //            this, SLOT(chartTypeChanged(int)));
+                QPushButton *addSeriesButton = new QPushButton("Add series");
+                connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 // Test data selector
                 QComboBox *testDataCombo = new QComboBox(this);
                 testDataCombo->addItem("linear");
                 testDataCombo->addItem("SIN");
                 testDataCombo->addItem("SIN + random component");
                 testDataCombo->addItem("TODO From file...");
                 testDataCombo->addItem("TODO From URL...");
                 connect(testDataCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(testDataChanged(int)));
                 // 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("Chart type:"), 0, 0);
+                //grid->addWidget(new QLabel("Add series:"), 0, 0);
-                grid->addWidget(chartTypeCombo, 0, 1);
+                grid->addWidget(addSeriesButton, 0, 1);
+            //    grid->addWidget(new QLabel("Chart type:"), 0, 0);
+            //    grid->addWidget(chartTypeCombo, 0, 1);
                 grid->addWidget(new QLabel("Data:"), 1, 0);
                 grid->addWidget(testDataCombo, 1, 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);
                 hbox->addWidget(m_chartWidget);
                 hbox->setStretch(1, 1);
                 setLayout(hbox);
                 m_autoScaleCheck->setChecked(true);
                 chartTypeChanged(4);
                 testDataChanged(0);
             }
+            void MainWidget::addSeries()
+            {
+                DataSerieDialog dialog(this);
+                connect(&dialog, SIGNAL(addSeries(QString)), this, SLOT(addSeries(QString)));
+                dialog.exec();
+            }
+            void MainWidget::addSeries(QString series)
+            {
+                if (series == "Scatter") {
+                    QXYSeries* series0 = new QXYSeries();
+                    series0->setColor(Qt::blue);
+                    for (int x = 0; x < 100; x++)
+                          series0->add(x, abs(sin(3.14159265358979 / 50 * x) * 100));
+                    QList<QXYSeries*> dataset;
+                    dataset << series0;
+                    m_chartWidget->addDataSeries(QChart::DataSeriesTypeScatter, dataset);
+                    //m_chartWidget->addDataSeries(dataset);
+                } else {
+                    // TODO
+                    qDebug() << "addSeries: " << series;
+                }
+            }
             void MainWidget::chartTypeChanged(int itemIndex)
             {
                 // TODO: change chart type
                 switch (itemIndex) {
                 case 4:
-                    m_chartWidget->setType(4);
+                    //m_chartWidget->setType(4);
                     break;
                 default: {
-                    m_chartWidget->setType(0);
+                    //m_chartWidget->setType(0);
                     break;
                 }
                 }
             }
             void MainWidget::testDataChanged(int itemIndex)
             {
                 qDebug() << "testDataChanged: " << itemIndex;
-                switch (itemIndex) {
+            //    switch (itemIndex) {
-                case 0: {
+            //    case 0: {
-                    QList<QChartDataPoint> data;
+            //        QList<QChartDataPoint> data;
-                    for (int x = 0; x < 20; x++) {
+            //        for (int x = 0; x < 20; x++) {
-                        data.append(QChartDataPoint() << x << x / 2);
+            //            data.append(QChartDataPoint() << x << x / 2);
+            //        }
-                    m_chartWidget->setData(data);
+            //        m_chartWidget->setData(data);
-                    break;
+            //        break;
+            //    }
-                case 1: {
+            //    case 1: {
-                    QList<QChartDataPoint> data;
+            //        QList<QChartDataPoint> data;
-                    for (int x = 0; x < 100; x++) {
+            //        for (int x = 0; x < 100; x++) {
-                        data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
+            //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
+            //        }
-                    m_chartWidget->setData(data);
+            //        m_chartWidget->setData(data);
-                    break;
+            //        break;
+            //    }
-                case 2: {
+            //    case 2: {
-                    QList<QChartDataPoint> data;
+            //        QList<QChartDataPoint> data;
-                    for (int x = 0; x < 1000; x++) {
+            //        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));
+            //            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);
+            //        m_chartWidget->setData(data);
-                    break;
+            //        break;
+            //    }
-                default:
+            //    default:
-                    break;
+            //        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;
             }

test/chartwidgettest/mainwidget.h +6 -1

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
+            #include <qchartconfig.h>
+            #include <qchartwidget.h>
             #include <QWidget>
-            class QChartWidget;
             class QSpinBox;
             class QCheckBox;
+            QCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private slots:
                 void chartTypeChanged(int itemIndex);
+                void addSeries();
+                void addSeries(QString series);
                 void testDataChanged(int itemIndex);
                 void backgroundChanged(int itemIndex);
                 void autoScaleChanged(int value);
                 void xMinChanged(int value);
                 void xMaxChanged(int value);
                 void yMinChanged(int value);
                 void yMaxChanged(int value);
             private:
                 QChartWidget *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
             };
             #endif // MAINWIDGET_H

test/chartwidgettest/qchartwidget.cpp removed 0 -44

NO CONTENT: file was removed

test/chartwidgettest/qchartwidget.h removed 0 -33

NO CONTENT: file was removed

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