HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r65:51e529f06d1a

Fixed line series usage in the test app

Tero Ahola -

r65:51e529f06d1a

parent child

Context file:

r65:51e529f06d1a

Collapse all files

src/qchart.cpp +34 -24

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qxychartseries.h"
             #include "barchartseries.h"
             #include "bargroup.h"
             #include "xylinechartitem_p.h"
             #include "xyplotdomain_p.h"
             #include "axis_p.h"
             #include "xygrid_p.h"
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
                 m_axisX(new Axis(this)),
                 m_axisY(new Axis(this)),
                 m_grid(new XYGrid(this)),
                 m_plotDataIndex(0),
                 m_marginSize(0)
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeVanilla);
                 //  setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 // set axis
                 m_axisY->rotate(90);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 return m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_series<<series;
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
+                    // Use color defined by theme in case the series does not define a custom color
+                    if (!xyseries->color().isValid() && m_themeColors.count())
+                        xyseries->setColor(m_themeColors.takeFirst());
                     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);
                     m_plotDomainList<<domain;
                     m_xyLineChartItems<<item;
                     break;
                 }
-                    // TODO: Not tested:
-            //    case QChartSeries::SeriesTypeScatter: {
-            //        QScatterSeries *scatter = qobject_cast<QScatterSeries *>(series);
-            //        if (scatter) {
-            //            scatter->d->setParentItem(this);
-            //            scene()->addItem(scatter->d);
-            //        }
-            //        break;
-            //    }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     // Who owns the series?
                     BarGroup* group = new BarGroup(*barSeries, this);
                     scene()->addItem(group);
                     m_BarGroupItems.append(group); // If we need to access group later
                     break;
                     }
-            QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
-                // TODO: support also other types; not only scatter and pie
-                switch (type) {
                 case QChartSeries::SeriesTypeScatter: {
-                    QScatterSeries *scatterSeries = new QScatterSeries(this);
+                    QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             scatterSeries, SLOT(chartSizeChanged(QRectF)));
                     scatterSeries->d->setParentItem(this);
                     QColor nextColor = m_themeColors.takeFirst();
                     nextColor.setAlpha(150); // TODO: default opacity?
                     scatterSeries->setMarkerColor(nextColor);
-                    return scatterSeries;
                 case QChartSeries::SeriesTypePie: {
                     // TODO: we now have also a list of y values as a parameter, it is ignored
                     // we should use a generic data class instead of list of x and y values
-                    QPieSeries *pieSeries = new QPieSeries(this);
+                    QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             pieSeries, SLOT(chartSizeChanged(QRectF)));
                     // TODO: how to define the color for all the slices of a pie?
-                    return pieSeries;
+                }
+            }
+            QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
+            {
+                // TODO: support also other types; not only scatter and pie
+                QChartSeries *series(0);
+                switch (type) {
+                case QChartSeries::SeriesTypeLine: {
+                    series = QXYChartSeries::create();
+                    break;
+                }
+                case QChartSeries::SeriesTypeBar: {
+                    series = new BarChartSeries(this);
+                    break;
+                }
+                case QChartSeries::SeriesTypeScatter: {
+                    series = new QScatterSeries(this);
+                    break;
+                }
+                case QChartSeries::SeriesTypePie: {
+                    series = new QPieSeries(this);
+                    break;
                 }
                 default:
                     Q_ASSERT(false);
                     break;
                 }
-                return 0;
+                addSeries(series);
+                return series;
             }
             void QChart::setSize(const QSizeF& size)
             {
                 m_rect = QRect(QPoint(0,0),size.toSize());
                 m_rect.adjust(margin(),margin(), -margin(), -margin());
                 m_grid->setPos(m_rect.topLeft());
                 m_grid->setSize(m_rect.size());
                 // TODO: TTD for setting scale
                 //emit scaleChanged(100, 100);
                 // TODO: calculate the origo
                 // TODO: not sure if emitting a signal here is the best from performance point of view
                 emit sizeChanged(QRectF(0, 0, size.width(), size.height()));
                 for (int i(0); i < m_plotDomainList.size(); i++)
                     m_plotDomainList[i].m_viewportRect = m_rect;
                 // TODO: line chart items are updated separately as they don't support update
                 // via sizeChanged signal
                 foreach(XYLineChartItem* item ,m_xyLineChartItems)
                     item->updateXYPlotDomain(m_plotDomainList.at(m_plotDataIndex));
                 if (m_plotDomainList.count())
                     m_grid->setXYPlotData(m_plotDomainList.at(m_plotDataIndex));
                 update();
             }
             int QChart::margin() const
             {
                 return m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 // TODO: define color themes
                 switch (theme) {
                 case ChartThemeVanilla:
                     m_themeColors.append(QColor(255, 238, 174));
                     m_themeColors.append(QColor(228, 228, 160));
                     m_themeColors.append(QColor(228, 179, 160));
                     m_themeColors.append(QColor(180, 151, 18));
                     m_themeColors.append(QColor(252, 252, 37));
                     break;
                 case ChartThemeIcy:
                     m_themeColors.append(QColor(255, 238, 174));
                     m_themeColors.append(QColor(228, 228, 160));
                     m_themeColors.append(QColor(228, 179, 160));
                     m_themeColors.append(QColor(180, 151, 18));
                     m_themeColors.append(QColor(252, 252, 37));
                     break;
                 case ChartThemeGrayscale:
                     m_themeColors.append(QColor(255, 238, 174));
                     m_themeColors.append(QColor(228, 228, 160));
                     m_themeColors.append(QColor(228, 179, 160));
                     m_themeColors.append(QColor(180, 151, 18));
                     m_themeColors.append(QColor(252, 252, 37));
                     break;
                 default:
                     Q_ASSERT(false);
                     break;
                 }
                 // TODO: update coloring of different elements to match the selected theme
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/qxychartseries.cpp +1 -1

             #include "qxychartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QXYChartSeries::QXYChartSeries(QObject* parent):QChartSeries(parent),
-                m_color(Qt::black)
+                m_color()
             {
             }
             QXYChartSeries::~QXYChartSeries()
             {
             }
             QXYChartSeries* QXYChartSeries::create(QObject* parent)
             {
                 //TODO: here we take QChartData when it is ready
                 // return null if malformed;
                 return new QXYChartSeries(parent);
             }
             void QXYChartSeries::setColor(const QColor& color)
             {
             	m_color = color;
             }
             void QXYChartSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
             }
             void QXYChartSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             qreal QXYChartSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             qreal QXYChartSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             int QXYChartSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             QDebug operator<< (QDebug debug, const QXYChartSeries 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();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

test/chartwidgettest/mainwidget.cpp +13 -2

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include <qxychartseries.h>
             #include <barchartseries.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)));
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Vanilla");
                 chartTheme->addItem("Icy");
                 chartTheme->addItem("Grayscale");
                 chartTheme->addItem("Tobedefined");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 QGridLayout *grid = new QGridLayout();
                 QGridLayout *mainLayout = new QGridLayout();
                 //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);
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), 9, 0);
                 grid->setRowStretch(9, 1);
                 mainLayout->addLayout(grid, 0, 0);
                 // Scatter specific settings
                 m_scatterLayout = new QGridLayout();
                 m_scatterLayout->addWidget(new QLabel("scatter"), 0, 0);
                 m_scatterLayout->setEnabled(false);
                 // Pie specific settings
                 m_pieLayout = new QGridLayout();
                 m_pieLayout->addWidget(new QLabel("Pie size factor"), 0, 0);
                 QDoubleSpinBox *pieSizeSpin = new QDoubleSpinBox();
                 pieSizeSpin->setMinimum(LONG_MIN);
                 pieSizeSpin->setMaximum(LONG_MAX);
                 pieSizeSpin->setValue(1.0);
                 pieSizeSpin->setSingleStep(0.1);
                 connect(pieSizeSpin, SIGNAL(valueChanged(double)), this, SLOT(setPieSizeFactor(double)));
                 m_pieLayout->setEnabled(false);
                 m_pieLayout->addWidget(pieSizeSpin, 0, 1);
                 mainLayout->addLayout(m_scatterLayout, 1, 0);
                 mainLayout->addLayout(m_pieLayout, 2, 0);
                 m_chartWidget = new QChartWidget(this);
                 //m_chartWidget->setColor(Qt::red);
                 mainLayout->addWidget(m_chartWidget, 0, 1, 3, 1);
             //    hbox->setStretch(1, 1);
                 setLayout(mainLayout);
                 m_autoScaleCheck->setChecked(true);
                 testDataChanged(0);
             }
             void MainWidget::addSeries()
             {
                 DataSerieDialog dialog(m_defaultSeriesName, 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_defaultSeriesName = series;
                 // 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 < 20; i++) {
                         x.append(i);
                         y.append(i);
                     }
                 } else if (data == "linear, 1M") {
                     for (int i = 0; i < 10000; i++) {
                         x.append(i);
                         y.append(20);
                     }
                 } else if (data == "SIN") {
                     for (int i = 0; i < 100; i++) {
                         x.append(i);
                         y.append(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));
                     }
                 } else {
                     // TODO: check if data has a valid file name
                     Q_ASSERT(false);
                 }
                 // TODO: color of the series
                 QChartSeries *newSeries = 0;
                 if (series == "Scatter") {
                     newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypeScatter);
                     Q_ASSERT(newSeries->setData(x, y));
                 } else if (series == "Pie") {
                     newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypePie);
                     Q_ASSERT(newSeries->setData(y));
                 } else if (series == "Line") {
-                    newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypePie);
+                    // TODO: adding data to an existing line series does not give any visuals for some reason
-                    Q_ASSERT(newSeries->setData(x, y));
+            //        newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypeLine);
+            //        QXYChartSeries *lineSeries = static_cast<QXYChartSeries *>(newSeries);
+            //        lineSeries->setColor(Qt::blue);
+            //        for (int i(0); i < x.count() && i < y.count(); i++) {
+            //            lineSeries->add(x.at(i), y.at(i));
+            //        }
+                    //Q_ASSERT(newSeries->setData(x, y));
+                    QXYChartSeries* series0 = QXYChartSeries::create();
+                    for (int i(0); i < x.count() && i < y.count(); i++)
+                        series0->add(x.at(i), y.at(i));
+                    m_chartWidget->addSeries(series0);
+                    newSeries = series0;
                 } else {
                     // TODO
                 }
                 // BarChart
                 if (series == "Bar") {
                     qDebug() << "Bar chart series";
                     QChartSeries* barSeries = QChartSeries::create(QChartSeries::SeriesTypeBar, this);
                     QList<int> barData;
                     barData << 1;
                     barData << 12;
                     barData << 5;
                     barData << 8;
                     barData << 17;
                     barData << 9;
                     barSeries->setData(barData);
                     m_chartWidget->addSeries(barSeries);
                 }
                 setCurrentSeries(newSeries);
             }
             void MainWidget::setCurrentSeries(QChartSeries *series)
             {
                 m_currentSeries = series;
                 switch (m_currentSeries->type()) {
                 case QChartSeries::SeriesTypeLine:
                     break;
                 case QChartSeries::SeriesTypeScatter:
                     break;
                 case QChartSeries::SeriesTypePie:
                     break;
                 default:
                     Q_ASSERT(false);
                     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;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chartWidget->setTheme((QChart::ChartTheme) themeIndex);
             }
             void MainWidget::setPieSizeFactor(double size)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 Q_ASSERT(pie);
                 pie->setSizeFactor(qreal(size));
             }

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