HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r61:45d3de5e814a

Refactored series creation with QChart

Tero Ahola -

r61:45d3de5e814a

parent child

Context file:

r61:45d3de5e814a

Collapse all files

src/qchart.cpp +4 -5

             #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)
             {
                 //  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);
                     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(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type)
+            QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
-                Q_ASSERT(type == QChartSeries::SeriesTypeScatter
-                         || type == QChartSeries::SeriesTypePie);
                 switch (type) {
                 case QChartSeries::SeriesTypeScatter: {
-                    QScatterSeries *scatterSeries = new QScatterSeries(x, y, this);
+                    QScatterSeries *scatterSeries = new QScatterSeries(this);
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             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
                     // we should use a generic data class instead of list of x and y values
-                    QPieSeries *pieSeries = new QPieSeries(x, this);
+                    QPieSeries *pieSeries = new QPieSeries(this);
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             pieSeries, SLOT(chartSizeChanged(QRectF)));
                     return pieSeries;
                 }
                 default:
+                    Q_ASSERT(false);
                     break;
                 }
                 return 0;
             }
             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"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 -1

             #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:
                 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(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type);
+                QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 virtual void setSize(const QSizeF& rect);
                 void setMargin(int margin);
                 int margin() const;
             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<BarGroup*> m_BarGroupItems;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartseries.h +5 -2

             #ifndef QCHARTSERIES_H
             #define QCHARTSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartSeries : public QObject
             {
             public:
                 enum QChartSeriesType {
                     SeriesTypeLine = 0,
             //        SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypePie,
                     SeriesTypeScatter
             //        SeriesTypeSpline
                 };
             protected:
                 QChartSeries(QObject *parent = 0):QObject(parent){};
             public:
                 virtual ~QChartSeries(){};
-                //factory method
+                // Factory method
                 static QChartSeries* create(QObject* parent = 0 ){ return 0;}
-                //pure virtual
+                // Pure virtual
                 virtual QChartSeriesType type() const = 0;
+                virtual bool setData(QList<int> data) { return false; }
+                virtual bool setData(QList<qreal> data) { return false; }
+                virtual bool setData(QList<qreal> x, QList<qreal> y){ return false; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.cpp +2 -2

             #include "qchartview.h"
             #include "qchart.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
                 QGraphicsView(parent),
                 m_scene(new QGraphicsScene()),
                 m_chart(new QChart()),
                 m_rubberBand(0),
                 m_showRubberBand(false)
             {
             	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->setSize(size());
                 QWidget::resizeEvent(event);
             }
             void QChartView::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
-            QChartSeries* QChartView::createSeries(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type)
+            QChartSeries* QChartView::createSeries(QChartSeries::QChartSeriesType type)
             {
-                return m_chart->createSeries(x, y, type);
+                return m_chart->createSeries(type);
             }
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 int margin = m_chart->margin();
                 QRect rect(margin,margin,width()-2*margin,height()-2*margin);
                 m_origin = event->pos();
                 if (!rect.contains(m_origin)) return;
                 if (!m_rubberBand)
                 m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                 m_rubberBand->setGeometry(QRect(m_origin, QSize()));
                 m_showRubberBand=true;
                 m_rubberBand->show();
             }
              void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_showRubberBand)
                 m_rubberBand->setGeometry(QRect(m_origin, event->pos()).normalized());
             }
              void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_showRubberBand) {
                     m_rubberBand->hide();
                     m_showRubberBand=false;
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +2 -2

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
             public:
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
-                // TODO: addSeries and createSeries are optional solutions
                 void addSeries(QChartSeries* series);
-                QChartSeries* createSeries(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type);
+                // Convenience function
+                QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
             protected:
                 void mouseMoveEvent (QMouseEvent *event);
                 void mousePressEvent (QMouseEvent *event);
                 void mouseReleaseEvent (QMouseEvent *event);
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QRubberBand *m_rubberBand;
                 QPoint m_origin;
                 bool m_showRubberBand;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qchartwidget.cpp +3 -3

             #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(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type)
+            QChartSeries* QChartWidget::createSeries(QChartSeries::QChartSeriesType type)
             {
-                return m_chart->createSeries(x, y, type);
+                return m_chart->createSeries(type);
             }
             #include "moc_qchartwidget.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartwidget.h +1 -1

             #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(QList<qreal> x, QList<qreal> y, QChartSeries::QChartSeriesType type);
+                QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
             private:
                 Q_DISABLE_COPY(QChartWidget)
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qpieseries.cpp +17 -11

             #include "qpieseries.h"
             #include "pieslice.h"
             #include <QGraphicsObject>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QPieSeries::QPieSeries(QList<qreal> x, QGraphicsObject *parent) :
+            QPieSeries::QPieSeries(QGraphicsObject *parent) :
                 QChartSeries(parent),
-                m_x(x),
                 m_sizeFactor(1.0)
             {
+            }
+            QPieSeries::~QPieSeries()
+            {
+                while (m_slices.count())
+                    delete m_slices.takeLast();
+            }
+            bool QPieSeries::setData(QList<qreal> data)
+            {
+                m_data = data;
                 // Create slices
                 qreal fullPie = 360;
                 qreal total = 0;
-                foreach (qreal value, m_x)
+                foreach (qreal value, m_data)
                     total += value;
-                QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent);
+                QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent());
                 Q_ASSERT(parentItem);
                 m_chartSize = parentItem->boundingRect();
                 qreal angle = 0;
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
-                foreach (qreal value, m_x) {
+                foreach (qreal value, m_data) {
                     qreal span = value / total * fullPie;
                     PieSlice *slice = new PieSlice(randomColor(), angle, span, parentItem->boundingRect());
                     slice->setParentItem(parentItem);
                     m_slices.append(slice);
                     angle += span;
                 }
                 resizeSlices(m_chartSize);
+                return true;
-            QPieSeries::~QPieSeries()
-                while (m_slices.count())
-                    delete m_slices.takeLast();
             }
             void QPieSeries::chartSizeChanged(QRectF chartRect)
             {
                 // TODO: allow user setting the size?
                 // TODO: allow user defining the margins?
                 m_chartSize = chartRect;
                 resizeSlices(m_chartSize);
             }
             void QPieSeries::resizeSlices(QRectF rect)
             {
                 QRectF tempRect = rect;
                 if (tempRect.width() < tempRect.height()) {
                     tempRect.setWidth(tempRect.width() * m_sizeFactor);
                     tempRect.setHeight(tempRect.width());
                     tempRect.moveCenter(rect.center());
                 } else {
                     tempRect.setHeight(tempRect.height() * m_sizeFactor);
                     tempRect.setWidth(tempRect.height());
                     tempRect.moveCenter(rect.center());
                 }
                 foreach (PieSlice *slice, m_slices)
                     slice->m_rect = tempRect;
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor > 0.0)
                     m_sizeFactor = factor;
                 resizeSlices(m_chartSize);
                 // Initiate update via the parent graphics item
                 // TODO: potential issue: what if this function is called from the parent context?
                 QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent());
                 Q_ASSERT(parentItem);
                 parentItem->update();
             }
             QColor QPieSeries::randomColor()
             {
                 QColor c;
                 c.setRed(qrand() % 255);
                 c.setGreen(qrand() % 255);
                 c.setBlue(qrand() % 255);
                 return c;
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qpieseries.h +3 -2

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
-                QPieSeries(QList<qreal> x, QGraphicsObject *parent = 0);
+                QPieSeries(QGraphicsObject *parent = 0);
                 ~QPieSeries();
                 QColor randomColor();
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() { return m_sizeFactor; }
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
+                bool setData(QList<qreal> data);
             public Q_SLOTS:
                 void chartSizeChanged(QRectF rect);
             private:
                 void resizeSlices(QRectF rect);
                 //Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: move the followin to internal impl
-                QList<qreal> m_x;
+                QList<qreal> m_data;
                 QList<PieSlice*> m_slices;
                 QRectF m_chartSize;
                 qreal m_sizeFactor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/qscatterseries.cpp +14 -6

             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //#define QSeriesData QList<qreal>
-            QScatterSeriesPrivate::QScatterSeriesPrivate(QList<qreal> x, QList<qreal> y, QGraphicsItem *parent) :
+            QScatterSeriesPrivate::QScatterSeriesPrivate(QGraphicsItem *parent) :
                 QGraphicsItem(parent),
-                m_x(x),
-                m_y(y),
                 m_scalex(100), // TODO: let the use define the scale (or autoscaled)
                 m_scaley(100)
             {
-                resize(parent->boundingRect());
             }
             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));
                 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(QList<qreal> x, QList<qreal> y, QObject *parent) :
+            QScatterSeries::QScatterSeries(QObject *parent) :
                 QChartSeries(parent),
-                d(new QScatterSeriesPrivate(x, y, qobject_cast<QGraphicsItem *> (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);
             }
             // 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 -1

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qchartseries.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 //QScatterSeries(QSeriesData *data, QObject *chart);
-                QScatterSeries(QList<qreal> x, QList<qreal> y, QObject *parent = 0);
+                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 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 -1

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
             class QScatterSeriesPrivate : public QGraphicsItem
             {
             public:
-                QScatterSeriesPrivate(QList<qreal> x, QList<qreal> y, QGraphicsItem *parent);
+                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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

test/chartwidgettest/mainwidget.cpp +8 -12

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include <qxychartseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 // Chart background
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("None");
                 backgroundCombo->addItem("TODO Grid");
                 backgroundCombo->addItem("TODO Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 // Axis
                 // TODO: multiple axes?
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 QGridLayout *grid = new QGridLayout();
                 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);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), 8, 0);
                 grid->setRowStretch(8, 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;
-                QChartSeries *newSeries = QXYChartSeries::create();
                 // TODO: a dedicated data class for storing x and y values
                 QList<qreal> x;
                 QList<qreal> y;
                 if (data == "linear") {
                     for (int i = 0; i < 20; i++) {
                         x.append(i);
                         y.append(i);
                     }
-                    for (int i = 0; i < 20; i++)
-                        ((QXYChartSeries *)newSeries)->add(i, i);
                 } else if (data == "linear, 1M") {
                     for (int i = 0; i < 10000; i++) {
                         x.append(i);
                         y.append(20);
                     }
-                    for (int i = 0; i < 1000000; i++)
-                        ((QXYChartSeries *)newSeries)->add(i, 10);
                 } else if (data == "SIN") {
                     for (int i = 0; i < 100; i++) {
                         x.append(i);
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                     }
-                    for (int i = 0; i < 100; i++)
-                        ((QXYChartSeries *)newSeries)->add(i, abs(sin(3.14159265358979 / 50 * i) * 100));
                 } else if (data == "SIN + random") {
                     for (qreal i = 0; i < 100; i += 0.1) {
                         x.append(i + (rand() % 5));
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                     }
-                    for (qreal i = 0; i < 100; i += 0.1)
-                        ((QXYChartSeries *)newSeries)->add(i + (rand() % 5), 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(x, y, QChartSeries::SeriesTypeScatter);
+                    newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypeScatter);
+                    Q_ASSERT(newSeries->setData(x, y));
                 } else if (series == "Pie") {
-                    newSeries = m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypePie);
+                    newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypePie);
+                    Q_ASSERT(newSeries->setData(y));
                 } else if (series == "Line") {
-                    m_chartWidget->addSeries(newSeries);
+                    newSeries = m_chartWidget->createSeries(QChartSeries::SeriesTypePie);
+                    Q_ASSERT(newSeries->setData(x, y));
                 } else {
                     // TODO
                 }
                 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::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