HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1276:2661cb767b8b

Scatter customization to QML api

Tero Ahola -

r1276:2661cb767b8b

parent child

Context file:

r1276:2661cb767b8b

Collapse all files

demos/qmlcustomizations/qml/qmlcustomizations/main.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 width: parent.width
                 height: parent.height
                 property int __activeIndex: 1
                 property real __intervalCoefficient: 0
                 ChartView {
                     id: chartView
                     anchors.fill: parent
                     title: "Wheel of fortune"
                     legend: ChartView.LegendDisabled
                     PieSeries {
                         id: wheelOfFortune
                     }
                     SplineSeries {
                         id: splineSeries
                     }
                     ScatterSeries {
                         id: scatterSeries
                     }
                 }
                 Component.onCompleted: {
                     __intervalCoefficient = Math.random() + 0.1;
                     console.log("__intervalCoefficient: " + __intervalCoefficient);
                     for (var i = 0; i < 20; i++)
                         wheelOfFortune.append("", 1);
                     var interval = 1;
                     for (var j = 0; interval < 800; j++) {
                         interval = __intervalCoefficient * j * j;
                         splineSeries.append(j, interval);
                     }
                     chartView.axisX.max = j;
                     chartView.axisY.max = 1000;
                 }
                 Timer {
                     triggeredOnStart: true
                     running: true
                     repeat: true
                     interval: 100
                     onTriggered: {
                         var index = __activeIndex % wheelOfFortune.count;
                         if (interval < 700) {
                             scatterSeries.clear();
                             wheelOfFortune.at(index).exploded = false;
                             __activeIndex++;
                             index = __activeIndex % wheelOfFortune.count;
                             wheelOfFortune.at(index).exploded = true;
                             interval = splineSeries.at(__activeIndex).y;
                             scatterSeries.append(__activeIndex, interval);
                             scatterSeries.color = Qt.tint(scatterSeries.color, "#05FF0000");
+                            scatterSeries.markerSize += 0.5;
                         } else {
                             // Switch the colors of the slice and the border
                             wheelOfFortune.at(index).borderWidth = 2;
                             var borderColor = wheelOfFortune.at(index).borderColor;
                             wheelOfFortune.at(index).borderColor = wheelOfFortune.at(index).color;
                             wheelOfFortune.at(index).color = borderColor;
                         }
                     }
                 }
             }

demos/qmlcustommodel/customtablemodel.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CUSTOMTABLEMODEL_H
             #define CUSTOMTABLEMODEL_H
             #include <QAbstractTableModel>
             #include <QHash>
             class CustomTableModel : public QAbstractTableModel
             {
                 Q_OBJECT
                 Q_PROPERTY(int count READ rowCount)
             public:
                 explicit CustomTableModel(QObject *parent = 0);
                 int rowCount ( const QModelIndex & parent = QModelIndex() ) const;
                 int columnCount ( const QModelIndex & parent = QModelIndex() ) const;
                 QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
                 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
                 bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
                 Qt::ItemFlags flags ( const QModelIndex & index ) const;
                 void insertColumn(int column, const QModelIndex &parent = QModelIndex());
                 void insertRow(int row, const QModelIndex &parent = QModelIndex());
-                /*Q_INVOKABLE*/ //bool removeRow(int row, const QModelIndex &parent = QModelIndex());
                 Q_INVOKABLE bool removeRows(int row, int count, const QModelIndex & parent = QModelIndex());
                 Q_INVOKABLE bool removeRow (int row, const QModelIndex &parent = QModelIndex());
             private:
                 QList<QVector<QVariant> * > m_data;
                 int m_columnCount;
                 int m_rowCount;
             };
             #endif // CUSTOMTABLEMODEL_H

examples/scatterchart/chartview.cpp +4 -4

             #include "chartview.h"
             #include <QScatterSeries>
             ChartView::ChartView(QWidget *parent) :
                 QChartView(new QChart(), parent)
             {
                 //![1]
                 QScatterSeries *series0 = new QScatterSeries();
                 series0->setName("scatter1");
-                series0->setShape(QScatterSeries::MarkerShapeCircle);
+                series0->setMarkerShape(QScatterSeries::MarkerShapeCircle);
-                series0->setSize(15.0);
+                series0->setMarkerSize(15.0);
                 QScatterSeries *series1 = new QScatterSeries();
                 series1->setName("scatter2");
-                series1->setShape(QScatterSeries::MarkerShapeCircle);
+                series1->setMarkerShape(QScatterSeries::MarkerShapeCircle);
-                series1->setSize(20.0);
+                series1->setMarkerSize(20.0);
                 //![1]
                 //![2]
                 series0->append(0, 6);
                 series0->append(2, 4);
                 series0->append(3, 8);
                 series0->append(7, 4);
                 series0->append(10, 5);
                 *series1 << QPointF(1, 1) << QPointF(3, 3) << QPointF(7, 6) << QPointF(8, 3) << QPointF(10, 2);
                 //![2]
                 //![3]
                 setRenderHint(QPainter::Antialiasing);
                 chart()->addSeries(series0);
                 chart()->addSeries(series1);
                 chart()->setTitle("Simple scatterchart example");
                 chart()->setBackgroundDropShadowEnabled(false);
                 //![3]
             }

plugins/declarative/plugin.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #include "qchart.h"
             #include "qaxiscategories.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include <QHPieModelMapper>
             #include <QVPieModelMapper>
             #include <QXYModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXyPoint>(uri, 1, 0, "XyPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeGroupedBarSeries>(uri, 1, 0, "GroupedBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<DeclarativePieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
+                    qmlRegisterUncreatableType<QScatterSeries>(uri, 1, 0, "QScatterSeries",
+                                                      QLatin1String("Trying to create uncreatable: QScatterSeries."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                       QLatin1String("Trying to create uncreatable: QPieSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                       QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                       QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                       QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAxis>(uri, 1, 0, "Axis",
                                                       QLatin1String("Trying to create uncreatable: Axis."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: XYModelMapper."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))

src/linechart/qlineseries.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "linechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
                 \image examples_linechart.png
             	Creating basic line chart is simple:
             	\code
                 QLineSeries* series = new QLineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual SeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QLineSeries::QLineSeries(QObject *parent) : QXYSeries(*new QLineSeriesPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QLineSeries::QLineSeries(QLineSeriesPrivate &d,QObject *parent) : QXYSeries (d,parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
                 Q_D(QLineSeries);
                 if(d->m_dataset){
                        d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QLineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeLine;
             }
             /*
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.d_func()->m_x.size() == series.d_func()->m_y.size());
                 int size = series.d_func()->m_x.size();
                 for (int i=0; i<size; i++) {
                     debug.nospace() << "(" << series.d_func()->m_x.at(i) << ','<< series.d_func()->m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             */
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* q):QXYSeriesPrivate(q)
             {
             };
             Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QLineSeries);
                 LineChartItem* line = new LineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     line->setAnimator(presenter->animator());
                     line->setAnimation(new XYAnimation(line));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return line;
             }
+            #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLINESERIES_H
             #define QLINESERIES_H
             #include <qchartglobal.h>
             #include <qxyseries.h>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
+                Q_OBJECT
             public:
                 explicit QLineSeries(QObject *parent = 0);
                 ~QLineSeries();
                 QAbstractSeries::SeriesType type() const;
             protected:
                 QLineSeries(QLineSeriesPrivate &d,QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QLineSeries)
                 Q_DISABLE_COPY(QLineSeries)
                 friend class LineChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterchart/qscatterseries.cpp +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
             /*!
                 Returns the shape used for drawing markers.
             */
-            QScatterSeries::MarkerShape QScatterSeries::shape() const
+            QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
             */
-            void QScatterSeries::setShape(MarkerShape shape)
+            void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
                 }
             }
             /*!
                 Returns the size of the marker items.
             */
-            qreal QScatterSeries::size() const
+            qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 15.
             */
-            void QScatterSeries::setSize(qreal size)
+            void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyIsNull(d->m_size - size)) {
                     d->m_size = size;
                     emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q):QXYSeriesPrivate(q),
                m_shape(QScatterSeries::MarkerShapeCircle),
                m_size(15.0)
             {
             };
             Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     scatter->setAnimator(presenter->animator());
                     scatter->setAnimation(new XYAnimation(scatter));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }
+            #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.h +8 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include <qchartglobal.h>
             #include <qxyseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
+                Q_OBJECT
+                Q_PROPERTY(MarkerShape markerShape READ markerShape WRITE setMarkerShape)
+                Q_PROPERTY(qreal markerSize READ markerSize WRITE setMarkerSize)
+                Q_ENUMS(MarkerShape)
             public:
                 enum MarkerShape {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             public:
                 explicit QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
                 QAbstractSeries::SeriesType type() const;
+                MarkerShape markerShape() const;
-                MarkerShape shape() const;
+                void setMarkerShape(MarkerShape shape);
-                void setShape(MarkerShape shape);
+                qreal markerSize() const;
-                qreal size() const;
+                void setMarkerSize(qreal size);
-                void setSize(qreal size);
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
                 friend class ScatterChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterchart/scatterchartitem.cpp +7 -6

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
             XYChart(series,presenter),
             QGraphicsItem(presenter ? presenter->rootItem() : 0),
             m_series(series),
             m_items(this),
             m_shape(QScatterSeries::MarkerShapeRectangle),
             m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                         case QScatterSeries::MarkerShapeCircle: {
                             QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                             const QRectF& rect = i->boundingRect();
                             i->setPos(-rect.width()/2,-rect.height()/2);
                             item = new Marker(i,this);
                             break;
                         }
                         case QScatterSeries::MarkerShapeRectangle: {
                             QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                             i->setPos(-m_size/2,-m_size/2);
                             item = new Marker(i,this);
                             break;
                         }
                         default:
                         qWarning()<<"Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker *marker)
             {
                 emit XYChart::clicked(marker->point());
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setPoint(point);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 setPos(origin());
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setBrush(brush);
                 }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
-                bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
+                bool recreate = m_size != m_series->markerSize() || m_shape != m_series->markerShape();
-                //TODO: only rewrite on size change
-                m_size = m_series->size();
+                m_size = m_series->markerSize();
-                m_shape = m_series->shape();
+                m_shape = m_series->markerShape();
                 if(recreate) {
+                    // TODO: optimize handleUpdate to recreate points only in case shape changed
                     deletePoints(count);
                     createPoints(count);
+                    // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
+                    updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             void ScatterChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include <qchartglobal.h>
             #include <qlineseries.h>
             #include <QList>
             #include <QPointF>
             #include <QtGlobal>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
-            public:
+            public:
                 explicit QSplineSeries(QObject *parent = 0);
                 ~QSplineSeries();
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QSplineSeries)
                 Q_DISABLE_COPY(QSplineSeries)
                 friend class SplineChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

tests/chartwidgettest/dataseriedialog.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "dataseriedialog.h"
             #include <QDialogButtonBox>
             #include <QGridLayout>
             #include <QCheckBox>
             #include <QPushButton>
             #include <QGroupBox>
             #include <QRadioButton>
             #include <QLabel>
             #include <QDebug>
             DataSerieDialog::DataSerieDialog(QWidget *parent) :
                 QDialog(parent)
             {
                 QDialogButtonBox *addSeriesBox = new QDialogButtonBox(Qt::Horizontal);
                 QPushButton *b = addSeriesBox->addButton(QDialogButtonBox::Ok);
                 connect(b, SIGNAL(clicked()), this, SLOT(accept()));
                 b = addSeriesBox->addButton(QDialogButtonBox::Cancel);
                 connect(b, SIGNAL(clicked()), this, SLOT(reject()));
                 QGridLayout *grid = new QGridLayout();
                 m_seriesTypeSelector = seriesTypeSelector();
                 m_columnCountSelector = columnCountSelector();
                 m_rowCountSelector = rowCountSelector();
                 m_dataCharacteristicsSelector = dataCharacteristicsSelector();
                 grid->addWidget(m_seriesTypeSelector, 0, 0);
                 grid->addWidget(m_columnCountSelector, 0, 1);
                 grid->addWidget(m_rowCountSelector, 1, 1);
                 grid->addWidget(m_dataCharacteristicsSelector, 1, 0);
                 m_labelsSelector = new QCheckBox("Labels defined");
                 m_labelsSelector->setChecked(true);
                 grid->addWidget(m_labelsSelector, 2, 0);
                 grid->addWidget(addSeriesBox, 3, 1);
                 setLayout(grid);
             }
             QGroupBox *DataSerieDialog::seriesTypeSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *line = new QRadioButton("Line");
                 line->setChecked(true);
                 layout->addWidget(line);
                 layout->addWidget(new QRadioButton("Area"));
                 layout->addWidget(new QRadioButton("Pie"));
                 layout->addWidget(new QRadioButton("Bar"));
                 layout->addWidget(new QRadioButton("Grouped bar"));
                 layout->addWidget(new QRadioButton("Stacked bar"));
                 layout->addWidget(new QRadioButton("Percent bar"));
                 layout->addWidget(new QRadioButton("Scatter"));
                 layout->addWidget(new QRadioButton("Spline"));
                 QGroupBox *groupBox = new QGroupBox("Series type");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::columnCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *radio = new QRadioButton("1");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("2"));
                 layout->addWidget(new QRadioButton("3"));
                 layout->addWidget(new QRadioButton("4"));
                 layout->addWidget(new QRadioButton("5"));
                 layout->addWidget(new QRadioButton("8"));
                 layout->addWidget(new QRadioButton("10"));
                 layout->addWidget(new QRadioButton("100"));
                 QGroupBox *groupBox = new QGroupBox("Column count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::rowCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("1"));
                 QRadioButton *radio = new QRadioButton("10");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("50"));
                 layout->addWidget(new QRadioButton("100"));
+                layout->addWidget(new QRadioButton("1000"));
                 layout->addWidget(new QRadioButton("10000"));
                 layout->addWidget(new QRadioButton("100000"));
                 layout->addWidget(new QRadioButton("1000000"));
                 QGroupBox *groupBox = new QGroupBox("Row count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::dataCharacteristicsSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("Linear"));
                 layout->addWidget(new QRadioButton("Constant"));
                 layout->addWidget(new QRadioButton("Random"));
                 layout->addWidget(new QRadioButton("Sin"));
                 layout->addWidget(new QRadioButton("Sin + random"));
                 QGroupBox *groupBox = new QGroupBox("Data Characteristics");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             void DataSerieDialog::accept()
             {
                 accepted(radioSelection(m_seriesTypeSelector),
                          radioSelection(m_columnCountSelector).toInt(),
                          radioSelection(m_rowCountSelector).toInt(),
                          radioSelection(m_dataCharacteristicsSelector),
                          m_labelsSelector->isChecked());
                 QDialog::accept();
             }
             void DataSerieDialog::selectRadio(QGroupBox *groupBox, int defaultSelection)
             {
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 Q_ASSERT(layout->count());
                 QLayoutItem *item = 0;
                 if (defaultSelection == -1) {
                     item = layout->itemAt(0);
                 } else if (layout->count() > defaultSelection) {
                     item = layout->itemAt(defaultSelection);
                 }
                 Q_ASSERT(item);
                 QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                 Q_ASSERT(radio);
                 radio->setChecked(true);
             }
             QString DataSerieDialog::radioSelection(QGroupBox *groupBox)
             {
                 QString selection;
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 for (int i(0); i < layout->count(); i++) {
                     QLayoutItem *item = layout->itemAt(i);
                     Q_ASSERT(item);
                     QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                     Q_ASSERT(radio);
                     if (radio->isChecked()) {
                         selection = radio->text();
                         break;
                     }
                 }
                 qDebug() << "radioSelection: " << selection;
                 return selection;
             }

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