HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r459:272f4a2e7431

Scatter API review: changed signal now private etc.

Tero Ahola -

r459:272f4a2e7431

parent child

Context file:

r459:272f4a2e7431

Collapse all files

doc/images/chartview_example_scatter.jpg binary modified 0 0

NO CONTENT: modified file, binary diff hidden

src/chartpresenter.cpp 0 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             #include "splinepresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_marginSize(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 if(axis==m_dataset->axisX()){
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX());
                     item->handleTicksCountChanged(4);
                 }
                 else{
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY());
                     item->handleTicksCountChanged(4);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)){
                         item = new LineChartAnimationItem(lineSeries,m_chart);
                     }else{
                         item = new LineChartItem(lineSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     //decorate
                     m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     else {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                      item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                      if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                      //decorate
                     m_chartTheme->decorate(item,areaSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* item = new BarPresenter(barSeries,m_chart);
                     m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     // m_axisXItem->setVisible(false);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                     m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                     m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
-                    QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
-                                     scatterSeries, SIGNAL(clicked(QPointF)));
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                      scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),
                                      scatterPresenter, SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                     m_chartItems.insert(scatterSeries, scatterPresenter);
                     if (m_rect.isValid())
                         scatterPresenter->handleGeometryChanged(m_rect);
                     scatterPresenter->handleDomainChanged(domain->minX(), domain->maxX(), domain->minY(), domain->maxY());
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *s = qobject_cast<QPieSeries *>(series);
                     PiePresenter* pie = new PiePresenter(m_chart, s);
                     m_chartTheme->decorate(pie, s, m_chartItems.count());
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->setAxisVisible(false);
                         m_chart->axisY()->setAxisVisible(false);
                         m_chart->axisX()->setGridVisible(false);
                         m_chart->axisY()->setGridVisible(false);
                         m_chart->axisX()->setLabelsVisible(false);
                         m_chart->axisY()->setLabelsVisible(false);
                         m_chart->axisX()->setShadesVisible(false);
                         m_chart->axisY()->setShadesVisible(false);
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     m_chartItems.insert(series, pie);
                     pie->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
                     SplinePresenter* splinePresenter = new SplinePresenter(splineSeries, m_chart);
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), splinePresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),splinePresenter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     splinePresenter->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     m_chartTheme->decorate(splinePresenter, splineSeries, m_chartItems.count());
                     m_chartItems.insert(splineSeries, splinePresenter);
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                     j.next();
                     m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis,m_dataset->domain(axis));
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series,m_dataset->domain(series));
                     }
                 }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_marginSize, -m_marginSize);
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.cpp +42 -35

             #include "qscatterseries.h"
             #include "scatterseries_p.h"
             #include "qchart.h"
             /*!
                 \class QScatterSeries
                 \brief QtCommercial Chart series API for showing scatter series.
                 \mainclass
                 Example on how to create a chart with scatter series:
                 \snippet ../example/scatter/main.cpp 1
                 The example code would result the following:
                 \image scatter_example1.jpg
                 To customize the graphical representation of the series, you can modify pen, brush, shape and
                 size of the marker items. For example:
                 \snippet ../example/scatter/main.cpp 3
                 Would present your scatter markers as big rectangles with opaque, uglyish green outlines and
                 opaque red filling instead of the beatiful markers defined by the chart's theme:
                 \image scatter_example_custom.jpg
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeDefault
                 \value MarkerShapeX
                 \value MarkerShapeRectangle
+                \value MarkerShapeRoundedRectangle
                 \value MarkerShapeTiltedRectangle
                 \value MarkerShapeTriangle
                 \value MarkerShapeCircle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
             */
             /*!
                 \fn void QScatterSeries::clicked(QPointF coordinate)
                 User clicked the scatter series. Note that the \a coordinate is the chart coordinate that the
                 click occurred on; not necessarily a data point coordinate. To find the corresponding (closest)
                 data point you can use closestPoint().
             */
-            /*!
-                \fn void QScatterSeries::changed()
-                \brief TODO
-            */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QScatterSeriesPrivate::QScatterSeriesPrivate() :
+            QScatterSeriesPrivate::QScatterSeriesPrivate(QObject *parent) :
+                QObject(parent),
                 m_data(QList<QPointF>()),
                 m_markerPen(QPen(QColor::Invalid)),
                 m_markerBrush(QBrush(QColor::Invalid)),
                 m_markerShape(QScatterSeries::MarkerShapeDefault),
                 m_markerSize(9.0)
             {
             }
+            void QScatterSeriesPrivate::emitChanged()
+            {
+                emit changed();
+            }
+            #include "moc_scatterseries_p.cpp"
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QSeries(parent),
-                d(new QScatterSeriesPrivate())
+                d(new QScatterSeriesPrivate(this))
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             /*!
                 Add single data point with \a x and \a y coordinates to the series.
             */
             void QScatterSeries::add(qreal x, qreal y)
             {
                 d->m_data.append(QPointF(x, y));
-                emit changed();
+                d->emitChanged();
             }
             /*!
                 Add single data point with \a value to the series.
             */
             void QScatterSeries::add(QPointF value)
             {
                 d->m_data.append(value);
-                emit changed();
+                d->emitChanged();
             }
             /*!
                 Add list of \a points to the series.
             */
             void QScatterSeries::add(QList<QPointF> points)
             {
                 d->m_data.append(points);
-                emit changed();
+                d->emitChanged();
             }
             /*!
                 Stream operator for adding a data point with \a value to the series.
                 \sa add()
                 For example:
                 \snippet ../example/scatter/main.cpp 2
             */
             QScatterSeries& QScatterSeries::operator << (const QPointF &value)
             {
                 d->m_data.append(value);
-                emit changed();
+                d->emitChanged();
                 return *this;
             }
             /*!
                 Stream operator for adding a list of points to the series.
                 \sa add()
             */
             QScatterSeries& QScatterSeries::operator << (QList<QPointF> value)
             {
                 d->m_data.append(value);
-                emit changed();
+                d->emitChanged();
                 return *this;
             }
             /*!
                 Replaces the data of the series with the given list of data \a points.
             */
             void QScatterSeries::setData(QList<QPointF> points)
             {
                 d->m_data = points;
-                emit changed();
+                d->emitChanged();
             }
             /*!
                 Returns the current list of data points of the series.
             */
             QList<QPointF> QScatterSeries::data()
             {
                 return d->m_data;
             }
             /*!
                 Replaces the point at \a index with \a newPoint. Returns true if \a index is a valid position
                 in the series data, false otherwise.
             */
             bool QScatterSeries::replace(int index, QPointF newPoint)
             {
                 if (index >= 0 && index < d->m_data.count()) {
                     d->m_data.replace(index, newPoint);
-                    emit changed();
+                    d->emitChanged();
                     return true;
                 }
                 return false;
             }
             /*!
                 Remove the data point at \a index. Returns true if a point was removed, false if the point
                 at \a index does not exist on the series.
             */
             bool QScatterSeries::removeAt(int index)
             {
                 if (index >=0 && index < d->m_data.count()) {
                     d->m_data.removeAt(index);
-                    emit changed();
+                    d->emitChanged();
                     return true;
                 }
                 return false;
             }
             /*!
                 Remove all occurrences of \a point from the series and returns the number of points removed.
             */
             int QScatterSeries::removeAll(QPointF point)
             {
                 int count = d->m_data.removeAll(point);
-                emit changed();
+                d->emitChanged();
                 return count;
             }
             /*!
                 Remove all data points from the series.
             */
             void QScatterSeries::clear()
             {
                 d->m_data.clear();
-                emit changed();
+                d->emitChanged();
             }
             /*!
                 Returns the index of the data point that is closest to \a coordinate. If several data points
                 are at the same distance from the \a coordinate, returns the last one. If no points exist,
                 returns -1.
             */
             int QScatterSeries::closestPoint(QPointF coordinate)
             {
                 qreal distance(-1);
                 int pointIndex(-1);
                 for (int i(0); i < d->m_data.count(); i++) {
                     QPointF dataPoint = d->m_data.at(i);
                     QPointF difference = dataPoint - coordinate;
                     if (i == 0 || difference.manhattanLength() <= distance) {
                         distance = difference.manhattanLength();
                         pointIndex = i;
                     }
                 }
                 return pointIndex;
             }
             /*!
+                Returns the pen used for drawing markers.
+            */
+            QPen QScatterSeries::pen() const
+            {
+                return d->m_markerPen;
+            }
+            /*!
                 Overrides the default pen used for drawing a marker item with a user defined \a pen. The
                 default pen is defined by chart theme setting.
                 \sa setBrush()
                 \sa QChart::setChartTheme()
             */
-            void QScatterSeries::setPen(QPen pen)
+            void QScatterSeries::setPen(const QPen &pen)
             {
                 d->m_markerPen = pen;
+                d->emitChanged();
             }
             /*!
-                Returns the pen used for drawing markers.
+                Returns the brush used for drawing markers.
             */
-            QPen QScatterSeries::pen()
+            QBrush QScatterSeries::brush() const
             {
-                return d->m_markerPen;
+                return d->m_markerBrush;
             }
             /*!
                 Overrides the default brush of the marker items with a user defined \a brush. The default brush
                 is defined by chart theme setting.
                 \sa setPen()
                 \sa QChart::setChartTheme()
             */
-            void QScatterSeries::setBrush(QBrush brush)
+            void QScatterSeries::setBrush(const QBrush &brush)
             {
                 d->m_markerBrush = brush;
+                d->emitChanged();
             }
             /*!
-                Returns the brush used for drawing markers.
+                Returns the shape used for drawing markers.
             */
-            QBrush QScatterSeries::brush()
+            QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
-                return d->m_markerBrush;
+                return (QScatterSeries::MarkerShape) d->m_markerShape;
             }
             /*!
                 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)
             {
                 d->m_markerShape = shape;
+                d->emitChanged();
-            /*!
-                Returns the shape used for drawing markers.
-            */
-            QScatterSeries::MarkerShape QScatterSeries::shape()
-                return (QScatterSeries::MarkerShape) d->m_markerShape;
             }
             /*!
                 Returns the size of the marker items.
             */
-            qreal QScatterSeries::size()
+            qreal QScatterSeries::size() const
             {
                 return d->m_markerSize;
             }
             /*!
                 Set the \a size of the marker items. The default size is 9.0.
             */
             void QScatterSeries::setSize(qreal size)
             {
                 d->m_markerSize = size;
-                emit changed();
+                d->emitChanged();
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +9 -11

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qseries.h"
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 enum MarkerShape {
                     // TODO: to be defined by the graphics design
                     // TODO: marker shapes: "x", star, rectangle, tilted rect, triangle, circle, dot
                     MarkerShapeDefault = 0,
                     MarkerShapeX,
                     MarkerShapeRectangle,
+                    MarkerShapeRoundedRectangle,
                     MarkerShapeTiltedRectangle,
                     MarkerShapeTriangle,
                     MarkerShapeCircle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
                 void add(qreal x, qreal y);
                 void add(QPointF value);
                 void add(QList<QPointF> points);
                 void setData(QList<QPointF> points);
                 QScatterSeries& operator << (const QPointF &value);
                 QScatterSeries& operator << (QList<QPointF> points);
                 QList<QPointF> data();
                 bool replace(int index, QPointF newPoint);
                 bool removeAt(int index);
                 int removeAll(QPointF point);
                 void clear();
                 int closestPoint(QPointF coordinate);
                 //TODO: insert, replace...?
-                QPen pen();
+                QPen pen() const;
-                void setPen(QPen pen);
+                void setPen(const QPen &pen);
-                QBrush brush();
+                QBrush brush() const;
-                void setBrush(QBrush brush);
+                void setBrush(const QBrush &brush);
-                MarkerShape shape();
+                MarkerShape shape() const;
                 void setShape(MarkerShape shape);
-                qreal size();
+                qreal size() const;
                 void setSize(qreal size);
             Q_SIGNALS:
                 void clicked(QPointF coordinate);
-                // TODO: move to PIMPL for simplicity or does the user ever need changed signals?
-                // TODO: more finegrained signaling for performance reasons
-                // (check QPieSeries implementation with change sets)
-                void changed();
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
-                QScatterSeriesPrivate *const d;
+                friend class ScatterPresenter;
+                QScatterSeriesPrivate *d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterseries/scatterpresenter.cpp +16 -6

             #include "scatterpresenter_p.h"
             #include "qscatterseries.h"
+            #include "scatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPen>
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QGraphicsSceneMouseEvent>
             #include <QGraphicsDropShadowEffect>
             #include <QDebug>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterPresenter::ScatterPresenter(QScatterSeries *series, QGraphicsObject *parent) :
                 ChartItem(parent),
                 m_minX(0),
                 m_maxX(0),
                 m_minY(0),
                 m_maxY(0),
                 m_series(series),
                 m_clippingRect()
             {
-                if (parent)
+                Q_ASSERT(parent);
-                    m_clippingRect = parent->boundingRect();
+                Q_ASSERT(series);
-                if (series) {
-                    connect(series, SIGNAL(changed()), this, SLOT(handleModelChanged()));
+                m_clippingRect = parent->boundingRect();
+                connect(series->d, SIGNAL(changed()), this, SLOT(handleModelChanged()));
+                connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             void ScatterPresenter::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX = minX;
                 m_maxX = maxX;
                 m_minY = minY;
                 m_maxY = maxY;
                 changeGeometry();
             }
             void ScatterPresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_clippingRect = rect.translated(-rect.topLeft());
                 changeGeometry();
                 setPos(rect.topLeft());
             }
             void ScatterPresenter::handleModelChanged()
             {
                 // TODO: more fine grained modelChanged signaling
                 changeGeometry();
             }
             void ScatterPresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 painter->save();
                 painter->setClipRect(m_clippingRect);
                 // TODO: how to draw a drop shadow?
                 // Now using a custom implementation for drop shadow instead of QGraphicsDropShadowEffect.
                 // It seems QGraphicsDropShadowEffect is quite heavy, at least on windows without open gl.
                 QPen dropShadowPen(QColor(0, 0, 0, 70));
                 dropShadowPen.setWidth(3);
                 painter->setPen(dropShadowPen);
                 painter->setBrush(dropShadowPen.color());
             //    painter->setRenderHint(QPainter::Antialiasing);
                 painter->drawPath(m_path.translated(2, 2));
                 // Paint the shape
                 // The custom settings in series override those defined by the theme
                 QPen pen = m_markerPen;
                 if (m_series->pen().color().isValid())
                     pen = m_series->pen();
                 painter->setPen(pen);
                 if (m_series->brush().color().isValid())
                     painter->setBrush(m_series->brush());
                 else
                     painter->setBrush(m_markerBrush);
                 // If either pen or brush is opaque, we need to draw the polygons one-by-one
                 if (painter->pen().color().alpha() < 255 || painter->brush().color().alpha() < 255) {
                     foreach (QPolygonF pol, m_path.toSubpathPolygons())
                         painter->drawPolygon(pol);
                 } else {
                     painter->drawPath(m_path);
                 }
                 painter->restore();
             }
             void ScatterPresenter::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 // Empty implementation to grab mouse release events for this item
                 Q_UNUSED(event)
             }
             void ScatterPresenter::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 QPointF clickedPoint(
                     m_minX + (event->lastPos().x() / m_clippingRect.width()) * (m_maxX-m_minX),
                     m_maxY - (event->lastPos().y() / m_clippingRect.height()) * (m_maxY-m_minY));
                 emit clicked(clickedPoint);
             }
             void ScatterPresenter::changeGeometry()
             {
                 if (m_clippingRect.isValid()) {
                     prepareGeometryChange();
                     qreal scalex = m_clippingRect.width() / (m_maxX - m_minX);
                     qreal scaley = m_clippingRect.height() / (m_maxY - m_minY);
                     int shape = m_series->shape();
                     m_path = QPainterPath();
                     m_path.setFillRule(Qt::WindingFill);
                     const qreal size = m_series->size();
                     foreach (QPointF point, m_series->data()) {
                         // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
                         qreal x = point.x() * scalex - m_minX * scalex - size / 2;
                         qreal y = m_clippingRect.height() - point.y() * scaley + m_minY * scaley - size / 2;
                         if (x < scene()->width() && y < scene()->height()) {
                             switch (shape) {
                             case QScatterSeries::MarkerShapeDefault:
                                 // Fallthrough, defaults to circle
                             case QScatterSeries::MarkerShapeCircle:
                                 m_path.addEllipse(x, y, size, size);
                                 break;
                             case QScatterSeries::MarkerShapeRectangle:
                                 m_path.addRect(x, y, size, size);
                                 break;
+                            case QScatterSeries::MarkerShapeRoundedRectangle:
+                                m_path.addRoundedRect(x, y, size, size, size / 4.0, size / 4.0);
+                                break;
                             case QScatterSeries::MarkerShapeTiltedRectangle: {
                                 // TODO: tilt the rectangle
                                 m_path.addRect(x, y, size, size);
                                 break;
                             }
+                            case QScatterSeries::MarkerShapeTriangle: {
+                                QPolygonF polygon;
+                                polygon << QPointF(0.0, -size) << QPointF(size / 2.0, 0.0) << QPointF(-size / 2, 0.0);
+                                // TODO: the position is not exactly right...
+                                m_path.addPolygon(polygon.translated(x + size / 2.0, y + size));
+                                break;
+                            }
                             default:
                                 // TODO: implement the rest of the shapes
                                 Q_ASSERT(false);
                                 break;
                             }
                         }
                     }
                 }
             }
             #include "moc_scatterpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterseries_p.h +11 -2

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartglobal.h"
             #include "qseries.h"
+            #include <QObject>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
-            class QScatterSeriesPrivate
+            class QScatterSeriesPrivate : public QObject
             {
+                Q_OBJECT
             public:
-                QScatterSeriesPrivate();
+                QScatterSeriesPrivate(QObject *parent);
+                void emitChanged();
+            Q_SIGNALS:
+                // TODO: more finegrained signaling for performance reasons
+                // (see for example QPieSeries implementation with change sets)
+                void changed();
             public:
                 QList<QPointF> m_data;
                 QPen m_markerPen;
                 QBrush m_markerBrush;
                 int m_markerShape;
                 qreal m_markerSize;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIESPRIVATE_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