HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r66:f1cd31b8c179

Merge branch 'master' of https://git.it.local/repos/QtCommercialDevel-13049/charts

sauimone -

r66:f1cd31b8c179

parent child

Context file:

r66:f1cd31b8c179

Collapse all files

src/qchart.cpp +76 -28

             #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_axisX(new Axis(this)),
-            		m_axisY(new Axis(this)),
+                m_axisY(new Axis(this)),
-            		m_grid(new XYGrid(this)),
+                m_grid(new XYGrid(this)),
-            		m_plotDataIndex(0),
+                m_plotDataIndex(0),
-            		m_marginSize(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;
                     }
+                case QChartSeries::SeriesTypeScatter: {
+                    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);
+                    }
+                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 = 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?
+                    }
                 }
             }
             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: {
-                    QScatterSeries *scatterSeries = new QScatterSeries(this);
+                    series = new QScatterSeries(this);
-                    connect(this, SIGNAL(sizeChanged(QRectF)),
+                    break;
-                            scatterSeries, SLOT(chartSizeChanged(QRectF)));
-                    scatterSeries->d->setParentItem(this);
-                    return scatterSeries;
                 }
                 case QChartSeries::SeriesTypePie: {
-                    // TODO: we now have also a list of y values as a parameter, it is ignored
+                    series = new QPieSeries(this);
-                    // we should use a generic data class instead of list of x and y values
+                    break;
-                    QPieSeries *pieSeries = new QPieSeries(this);
-                    connect(this, SIGNAL(sizeChanged(QRectF)),
-                            pieSeries, SLOT(chartSizeChanged(QRectF)));
-                    return pieSeries;
                 }
                 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;
             }
-            #include "moc_qchart.cpp"
+            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/qchart.h +9 0

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Axis;
             class XYGrid;
             class QChartSeries;
             class XYPlotDomain;
             class XYLineChartItem;
             class BarGroup;
             // 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 QGraphicsObject
             {
                 Q_OBJECT
             public:
+                enum ChartTheme {
+                    ChartThemeVanilla = 0,
+                    ChartThemeIcy,
+                    ChartThemeGrayscale
+                };
+            public:
                 QChart(QGraphicsObject* parent = 0);
                 ~QChart();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 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(QChartSeries::QChartSeriesType type);
                 virtual void setSize(const QSizeF& rect);
                 void setMargin(int margin);
                 int margin() const;
+                void setTheme(QChart::ChartTheme theme);
             signals:
                 void sizeChanged(QRectF rect);
                 void scaleChanged(qreal xscale, qreal yscale);
             private:
                 Q_DISABLE_COPY(QChart)
                 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;
+                QList<QColor> m_themeColors;
                 QList<BarGroup*> m_BarGroupItems;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartwidget.cpp +6 0

             #include "qchartwidget.h"
             #include "qchartseries.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartWidget::QChartWidget(QWidget *parent) :
             QGraphicsView(parent)
             {
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 m_scene = new QGraphicsScene();
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart = new QChart();
                 m_scene->addItem(m_chart);
                 show();
             }
             QChartWidget::~QChartWidget()
             {
             }
             void QChartWidget::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->setSize(size());
                 QWidget::resizeEvent(event);
             }
             QSize QChartWidget::sizeHint() const
             {
                 // TODO: calculate size hint based on contents?
                 return QSize(100, 100);
             }
             void QChartWidget::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
             QChartSeries* QChartWidget::createSeries(QChartSeries::QChartSeriesType type)
             {
                 return m_chart->createSeries(type);
             }
+            void QChartWidget::setTheme(QChart::ChartTheme theme)
+            {
+                m_chart->setTheme(theme);
+            }
             #include "moc_qchartwidget.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartwidget.h +6 0

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartSeries;
             class QChartWidgetPrivate;
             class QTCOMMERCIALCHART_EXPORT QChartWidget : public QGraphicsView
             {
                 Q_OBJECT
             public:
                 explicit QChartWidget(QWidget *parent = 0);
                 ~QChartWidget();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
                 QSize sizeHint() const;
                 // TODO: addSeries and createSeries are optional solutions
                 // TODO: currently createSeries assumes x, y value pairs. This isn't case with all charts. So is there another createSeries for other types (for example one list of ints)?
                 void addSeries(QChartSeries* series);
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
+                /*!
+                 * Set color theme for the chart. Themes define harmonic colors for the graphical elements of
+                 * the chart.
+                 */
+                void setTheme(QChart::ChartTheme theme);
             private:
                 Q_DISABLE_COPY(QChartWidget)
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qscatterseries.cpp +9 -2

             #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(QGraphicsItem *parent) :
                 QGraphicsItem(parent),
                 m_scalex(100), // TODO: let the use define the scale (or autoscaled)
-                m_scaley(100)
+                m_scaley(100),
+                m_markerColor(QColor())
             {
             }
             void QScatterSeriesPrivate::resize(QRectF rect)
             {
                 m_scenex.clear();
                 m_sceney.clear();
                 foreach(qreal x, m_x)
                     m_scenex.append(rect.left() + x * (rect.width() / m_scalex));
                 foreach(qreal y, m_y)
                     m_sceney.append(rect.bottom() - y * (rect.height() / m_scaley));
             }
             // TODO:
             //void QScatterSeriesPrivate::setAxisScale(qreal xscale, qreal yscale)
             QRectF QScatterSeriesPrivate::boundingRect() const
             {
                 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, 100));
+                //brush.setColor(QColor(255, 82, 0, 100));
+                brush.setColor(m_markerColor);
                 pen.setBrush(brush);
                 pen.setWidth(4);
                 painter->setPen(pen);
                 // TODO: m_scenex and m_sceny are left empty during construction -> we would need a resize
                 // event right after construction or maybe given a size during initialization
                 for (int i(0); i < m_scenex.count() && i < m_sceney.count(); i++) {
                     if (scene()->width() > m_scenex.at(i) && scene()->height() > m_sceney.at(i))
                         //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(QObject *parent) :
                 QChartSeries(parent),
                 d(new QScatterSeriesPrivate(qobject_cast<QGraphicsItem *> (parent)))
             {
             }
             bool QScatterSeries::setData(QList<qreal> x, QList<qreal> y)
             {
                 // TODO: validate data
                 d->m_x = x;
                 d->m_y = y;
                 QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent());
                 Q_ASSERT(parentItem);
                 d->resize(parentItem->boundingRect());
                 return true;
             }
             void QScatterSeries::chartSizeChanged(QRectF rect)
             {
                 // Recalculate scatter data point locations on the scene
             //    d->transform().reset();
             //    d->transform().translate();
                 d->resize(rect);
             }
+            void QScatterSeries::setMarkerColor(QColor color)
+            {
+                d->m_markerColor = color;
+            }
             // TODO:
             //void QScatterSeries::chartScaleChanged(qreal xscale, qreal yscale)
             //{
             //    d->rescale(xscale, yscale);
             //}
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qscatterseries.h +2 0

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qchartseries.h"
             #include <QRectF>
+            #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 //QScatterSeries(QSeriesData *data, QObject *chart);
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypeScatter; }
                 bool setData(QList<qreal> x, QList<qreal> y);
             public Q_SLOTS:
                 void chartSizeChanged(QRectF rect);
+                void setMarkerColor(QColor color);
                 //void chartScaleChanged(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 +1 0

             #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(QGraphicsItem *parent);
             public: // from QGraphicsItem
                 void resize(QRectF rect);
                 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;
                 qreal m_scalex;
                 qreal m_scaley;
                 QList<qreal> m_scenex;
                 QList<qreal> m_sceney;
+                QColor m_markerColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

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 +31 -4

             #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(""), 8, 0);
+                grid->addWidget(new QLabel(""), 9, 0);
-                grid->setRowStretch(8, 1);
+                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") {
                     // This is the another way of creating series. Should we create test cases for both ways, if we support them?
                     qDebug() << "Bar chart series";
                     newSeries = QChartSeries::create(QChartSeries::SeriesTypeBar, this);
                     QList<int> barData;
                     barData << 1;
                     barData << 12;
                     barData << 5;
                     barData << 8;
                     barData << 17;
                     barData << 9;
                     newSeries->setData(barData);
                     m_chartWidget->addSeries(newSeries);
                 }
                 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;
                 case QChartSeries::SeriesTypeBar:
                     qDebug() << "setCurrentSeries (bar)";
                     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));
             }

test/chartwidgettest/mainwidget.h +1 0

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
             #include <qchartglobal.h>
             #include <qchartwidget.h>
             #include <QWidget>
             class QSpinBox;
             class QCheckBox;
             class QGridLayout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private slots:
                 void addSeries();
                 void addSeries(QString series, QString data);
                 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);
                 void setCurrentSeries(QChartSeries *series);
+                void changeChartTheme(int themeIndex);
                 void setPieSizeFactor(double margin);
             private:
                 QChartWidget *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
                 QString m_defaultSeriesName;
                 QChartSeries *m_currentSeries;
                 QGridLayout *m_scatterLayout;
                 QGridLayout *m_pieLayout;
             };
             #endif // MAINWIDGET_H

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