HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r394:9882bdf19567

Clicked, remove and clear to QScatterSeries

Tero Ahola -

r394:9882bdf19567

parent child

Context file:

r394:9882bdf19567

Collapse all files

example/scatterinteractions/main.cpp created 644 +11 0

@@ -0,0 +1,11
	1	#include <QtGui/QApplication>
	2	#include "mainwindow.h"
	3
	4	int main(int argc, char *argv[])
	5	{
	6	QApplication a(argc, argv);
	7	MainWindow w;
	8	w.show();
	9
	10	return a.exec();
	11	}

example/scatterinteractions/mainwindow.cpp created 644 +51 0

@@ -0,0 +1,51
	1	#include "mainwindow.h"
	2	#include <qchartglobal.h>
	3	#include <qchartview.h>
	4	#include <QDebug>
	5
	6	QTCOMMERCIALCHART_USE_NAMESPACE
	7
	8	MainWindow::MainWindow(QWidget *parent)
	9	: QMainWindow(parent)
	10	{
	11	resize(400, 300);
	12	setWindowFlags(Qt::FramelessWindowHint);
	13
	14	QChartView *chartView = new QChartView(this);
	15	chartView->setChartTitle("Click to play with points");
	16	chartView->setRenderHint(QPainter::Antialiasing);
	17	setCentralWidget(chartView);
	18
	19	m_scatter = new QScatterSeries();
	20	for(qreal x(0.5); x <= 5.0; x += 0.5) {
	21	for(qreal y(0.5); y <= 5.0; y += 0.5) {
	22	*m_scatter << QPointF(x, y);
	23	}
	24	}
	25	chartView->addSeries(m_scatter);
	26
	27	// Add two more series
	28	m_scatter2 = new QScatterSeries();
	29	chartView->addSeries(m_scatter2);
	30	m_scatter3 = new QScatterSeries();
	31	chartView->addSeries(m_scatter3);
	32
	33	connect(m_scatter, SIGNAL(clicked(QPointF)), this, SLOT(clickPoint(QPointF)));
	34	}
	35
	36	MainWindow::~MainWindow()
	37	{
	38	}
	39
	40	void MainWindow::clickPoint(QPointF coordinate)
	41	{
	42	// Remove the clicked point from the series and add points to the two other series we have
	43	int index = m_scatter->closestPoint(coordinate);
	44	QPointF point = m_scatter->data().at(index);
	45	Q_ASSERT(m_scatter->removeAt(index));
	46	point.rx() += 0.25;
	47	point.ry() += 0.25;
	48	*m_scatter2 << point;
	49	point.ry() -= 0.25;
	50	*m_scatter3 << point;
	51	}

example/scatterinteractions/mainwindow.h created 644 +27 0

@@ -0,0 +1,27
	1	#ifndef MAINWINDOW_H
	2	#define MAINWINDOW_H
	3
	4	#include <QtGui/QMainWindow>
	5	#include <qchartglobal.h>
	6	#include <qscatterseries.h>
	7
	8	QTCOMMERCIALCHART_USE_NAMESPACE
	9
	10	class MainWindow : public QMainWindow
	11	{
	12	Q_OBJECT
	13
	14	public:
	15	MainWindow(QWidget *parent = 0);
	16	~MainWindow();
	17
	18	private Q_SLOTS:
	19	void clickPoint(QPointF coordinate);
	20
	21	private:
	22	QScatterSeries *m_scatter;
	23	QScatterSeries *m_scatter2;
	24	QScatterSeries *m_scatter3;
	25	};
	26
	27	#endif // MAINWINDOW_H

example/scatterinteractions/scatterinteractions.pro created 644 +12 0

@@ -0,0 +1,12
	1	!include( ../example.pri ) {
	2	error( "Couldn't find the example.pri file!" )
	3	}
	4	QT += core gui
	5
	6	TARGET = scatterinteractions
	7	TEMPLATE = app
	8
	9	SOURCES += main.cpp\
	10	mainwindow.cpp
	11
	12	HEADERS += mainwindow.h

example/example.pro +2 -1

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
-                       chartview
+                       chartview \
+                       scatterinteractions

example/scatter/main.cpp +3 -8

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qscatterseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 //! [1]
                 // Create chart view
                 QChartView *chartView = new QChartView();
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 // Add scatter series with simple test data
                 QScatterSeries *scatter = new QScatterSeries();
-                *scatter << QPointF(0.5, 5.0)
+                *scatter << QPointF(0.5, 5.0) << QPointF(1.0, 4.5) << QPointF(1.0, 5.5) << QPointF(1.5, 5.0);
-                         << QPointF(1.0, 4.5)
-                         << QPointF(1.0, 5.5)
-                         << QPointF(1.5, 5.0)
-                         << QPointF(2.0, 4.5)
-                         << QPointF(2.5, 5.0);
                 // Chart takes ownership
                 chartView->addSeries(scatter);
                 //! [1]
                 // And more
                 //! [3]
                 *scatter << QPointF(2.0, 5.5) << QPointF(2.2, 5.4);
                 //! [3]
                 // Add another scatter series (re-use the previous pointer)
                 // - more data with random component
                 scatter = new QScatterSeries();
                 for (qreal i(0.0); i < 20; i += 0.15) {
                     (*scatter) << QPointF(i + (qreal)(rand() % 100) / 100.0,
                                            i + (qreal)(rand() % 100) / 100.0);
                 }
                 //! [4]
                 QBrush brush(QColor(255, 0, 0, 100), Qt::SolidPattern);
                 scatter->setBrush(brush);
                 //! [4]
                 //! [5]
                 QPen pen(QColor(0, 255, 0, 80), 3);
                 scatter->setPen(pen);
                 //! [5]
                 //! [6]
                 scatter->setShape(QScatterSeries::MarkerShapeRectangle);
                 //! [6]
                 chartView->addSeries(scatter);
                 // Use the chart widget as the central widget
                 QMainWindow w;
-                w.resize(640, 480);
+                w.resize(400, 300);
                 w.setCentralWidget(chartView);
+                w.setWindowFlags(Qt::FramelessWindowHint);
                 w.show();
                 return a.exec();
             }

example/scatter/scatter.pro +1 -4

             !include( ../example.pri ) {
-             error( "Couldn't find the example.pri file!" )
+                error( "Couldn't find the example.pri file!" )
             }
             TARGET = scatter
             SOURCES += main.cpp

src/chartpresenter.cpp +2 -1

             #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 "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(0)
             {
             	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*)),this,SLOT(handleSeriesAdded(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 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)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 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)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         LineChartItem* item;
                         if(m_options.testFlag(QChart::SeriesAnimations)){
                             item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         }else{
                             item = new LineChartItem(this,lineSeries,m_chart);
                         }
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
                         QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
                         QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
                         QObject::connect(lineSeries,SIGNAL(updated()),item,SLOT(handleUpdated()));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         item->handleUpdated();
                         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()), scatterSeries, SIGNAL(clicked()));
+                        QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
+                                         scatterSeries, SIGNAL(clicked(QPointF)));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
                         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;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
             }
             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);
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.cpp +57 -2

             #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
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeDefault
                 \value MarkerShapePoint
                 \value MarkerShapeX
                 \value MarkerShapeRectangle
                 \value MarkerShapeTiltedRectangle
                 \value MarkerShapeTriangle
                 \value MarkerShapeCircle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
             */
             /*!
-                \fn void QScatterSeries::clicked()
+                \fn void QScatterSeries::clicked(QPointF coordinate)
-                \brief TODO
+                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() :
                 m_data(QList<QPointF>()),
                 m_markerPen(QPen(QColor::Invalid)),
                 m_markerBrush(QBrush(QColor::Invalid)),
                 m_markerShape(QScatterSeries::MarkerShapeDefault)
             {
             }
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QSeries(parent),
                 d(new QScatterSeriesPrivate())
             {
             }
             /*!
                 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();
             }
             /*!
                 Add single data point with \a value to the series.
             */
             void QScatterSeries::add(QPointF value)
             {
                 d->m_data.append(value);
                 emit changed();
             }
             /*!
                 Add list of \a points to the series.
             */
             void QScatterSeries::add(QList<QPointF> points)
             {
                 d->m_data.append(points);
                 emit changed();
             }
             /*!
                 Stream operator for adding a data point with \a value to the series.
                 \sa add()
                 For example:
                 \snippet ../example/scatter/main.cpp 3
             */
             QScatterSeries& QScatterSeries::operator << (const QPointF &value)
             {
                 d->m_data.append(value);
                 emit changed();
                 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();
                 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();
             }
             /*!
                 Returns the current list of data points of the series.
             */
             QList<QPointF> QScatterSeries::data()
             {
                 return d->m_data;
             }
             /*!
+                Remove the data point at \a pointIndex. Returns true if a point was removed, false if the point
+                at \a pointIndex does not exist on the series.
+            */
+            bool QScatterSeries::removeAt(int pointIndex)
+            {
+                if (pointIndex >=0 && pointIndex < d->m_data.count()) {
+                    d->m_data.removeAt(pointIndex);
+                    emit changed();
+                    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();
+                return count;
+            }
+            /*!
+                Remove all data points from the series.
+            */
+            void QScatterSeries::clear()
+            {
+                d->m_data.clear();
+                emit changed();
+            }
+            /*!
+                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;
+            }
+            /*!
                 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.
                 For example:
                 \snippet ../example/scatter/main.cpp 5
                 Would present your scatter markers with an opaque, uglyish green outlines instead of the
                 beatiful markers defined by the chart's theme:
                 \image scatter_example_pen.jpg
                 \sa setBrush()
                 \sa QChart::setChartTheme()
             */
             void QScatterSeries::setPen(QPen pen)
             {
                 d->m_markerPen = pen;
             }
             /*!
                 Returns the pen used for drawing markers.
             */
             QPen QScatterSeries::pen()
             {
                 return d->m_markerPen;
             }
             /*!
                 Overrides the default brush of the marker items with a user defined \a brush. The default brush
                 is defined by chart theme setting.
                 For example:
                 \snippet ../example/scatter/main.cpp 4
                 Would fill your scatter markers with an opaque red color:
                 \image scatter_example_brush.jpg
                 \sa setPen()
                 \sa QChart::setChartTheme()
             */
             void QScatterSeries::setBrush(QBrush brush)
             {
                 d->m_markerBrush = brush;
             }
             /*!
                 Returns the brush used for drawing markers.
             */
             QBrush QScatterSeries::brush()
             {
                 return d->m_markerBrush;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
                 For example:
                 \snippet ../example/scatter/main.cpp 6
                 Would make your scatter marker items rectangle:
                 \image scatter_example_shape.jpg
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
                 d->m_markerShape = shape;
             }
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape()
             {
                 return (QScatterSeries::MarkerShape) d->m_markerShape;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +6 -2

             #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,
                     MarkerShapePoint,
                     MarkerShapeX,
                     MarkerShapeRectangle,
                     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();
-                //TODO: insert, replace, remove, clear...?
+                bool removeAt(int pointIndex);
+                int removeAll(QPointF point);
+                void clear();
+                int closestPoint(QPointF coordinate);
+                //TODO: insert, replace...?
                 QPen pen();
                 void setPen(QPen pen);
                 QBrush brush();
                 void setBrush(QBrush brush);
                 MarkerShape shape();
                 void setShape(MarkerShape shape);
                 // TODO: marker size?
             Q_SIGNALS:
-                void clicked(/* TODO: parameters? */);
+                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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterseries/scatterpresenter.cpp +18 -11

             #include "scatterpresenter_p.h"
             #include "qscatterseries.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_series(series),
                 m_boundingRect(),
                 m_visibleChartArea()
             {
                 if (parent)
                     m_boundingRect = parent->boundingRect();
                 if (series) {
                     connect(series, SIGNAL(changed()), this, SLOT(handleModelChanged()));
                 }
                 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(const Domain& domain)
             {
                 m_visibleChartArea = domain;
                 changeGeometry();
             }
             void ScatterPresenter::handleGeometryChanged(const QRectF& rect)
             {
-                m_boundingRect = rect;
+                m_boundingRect = 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_boundingRect);
                 // 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)
             {
-                qDebug() << "ScatterPresenter::mousePressEvent" << event << " cont: "
+                // Empty implementation to grab mouse release events for this item
-                    << m_path.contains(event->lastPos());
+                Q_UNUSED(event)
+            }
-                if (m_path.contains(event->lastPos()))
+            void ScatterPresenter::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
-                    emit clicked();
+                QPointF clickedPoint(
+                    m_visibleChartArea.m_minX + (event->lastPos().x() / m_boundingRect.width()) * m_visibleChartArea.spanX(),
+                    m_visibleChartArea.m_maxY - (event->lastPos().y() / m_boundingRect.height()) * m_visibleChartArea.spanY());
+                emit clicked(clickedPoint);
             }
             void ScatterPresenter::changeGeometry()
             {
                 if (m_boundingRect.isValid()) {
                     prepareGeometryChange();
                     qreal scalex = m_boundingRect.width() / m_visibleChartArea.spanX();
                     qreal scaley = m_boundingRect.height() / m_visibleChartArea.spanY();
                     int shape = m_series->shape();
                     m_path = QPainterPath();
                     m_path.setFillRule(Qt::WindingFill);
+                    const qreal size(9); // TODO: user defined size?
                     foreach (QPointF point, m_series->data()) {
                         // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
-                        qreal x = m_boundingRect.left() + point.x() * scalex - m_visibleChartArea.m_minX * scalex;
+                        qreal x = point.x() * scalex - m_visibleChartArea.m_minX * scalex - size / 2;
-                        qreal y = m_boundingRect.bottom() - point.y() * scaley + m_visibleChartArea.m_minY * scaley;
+                        qreal y = m_boundingRect.height() - point.y() * scaley + m_visibleChartArea.m_minY * scaley - size / 2;
-                        if (scene()->width() > x && scene()->height() > y) {
+                        if (x < scene()->width() && y < scene()->height()) {
                             switch (shape) {
                             case QScatterSeries::MarkerShapeDefault:
                                 // Fallthrough, defaults to circle
                             case QScatterSeries::MarkerShapeCircle:
-                                m_path.addEllipse(x, y, 9, 9);
+                                m_path.addEllipse(x, y, size, size);
                                 break;
                             case QScatterSeries::MarkerShapePoint:
                                 m_path.addEllipse(x, y, 2, 2);
                                 break;
                             case QScatterSeries::MarkerShapeRectangle:
-                                m_path.addRect(x, y, 9, 9);
+                                m_path.addRect(x, y, size, size);
                                 break;
                             case QScatterSeries::MarkerShapeTiltedRectangle: {
                                 // TODO: tilt the rectangle
-                                m_path.addRect(x, y, 9, 9);
+                                m_path.addRect(x, y, size, size);
                                 break;
                             }
                             default:
                                 // TODO: implement the rest of the shapes
                                 Q_ASSERT(false);
                                 break;
                             }
                         }
                     }
                 }
             }
             #include "moc_scatterpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterpresenter_p.h +3 -6

             #ifndef SCATTERPRESENTER_H
             #define SCATTERPRESENTER_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QObject>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
-            /*!
-             * The "business logic" of scatter series. This is a QObject that does not have a parent QObject.
-             * The QGraphicsItem parent owns the object instead.
-             */
             class ScatterPresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterPresenter(QScatterSeries *series, QGraphicsObject *parent = 0);
             public: // from ChartItem
-                QRectF boundingRect() const { return m_path.boundingRect(); }
+                QRectF boundingRect() const { return m_path.controlPointRect(); }
                 QPainterPath shape() const { return m_path; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
                 void mousePressEvent (QGraphicsSceneMouseEvent * event);
+                void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
-                void clicked();
+                void clicked(QPointF coordinates);
             public Q_SLOTS:
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
                 void handleModelChanged();
             public:
                 void changeGeometry();
                 QScatterSeries *m_series;
                 QRectF m_boundingRect;
                 Domain m_visibleChartArea;
                 QPen m_markerPen;
                 QBrush m_markerBrush;
                 QPainterPath m_path;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_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