HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r75:cdad8ac737ab

Color themes now enabled for scatter, pie and line series.

Tero Ahola -

r75:cdad8ac737ab

parent child

Context file:

r75:cdad8ac737ab

Collapse all files

src/qchart.cpp +63 -29

             #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 "plotdomain_p.h"
             #include "axisitem_p.h"
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
                 m_background(new QGraphicsRectItem(this)),
                 m_title(new QGraphicsTextItem(this)),
                 m_axisX(new AxisItem(AxisItem::X_AXIS,this)),
                 m_axisY(new AxisItem(AxisItem::Y_AXIS,this)),
                 m_plotDataIndex(0),
                 m_marginSize(0)
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeVanilla);
                 //  setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 PlotDomain domain;
                 m_plotDomainList<<domain;
                 m_chartItems<<m_axisX;
                 m_chartItems<<m_axisY;
             }
             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;
+                m_chartSeries << 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());
+                        xyseries->setColor(nextColor());
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     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);
                     m_chartItems<<item;
                     foreach(ChartItem* i ,m_chartItems)
                         i->setPlotDomain(m_plotDomainList.at(m_plotDataIndex));
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             barSeries, SLOT(chartSizeChanged(QRectF)));
                     break;
                     }
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
+                    scatterSeries->d->setParentItem(this);
+                    // Set pre-defined colors in case the series has no colors defined
+                    if (!scatterSeries->markerColor().isValid())
+                        scatterSeries->setMarkerColor(nextColor());
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             scatterSeries, SLOT(chartSizeChanged(QRectF)));
-                    scatterSeries->d->setParentItem(this);
+            //        QColor nextColor = m_themeColors.takeFirst();
-                    QColor nextColor = m_themeColors.takeFirst();
+            //        nextColor.setAlpha(150); // TODO: default opacity?
-                    nextColor.setAlpha(150); // TODO: default opacity?
+            //        scatterSeries->setMarkerColor(nextColor);
-                    scatterSeries->setMarkerColor(nextColor);
+                    break;
                     }
                 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);
+                    for (int i(0); i < pieSeries->sliceCount(); i++) {
+                        if (!pieSeries->sliceColor(i).isValid())
+                            pieSeries->setSliceColor(i, nextColor());
+                    }
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             pieSeries, SLOT(chartSizeChanged(QRectF)));
+                    // Set pre-defined colors in case the series has no colors defined
                     // TODO: how to define the color for all the slices of a pie?
+            //        for (int (i); i < pieSeries.sliceCount(); i++)
+                    break;
                     }
                 }
             }
             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;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setSize(const QSize& size)
             {
                 m_rect = QRect(QPoint(0,0),size);
                 QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 //recalculate background gradient
                 m_background->setRect(rect);
                 m_backgroundGradient.setFinalStop(0,m_background->rect().height());
                 m_background->setBrush(m_backgroundGradient);
                 //resize elements
                 foreach (ChartItem* item ,m_chartItems) {
                     item->setPos(rect.topLeft());
                     item->setSize(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()));
                 update();
             }
             void QChart::setBackgroundColor(const QColor& color)
             {
                 m_backgroundGradient.setColorAt( 0.0, Qt::white);
                 m_backgroundGradient.setColorAt( 1.0, color);
                 m_background->setBrush(m_backgroundGradient);
                 m_background->setPen(Qt::NoPen);
                 m_background->update();
             }
             void QChart::setTitle(const QString& title)
             {
                 m_title->setPlainText(title);
             }
             int QChart::margin() const
             {
                 return m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
-            void QChart::setTheme(QChart::ChartTheme theme)
+            void QChart::setTheme(QChart::ChartThemeId theme)
             {
+            //    if (theme != m_currentTheme) {
+                m_themeColors.clear();
                 // TODO: define color themes
                 switch (theme) {
-                case ChartThemeVanilla:
+                case QChart::ChartThemeVanilla:
-                    m_themeColors.append(QColor(255, 238, 174));
+                    m_themeColors.append(QColor(217, 197, 116));
-                    m_themeColors.append(QColor(228, 228, 160));
+                    m_themeColors.append(QColor(214, 168, 150));
-                    m_themeColors.append(QColor(228, 179, 160));
+                    m_themeColors.append(QColor(160, 160, 113));
-                    m_themeColors.append(QColor(180, 151, 18));
+                    m_themeColors.append(QColor(210, 210, 52));
-                    m_themeColors.append(QColor(252, 252, 37));
+                    m_themeColors.append(QColor(136, 114, 58));
                     break;
-                case ChartThemeIcy:
+                case QChart::ChartThemeIcy:
-                    m_themeColors.append(QColor(255, 238, 174));
+                    m_themeColors.append(QColor(0, 3, 165));
-                    m_themeColors.append(QColor(228, 228, 160));
+                    m_themeColors.append(QColor(49, 52, 123));
-                    m_themeColors.append(QColor(228, 179, 160));
+                    m_themeColors.append(QColor(71, 114, 187));
-                    m_themeColors.append(QColor(180, 151, 18));
+                    m_themeColors.append(QColor(48, 97, 87));
-                    m_themeColors.append(QColor(252, 252, 37));
+                    m_themeColors.append(QColor(19, 71, 90));
+                    m_themeColors.append(QColor(110, 70, 228));
                     break;
-                case ChartThemeGrayscale:
+                case QChart::ChartThemeGrayscale:
-                    m_themeColors.append(QColor(255, 238, 174));
+                    m_themeColors.append(QColor(0, 0, 0));
-                    m_themeColors.append(QColor(228, 228, 160));
+                    m_themeColors.append(QColor(50, 50, 50));
-                    m_themeColors.append(QColor(228, 179, 160));
+                    m_themeColors.append(QColor(100, 100, 100));
-                    m_themeColors.append(QColor(180, 151, 18));
+                    m_themeColors.append(QColor(140, 140, 140));
-                    m_themeColors.append(QColor(252, 252, 37));
+                    m_themeColors.append(QColor(180, 180, 180));
                     break;
                 default:
                     Q_ASSERT(false);
                     break;
                 }
-                // TODO: update coloring of different elements to match the selected theme
+                foreach(QChartSeries* series, m_chartSeries) {
+                    // TODO: other series interested on themes?
+                    if (series->type() == QChartSeries::SeriesTypeLine) {
+                        QXYChartSeries *lineseries = reinterpret_cast<QXYChartSeries *>(series);
+                        lineseries->setColor(nextColor());
+                    } else if (series->type() == QChartSeries::SeriesTypeScatter) {
+                        QScatterSeries *scatter = qobject_cast<QScatterSeries *>(series);
+                        scatter->setMarkerColor(nextColor());
+                    } else if (series->type() == QChartSeries::SeriesTypePie) {
+                        QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
+                        for (int i(0); i < pieSeries->sliceCount(); i++)
+                            pieSeries->setSliceColor(i, nextColor());
+                    }
+                }
+                update();
+            }
+            QColor QChart::nextColor()
+            {
+                QColor nextColor = m_themeColors.first();
+                m_themeColors.move(0, m_themeColors.size() - 1);
+                return nextColor;
             }
             void QChart::zoomInToRect(const QRect& rectangle)
             {
                 if(!rectangle.isValid()) return;
                 qreal margin = this->margin();
                 QRect rect = rectangle.normalized();
                 rect.translate(-margin, -margin);
                 PlotDomain& oldDomain = m_plotDomainList[m_plotDataIndex];
                 PlotDomain newDomain;
                 qreal dx = oldDomain.spanX() / (m_rect.width() - 2 * margin);
                 qreal dy = oldDomain.spanY() / (m_rect.height() - 2 * margin);
                 newDomain.m_minX = oldDomain.m_minX + dx * rect.left();
                 newDomain.m_maxX = oldDomain.m_minX + dx * rect.right();
                 newDomain.m_minY = oldDomain.m_maxY - dy * rect.bottom();
                 newDomain.m_maxY = oldDomain.m_maxY - dy * rect.top();
                 m_plotDomainList.resize(m_plotDataIndex + 1);
                 m_plotDomainList<<newDomain;
                 m_plotDataIndex++;
                 foreach (ChartItem* item ,m_chartItems)
                     item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                 update();
             }
             void QChart::zoomIn()
             {
                 if (m_plotDataIndex < m_plotDomainList.count() - 1) {
                     m_plotDataIndex++;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }else{
                     QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     zoomInToRect(rect);
                 }
             }
             void QChart::zoomOut()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex--;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +5 -5

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsObject>
             #include <QLinearGradient>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class ChartItem;
             class BarGroup;
             class QChartAxis;
             // 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 {
+                enum ChartThemeId {
                     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);
                 void setSize(const QSize& size);
                 void setMargin(int margin);
                 int margin() const;
-                void setTheme(QChart::ChartTheme theme);
+                void setTheme(QChart::ChartThemeId theme);
                 void setTitle(const QString& title);
                 void setBackgroundColor(const QColor& color);
                 void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void setAxisX(QChartAxis* axis){};
                 void setAxisY(QChartAxis* axis){};
                 void setAxisY(QList<QChartAxis*> axis){};
             signals:
                 //TODO chage to const QSize& size
                 void sizeChanged(QRectF rect);
                 void scaleChanged(qreal xscale, qreal yscale);
             private:
+                QColor nextColor();
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_background;
                 QLinearGradient m_backgroundGradient;
                 QGraphicsTextItem* m_title;
                 AxisItem* m_axisX;
                 AxisItem* m_axisY;
                 QRect m_rect;
-                QList<const QChartSeries*> m_series;
+                QList<QChartSeries*> m_chartSeries;
                 QVector<PlotDomain> m_plotDomainList;
                 QList<ChartItem*> m_chartItems;
-                //TODO: remove
-                QList<QGraphicsItem*> m_items;
                 int m_plotDataIndex;
                 int m_marginSize;
                 QList<QColor> m_themeColors;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartwidget.cpp +1 -1

             #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)
+            void QChartWidget::setTheme(QChart::ChartThemeId theme)
             {
                 m_chart->setTheme(theme);
             }
             #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(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);
+                void setTheme(QChart::ChartThemeId theme);
             private:
                 Q_DISABLE_COPY(QChartWidget)
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qpieseries.cpp +20 -11

             #include "qpieseries.h"
             #include "pieslice.h"
             #include <QGraphicsObject>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeries::QPieSeries(QGraphicsObject *parent) :
                 QChartSeries(parent),
                 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_data)
                     total += value;
                 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_data) {
                     qreal span = value / total * fullPie;
-                    PieSlice *slice = new PieSlice(randomColor(), angle, span, parentItem->boundingRect());
+                    PieSlice *slice = new PieSlice(QColor(), angle, span, parentItem->boundingRect());
                     slice->setParentItem(parentItem);
                     m_slices.append(slice);
                     angle += span;
                 }
                 resizeSlices(m_chartSize);
                 return true;
             }
+            void QPieSeries::setSliceColor(int index, QColor color)
+            {
+                if (index >= 0 && index < m_slices.count())
+                    m_slices.at(index)->m_color = color;
+            }
+            QColor QPieSeries::sliceColor(int index)
+            {
+                if (index >= 0 && index < m_slices.count())
+                    return m_slices.at(index)->m_color;
+                else
+                    return QColor();
+            }
+            int QPieSeries::sliceCount()
+            {
+                return m_slices.count();
+            }
             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 +6 -1

             #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(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:
+                void setSliceColor(int index, QColor color);
+                QColor sliceColor(int index);
+                int sliceCount();
             public Q_SLOTS:
                 void chartSizeChanged(QRectF rect);
             private:
                 void resizeSlices(QRectF rect);
                 //Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
+                friend class QChart;
                 // TODO: move the followin to internal impl
                 QList<qreal> m_data;
                 QList<PieSlice*> m_slices;
                 QRectF m_chartSize;
                 qreal m_sizeFactor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/qscatterseries.cpp +5 0

             #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_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(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;
             }
+            QColor QScatterSeries::markerColor()
+            {
+                return d->m_markerColor;
+            }
             // 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 +1 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);
+                QColor markerColor();
                 //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);
+            public:
                 // 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

test/chartwidgettest/mainwidget.cpp +3 -3

             #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") {
                     // TODO: adding data to an existing line series does not give any visuals for some reason
             //        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);
+                m_chartWidget->setTheme((QChart::ChartThemeId) themeIndex);
             }
             void MainWidget::setPieSizeFactor(double size)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
-                Q_ASSERT(pie);
+                if (pie)
-                pie->setSizeFactor(qreal(size));
+                    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