HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r110:d11ac5a26e2a

Refactored the test app

Tero Ahola -

r110:d11ac5a26e2a

parent child

Context file:

r110:d11ac5a26e2a

Collapse all files

integrated.pri +9 -11

             integrated_build:{
                 message('Internal build within charts core source tree')
                 INCLUDEPATH += $$CHART_BUILD_HEADER_DIR
                 LIBS += -L $$CHART_BUILD_LIB_DIR -Wl,-rpath,$$CHART_BUILD_LIB_DIR
                 DESTDIR = $$CHART_BUILD_BIN_DIR
                 CONFIG(debug, debug|release) {
-                LIBS += -lQtCommercialChartd
+                    LIBS += -lQtCommercialChartd
+                    #this is ugly hack to work around missing rpath, it simply copies lib
-                #this is ugly hack to work around missing rpath, it simply copies lib
+                    win32:{
-                win32:{
+                        copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
-                    copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
+                        copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChartd.dll $$CHART_BUILD_BIN_DIR
-                    copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChartd.dll $$CHART_BUILD_BIN_DIR
+                        copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChartd.dll
-                    copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChartd.dll
+                        PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
-                    PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
+                        QMAKE_EXTRA_TARGETS +=copylib
-                    QMAKE_EXTRA_TARGETS +=copylib
                 } else {
                     LIBS += -lQtCommercialChart
                     #this is ugly hack to work around missing rpath, it simply copies lib
                     win32: {
                         copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChart
                         copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChart.dll $$CHART_BUILD_BIN_DIR
                         copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChart.dll
                         PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChart
                         QMAKE_EXTRA_TARGETS +=copylib
                     }
                 }
                 mac: {
                     # This is a hack to make binaries to use the internal version of the QtCommercial Charts library on OSX
                     QMAKE_POST_LINK += install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/chartwidgettest.app/Contents/MacOS/chartwidgettest
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/barchart.app/Contents/MacOS/barchart
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/colorlineChart.app/Contents/MacOS/colorlineChart
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/lineChart.app/Contents/MacOS/lineChart
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/percentbarchart.app/Contents/MacOS/percentbarchart
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/stackedbarchart.app/Contents/MacOS/stackedbarchart
                     QMAKE_POST_LINK += && install_name_tool -change "libQtCommercialChartd.1.dylib" "@rpath/libQtCommercialChartd.dylib" $$CHART_BUILD_BIN_DIR/zoomLineChart.app/Contents/MacOS/zoomLineChart
                 }
             } else {
                 CONFIG+=qtcommercialchart
             }

src/charttheme_p.h +1 -1

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QSharedData>
             #include <QColor>
             #include <QLinearGradient>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartTheme;
             class ChartThemeObserver
             {
             public:
                 virtual void themeChanged(ChartTheme *theme) = 0;
             };
             /*!
              * The theme specific settings for the appearance of a series. TODO: These can be overridden by setting
              * custom settings to a QChartSeries object.
              */
             struct SeriesTheme {
             public:
                 SeriesTheme() :
                     linePen(QPen()),
                     markerPen(QPen()) {}
                 SeriesTheme(QColor lineColor, qreal lineWidth/*, QPen marker*/) :
                     linePen(QPen(QBrush(lineColor), lineWidth)),
                     markerPen(linePen) {}
             //const QBrush & brush, qreal width, Qt::PenStyle style = Qt::SolidLine, Qt::PenCapStyle cap = Qt::SquareCap, Qt::PenJoinStyle join = Qt::BevelJo
                 // TODO:
                 //QColor lineColor;
                 QPen linePen;
                 //QBrush lineBrush;
                 QPen markerPen;
                 //QBrush markerBrush;
             };
             /*!
              * Explicitly shared data class for the themes.
              */
             class ChartThemeData : public QSharedData
             {
             public:
                 ChartThemeData() : m_currentTheme(0) {}
                 ~ChartThemeData() {}
             public:
                 void setTheme(int theme);
             public:
                 int m_currentTheme;
                 QList<ChartThemeObserver *> m_observers;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<SeriesTheme> m_seriesThemes;
                 int m_seriesIndex;
             };
             class ChartTheme : public QObject
             {
                 Q_OBJECT
             public:
                 explicit ChartTheme(QObject *parent = 0);
-                explicit ChartTheme(const ChartTheme &other) : d(other.d) {}
+                explicit ChartTheme(const ChartTheme &other, QObject *parent = 0) : QObject(parent), d(other.d) {}
                 void operator =(const ChartTheme &other) { d = other.d; }
                 void setTheme(int theme);
                 SeriesTheme themeForSeries();
                 void addObserver(ChartThemeObserver *o) { d->m_observers << o; }
             public:
                 // All the graphical elements of a QChart share the same theme settings
                 // so let's use explicitly shared data
                 QExplicitlySharedDataPointer<ChartThemeData> d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/pieslice.cpp +1 -1

             #include "pieslice.h"
             #include <QPainter>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieSlice::PieSlice(const QColor& color, qreal startAngle, qreal span, QRectF rect)
                 : m_color(color),
                 m_startAngle(startAngle),
                 m_span(span),
                 m_rect(rect)
             {
                 setAcceptHoverEvents(true);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath PieSlice::shape() const
             {
                 qreal angle = (-m_startAngle) + (90);
                 qreal span = -m_span;
                 QPainterPath path;
                 path.moveTo(boundingRect().center());
                 path.arcTo(boundingRect(), angle, span);
                 // TODO: draw the shape so that it might have a hole in the center
                 // - Sin & Cos will be needed to find inner/outer arc endpoints
                 // dx, dy are offsets from the center
                 //qreal l = boundingRect().height();
                 //qreal dx = qSin(angle*(M_PI/180)) * l;
                 //qreal dy = qCos(angle*(M_PI/180)) * l;
                 // TODO: exploded slice?
                 return path;
             }
-            void PieSlice::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+            void PieSlice::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 painter->setRenderHint(QPainter::Antialiasing);
                 // TODO: how to map theme settings to a pie slice? Now we
                 //painter->setPen(m_theme.linePen);
                 // TODO:
                 painter->setBrush(m_theme.linePen.color());
                 // From Qt docs:
                 // The startAngle and spanAngle must be specified in 1/16th of a degree, i.e. a full circle equals 5760 (16 * 360).
                 // Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction.
                 // Zero degrees is at the 3 o'clock position.
                 //
                 // For sake of simplicity convert this so that zero degrees is at 12 o'clock and full circle is 360.
                 //qreal angle = (-m_startAngle*16) + (90*16);
                 //qreal span = -m_span*16;
                 //painter->drawPie(boundingRect(), angle, span);
                 painter->drawPath(shape());
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
             {
                 QGraphicsItem::hoverEnterEvent(event);
                 qDebug() << "hover" << m_color << m_startAngle << m_span;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +2 -2

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qxychartseries.h"
             #include "qchartaxis.h"
             #include "barchartseries.h"
             #include "bargroup.h"
             #include "stackedbarchartseries.h"
             #include "stackedbargroup.h"
             #include "percentbarchartseries.h"
             #include "percentbargroup.h"
             #include "charttheme_p.h"
             #include "chartitem_p.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_backgroundItem(0),
                 m_titleItem(0),
-                m_axisXItem(new AxisItem(AxisItem::X_AXIS,this)),
+                m_axisXItem(new AxisItem(AxisItem::X_AXIS, this)),
                 m_plotDataIndex(0),
                 m_marginSize(0),
-                m_chartTheme(new ChartTheme())
+                m_chartTheme(new ChartTheme(this))
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeDefault);
                 PlotDomain domain;
                 m_plotDomainList << domain;
                 m_axisYItem << new AxisItem(AxisItem::Y_AXIS,this);
                 m_chartItems << m_axisXItem;
                 m_chartItems << m_axisYItem.at(0);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 return m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                     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;
                     // TODO:
                     //m_chartTheme->addObserver(xyseries);
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     BarGroup* barGroup = new BarGroup(*barSeries,this);
                     // Add some fugly colors for 5 fist series...
                     barGroup->addColor(QColor(255,0,0,128));
                     barGroup->addColor(QColor(255,255,0,128));
                     barGroup->addColor(QColor(0,255,0,128));
                     barGroup->addColor(QColor(0,0,255,128));
                     barGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << barGroup;
                     childItems().append(barGroup);
                     // TODO: setting of domain should this be somewhere else.
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     qreal x = barSeries->countColumns();
                     qreal y = barSeries->max();
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     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);
                     break;
                     }
                 case QChartSeries::SeriesTypeStackedBar: {
                     qDebug() << "barSeries added";
                     StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                     StackedBarGroup* stackedBarGroup = new StackedBarGroup(*stackedBarSeries,this);
                     // Add some fugly colors for 5 fist series...
                     stackedBarGroup->addColor(QColor(255,0,0,128));
                     stackedBarGroup->addColor(QColor(255,255,0,128));
                     stackedBarGroup->addColor(QColor(0,255,0,128));
                     stackedBarGroup->addColor(QColor(0,0,255,128));
                     stackedBarGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << stackedBarGroup;
                     childItems().append(stackedBarGroup);
                     // TODO: setting of domain should this be somewhere else.
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     qreal x = stackedBarSeries->countColumns();
                     qreal y = stackedBarSeries->maxColumnSum();
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     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);
                     break;
                     }
                 case QChartSeries::SeriesTypePercentBar: {
                     qDebug() << "barSeries added";
                     PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                     PercentBarGroup* percentBarGroup = new PercentBarGroup(*percentBarSeries,this);
                     // Add some fugly colors for 5 fist series...
                     percentBarGroup->addColor(QColor(255,0,0,128));
                     percentBarGroup->addColor(QColor(255,255,0,128));
                     percentBarGroup->addColor(QColor(0,255,0,128));
                     percentBarGroup->addColor(QColor(0,0,255,128));
                     percentBarGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << percentBarGroup;
                     childItems().append(percentBarGroup);
                     // TODO: setting of domain should this be somewhere else.
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     qreal x = percentBarSeries->countColumns();
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     domain.m_minX = qMin(domain.m_minX,x);
                     domain.m_minY = 0;
                     domain.m_maxX = qMax(domain.m_maxX,x);
                     domain.m_maxY = 100;
                     break;
                     }
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
                     scatterSeries->d->setParentItem(this);
                     m_chartItems << scatterSeries->d;
                     m_chartTheme->addObserver(scatterSeries->d);
                     break;
                     }
                 case QChartSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                     pieSeries->d->setParentItem(this);
                     m_chartItems << pieSeries->d;
                     pieSeries->d->m_chartTheme = m_chartTheme;
                     m_chartTheme->addObserver(pieSeries->d);
                     break;
                     }
                 }
                 // Update all the items to match the new visible area of the chart
                 foreach(ChartItem* i, m_chartItems)
                     i->setPlotDomain(m_plotDomainList.at(m_plotDataIndex));
             }
             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::SeriesTypeStackedBar: {
                     series = new StackedBarChartSeries(this);
                     break;
                 }
                 case QChartSeries::SeriesTypePercentBar: {
                     series = new PercentBarChartSeries(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 title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                     if (m_bacgroundOrinetation == HorizonatlGradientOrientation)
                         m_backgroundGradient.setFinalStop(m_backgroundItem->rect().width(), 0);
                     else
                         m_backgroundGradient.setFinalStop(0, m_backgroundItem->rect().height());
                     m_backgroundItem->setBrush(m_backgroundGradient);
                 }
                 // resize and reposition childs
                 foreach (ChartItem *item, m_chartItems) {
                     item->setPos(rect.topLeft());
                     item->setSize(rect.size());
                 }
                 update();
             }
             void QChart::setBackground(const QColor& startColor, const QColor& endColor, GradientOrientation orientation)
             {
                 if(!m_backgroundItem){
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_bacgroundOrinetation = orientation;
                 m_backgroundGradient.setColorAt(0.0, startColor);
                 m_backgroundGradient.setColorAt(1.0, endColor);
                 m_backgroundGradient.setStart(0,0);
                 if(orientation == VerticalGradientOrientation){
                     m_backgroundGradient.setFinalStop(0,m_rect.height());
                 }else{
                     m_backgroundGradient.setFinalStop(m_rect.width(),0);
                 }
                 m_backgroundItem->setBrush(m_backgroundGradient);
                 m_backgroundItem->setPen(Qt::NoPen);
                 m_backgroundItem->update();
             }
             void QChart::setTitle(const QString& title,const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
                 m_chartTheme->setTheme(theme);
                 setBackground(m_chartTheme->d->m_gradientStartColor,
                               m_chartTheme->d->m_gradientEndColor,
                               m_bacgroundOrinetation);
                 // TODO: Move the controlling of the series presentations into private implementation of the
                 // series instead of QChart controlling themes for each
                 // In other words, the following should be used when creating xy series:
                 // m_chartTheme->addObserver(xyseries)
                 foreach (QChartSeries *series, m_chartSeries) {
                     if (series->type() == QChartSeries::SeriesTypeLine) {
                         QXYChartSeries *xyseries = static_cast<QXYChartSeries *>(series);
                         SeriesTheme seriesTheme = m_chartTheme->themeForSeries();
                         xyseries->setPen(seriesTheme.linePen);
                     }
                 }
                 update();
             }
             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 domain = oldDomain.subDomain(rect,m_rect.width() - 2 * margin,m_rect.height() - 2 * margin);
                 m_plotDomainList.resize(m_plotDataIndex + 1);
                 m_plotDomainList<<domain;
                 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();
                 }
             }
             void QChart::zoomReset()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex = 0;
                     foreach (ChartItem* item, m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
                 setAxis(m_axisXItem,axis);
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
                 setAxis(m_axisYItem.at(0),axis);
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
                 item->setVisible(axis.isAxisVisible());
             }
             #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>
             #include <QLinearGradient>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class BarGroup;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             // 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 GradientOrientation {
                     HorizonatlGradientOrientation,
                     VerticalGradientOrientation
                 };
                 enum ChartThemeId {
                     ChartThemeInvalid = -1,
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     //ChartThemeScientific,
                     ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsObject* parent = 0);
                 ~QChart();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
-                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
+                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::ChartThemeId theme);
                 void setTitle(const QString& title,const QFont& font = QFont());
                 void setBackground(const QColor& startColor, const QColor& endColor = Qt::white, GradientOrientation orientation = VerticalGradientOrientation);
                 void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void zoomReset();
                 void setAxisX(const QChartAxis& axis);
                 void setAxisY(const QChartAxis& axis);
                 void setAxisY(const QList<QChartAxis>& axis);
             private:
                 void setAxis(AxisItem *item, const QChartAxis& axis);
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QLinearGradient m_backgroundGradient;
                 GradientOrientation m_bacgroundOrinetation;
                 QGraphicsTextItem* m_titleItem;
                 AxisItem* m_axisXItem;
                 QList<AxisItem*> m_axisYItem;
                 QRect m_rect;
                 QList<QChartSeries *> m_chartSeries;
                 QList<ChartItem *> m_chartItems;
                 QVector<PlotDomain> m_plotDomainList;
                 int m_plotDataIndex;
                 int m_marginSize;
                 ChartTheme *m_chartTheme;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartseries.h +4 -4

             #ifndef QCHARTSERIES_H
             #define QCHARTSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartSeries : public QObject
             {
                 Q_OBJECT
             public:
                 enum QChartSeriesType {
                     SeriesTypeLine = 0,
             //        SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter
             //        SeriesTypeSpline
                 };
             protected:
                 QChartSeries(QObject *parent = 0):QObject(parent){};
             public:
                 virtual ~QChartSeries(){};
                 // Factory method
                 static QChartSeries* create(QChartSeriesType type, QObject* parent = 0 );
                 // Pure virtual
                 virtual QChartSeriesType type() const = 0;
-                virtual bool setData(QList<int> data) { return false; }
+                virtual bool setData(QList<int> /*data*/) { return false; }
-                virtual bool setData(QList<qreal> data) { return false; }
+                virtual bool setData(QList<qreal> /*data*/) { return false; }
-                virtual bool setData(QList<qreal> x, QList<qreal> y){ return false; }
+                virtual bool setData(QList<qreal> /*x*/, QList<qreal> /*y*/){ return false; }
                 // Prototype for data model. TODO: remove the other setData methods and use something like this for now?
-                virtual bool setData(QAbstractItemModel* model) { return false; }
+                virtual bool setData(QAbstractItemModel* /*model*/) { return false; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qscatterseries.cpp +1 -1

             #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) :
                 ChartItem(parent),
                 m_markerColor(QColor()),
                 m_visibleChartArea()
             {
             }
             void QScatterSeriesPrivate::resize(QRectF rect)
             {
                 qreal scalex = rect.width() / m_visibleChartArea.spanX();
                 qreal scaley = rect.height() / m_visibleChartArea.spanY();
                 m_scenex.clear();
                 m_sceney.clear();
                 // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
                 foreach(qreal x, m_x)
                     m_scenex.append(rect.left() + x * scalex - m_visibleChartArea.m_minX * scalex);
                 foreach(qreal y, m_y)
                     m_sceney.append(rect.bottom() - y * scaley - m_visibleChartArea.m_minY * scaley);
             }
             void QScatterSeriesPrivate::setSize(const QSize &size)
             {
                 QGraphicsItem *parent = this->parentItem();
                 if (parent)
                     resize(QRectF(parent->pos(), size));
             }
             void QScatterSeriesPrivate::themeChanged(ChartTheme *theme)
             {
                 m_theme = theme->themeForSeries();
             }
             void QScatterSeriesPrivate::setPlotDomain(const PlotDomain& plotDomain)
             {
                 m_visibleChartArea = plotDomain;
                 resize(parentItem()->boundingRect());
             }
             QRectF QScatterSeriesPrivate::boundingRect() const
             {
                 return QRectF(0, 0, 55, 100);
             }
-            void QScatterSeriesPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+            void QScatterSeriesPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 // TODO: The opacity should be user definable?
                 //brush.setColor(QColor(255, 82, 0, 100));
                 if (m_markerColor.isValid()) {
                     QPen pen = painter->pen();
                     QBrush brush = pen.brush();
                     brush.setColor(m_markerColor);
                     pen.setBrush(brush);
                     pen.setWidth(4);
                     painter->setPen(pen);
                 }
                 else
                     painter->setPen(m_theme.markerPen);
             //        brush.setColor(m_theme..lineColor);
                 // 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->setPos(parentItem->pos());
             //    d->setSize(parentItem->boundingRect().size().toSize());
                 d->resize(parentItem->boundingRect());
                 return true;
             }
             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

test/chartwidgettest/mainwidget.cpp +62 -51

             #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>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 m_chartWidget = new QChartWidget(this);
+                // GridLayout for the controls for configuring the chart widget
+                QGridLayout *grid = new QGridLayout();
+                QGridLayout *mainLayout = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
+                grid->addWidget(addSeriesButton, 0, 1);
+                initBackroundCombo(grid);
+                initScaleControls(grid);
+                initThemeCombo(grid);
+                QCheckBox *zoomCheckBox = new QCheckBox("Zoom enabled");
+                connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartWidget, SLOT(setZoomEnabled(bool)));
+                zoomCheckBox->setChecked(true);
+                grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
+                // add row with empty label to make all the other rows static
+                grid->addWidget(new QLabel(""), grid->rowCount(), 0);
+                grid->setRowStretch(grid->rowCount() - 1, 1);
+                mainLayout->addLayout(grid, 0, 0);
+                // Init series type specific controls
+                initPieControls();
+                mainLayout->addLayout(m_pieLayout, 2, 0);
+                // Scatter series specific settings
+            //    m_scatterLayout = new QGridLayout();
+            //    m_scatterLayout->addWidget(new QLabel("scatter"), 0, 0);
+            //    m_scatterLayout->setEnabled(false);
+            //    mainLayout->addLayout(m_scatterLayout, 1, 0);
+                // Add layouts and the chart widget to the main layout
+                mainLayout->addWidget(m_chartWidget, 0, 1, 3, 1);
+                setLayout(mainLayout);
+                // force an update to test data
+                testDataChanged(0);
+            }
-                // Chart background
+            // Combo box for selecting the chart's background
+            void MainWidget::initBackroundCombo(QGridLayout *grid)
+            {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
-                // Axis
+                grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
-                // TODO: multiple axes?
+                grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
+            }
+            // Scale related controls (auto-scale vs. manual min-max values)
+            void MainWidget::initScaleControls(QGridLayout *grid)
+            {
                 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)));
+                grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
+                grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
+                grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
+                grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
+                grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
+                grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
+                grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
+                grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
+                grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
+                m_autoScaleCheck->setChecked(true);
+            }
+            // Combo box for selecting theme
+            void MainWidget::initThemeCombo(QGridLayout *grid)
+            {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Vanilla");
                 chartTheme->addItem("Icy");
                 chartTheme->addItem("Grayscale");
                 chartTheme->addItem("Unnamed1");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
-            //    connect(chartTheme, SIGNAL(currentIndexChanged(int)),
-            //            m_signalMapper, SLOT(map()));
-            //    m_signalMapper->setMapping(chartTheme, (QChart::ChartThemeId)chartTheme->currentIndex());
-            //    connect(m_signalMapper, SIGNAL(mapped(QChart::ChartThemeId)),
-            //            m_chartWidget, SLOT(setTheme(QChart::ChartThemeId)));
-                QCheckBox *zoomCheckBox = new QCheckBox("Zoom enabled");
-                connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartWidget, SLOT(setZoomEnabled(bool)));
-                zoomCheckBox->setChecked(true);
-                QGridLayout *grid = new QGridLayout();
-                QGridLayout *mainLayout = new QGridLayout();
-                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);
-                grid->addWidget(zoomCheckBox, 9, 0);
-                // add row with empty label to make all the other rows static
-                grid->addWidget(new QLabel(""), 10, 0);
-                grid->setRowStretch(10, 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
+            void MainWidget::initPieControls()
+            {
+                // Pie series specific settings
                 // Pie size factory
                 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)));
                 // Pie position
                 QComboBox *piePosCombo = new QComboBox(this);
                 piePosCombo->addItem("Maximized");
                 piePosCombo->addItem("Top left");
                 piePosCombo->addItem("Top right");
                 piePosCombo->addItem("Bottom left");
                 piePosCombo->addItem("Bottom right");
                 connect(piePosCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(setPiePosition(int)));
                 m_pieLayout = new QGridLayout();
                 m_pieLayout->setEnabled(false);
                 m_pieLayout->addWidget(new QLabel("Pie size factor"), 0, 0);
                 m_pieLayout->addWidget(pieSizeSpin, 0, 1);
                 m_pieLayout->addWidget(new QLabel("Pie position"), 1, 0);
                 m_pieLayout->addWidget(piePosCombo, 1, 1);
-                mainLayout->addLayout(m_scatterLayout, 1, 0);
-                mainLayout->addLayout(m_pieLayout, 2, 0);
-                //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") {
                     // 1 million data points from 0.0001 to 100
                     // TODO: What is the requirement? Should we be able to show this kind of data with
                     // reasonable performance, or can we expect the application developer to do "data mining"
                     // for us, so that the count of data points given to QtCommercial Chart is always
                     // reasonable?
                     for (qreal i = 0; i < 100; i += 0.0001) {
                         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);
                     // Create some test data to chart
                     QStandardItemModel dataModel(2,10,this);
                     QModelIndex index;
                     index = dataModel.index(0,0);
                     // Series 1, items 6 to 9 missing.
                     dataModel.setData(dataModel.index(0,0),1);
                     dataModel.setData(dataModel.index(0,1),12);
                     dataModel.setData(dataModel.index(0,2),5);
                     dataModel.setData(dataModel.index(0,3),8);
                     dataModel.setData(dataModel.index(0,4),17);
                     dataModel.setData(dataModel.index(0,5),9);
                     // Series 2, some other items missing
                     dataModel.setData(dataModel.index(1,0),5);
                     dataModel.setData(dataModel.index(1,3),4);
                     dataModel.setData(dataModel.index(1,5),7);
                     dataModel.setData(dataModel.index(1,6),8);
                     dataModel.setData(dataModel.index(1,8),9);
                     dataModel.setData(dataModel.index(1,9),9);
                     newSeries->setData(&dataModel);
                     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::ChartThemeId) themeIndex);
             }
             void MainWidget::setPieSizeFactor(double size)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setSizeFactor(qreal(size));
             }
             void MainWidget::setPiePosition(int position)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setPosition((QPieSeries::PiePosition) position);
             }

test/chartwidgettest/mainwidget.h +6 0

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
             #include <qchartglobal.h>
             #include <qchartwidget.h>
             #include <QWidget>
             class QSpinBox;
             class QCheckBox;
             class QGridLayout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
+            private:
+                void initBackroundCombo(QGridLayout *grid);
+                void initScaleControls(QGridLayout *grid);
+                void initThemeCombo(QGridLayout *grid);
+                void initPieControls();
             private slots:
                 void addSeries();
                 void addSeries(QString series, QString data);
                 void testDataChanged(int itemIndex);
                 void backgroundChanged(int itemIndex);
                 void autoScaleChanged(int value);
                 void xMinChanged(int value);
                 void xMaxChanged(int value);
                 void yMinChanged(int value);
                 void yMaxChanged(int value);
                 void setCurrentSeries(QChartSeries *series);
                 void changeChartTheme(int themeIndex);
                 void setPieSizeFactor(double margin);
                 void setPiePosition(int position);
             private:
                 QChartWidget *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
                 QString m_defaultSeriesName;
                 QChartSeries *m_currentSeries;
                 QGridLayout *m_scatterLayout;
                 QGridLayout *m_pieLayout;
             };
             #endif // MAINWIDGET_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages