HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r541:4eee071cd5a1

Adds missing scatter intercation implementation...

Michal Klocek -

r541:4eee071cd5a1

parent child

Context file:

r541:4eee071cd5a1

Collapse all files

examples/scatterinteractions/mainwindow.cpp +8 -21

             #include "mainwindow.h"
             #include <qchartglobal.h>
             #include <qchartview.h>
+            #include <qchartaxis.h>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWindow::MainWindow(QWidget *parent)
                 : QMainWindow(parent)
             {
                 QChartView *chartView = new QChartView(this);
-                chartView->setChartTitle("Click to play with points");
+                chartView->setChartTitle("Click to remove scatter point");
                 chartView->setRenderHint(QPainter::Antialiasing);
                 setCentralWidget(chartView);
                 m_scatter = new QScatterSeries();
                 for(qreal x(0.5); x <= 4.0; x += 0.5) {
                     for(qreal y(0.5); y <= 4.0; y += 0.5) {
                         *m_scatter << QPointF(x, y);
                     }
                 }
-                chartView->addSeries(m_scatter);
-                // Add two more series
+                chartView->addSeries(m_scatter);
-                m_scatter2 = new QScatterSeries();
+                chartView->axisX()->setRange(0,4.5);
-                chartView->addSeries(m_scatter2);
+                chartView->axisY()->setRange(0,4.5);
-                m_scatter3 = new QScatterSeries();
-                chartView->addSeries(m_scatter3);
-                connect(m_scatter, SIGNAL(clicked(QPointF)), this, SLOT(clickPoint(QPointF)));
+                connect(m_scatter, SIGNAL(clicked(const QPointF&)), this, SLOT(handleClickedPoint(const QPointF&)));
             }
             MainWindow::~MainWindow()
             {
             }
-            void MainWindow::clickPoint(QPointF coordinate)
+            void MainWindow::handleClickedPoint(const QPointF& point)
             {
-                // Remove the clicked point from the series and add points to the two other series we have
+                m_scatter->remove(point);
-                //TODO: fix me
-                /*
-                int index = m_scatter->closestPoint(coordinate);
-                QPointF point = m_scatter->data().at(index);
-                Q_ASSERT(m_scatter->removeAt(index));
-                point.rx() += 0.25;
-                point.ry() += 0.25;
-                *m_scatter2 << point;
-                point.ry() -= 0.25;
-                *m_scatter3 << point;
-                */
             }

examples/scatterinteractions/mainwindow.h +1 -1

             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QtGui/QMainWindow>
             #include <qchartglobal.h>
             #include <qscatterseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 MainWindow(QWidget *parent = 0);
                 ~MainWindow();
             private Q_SLOTS:
-                void clickPoint(QPointF coordinate);
+                void handleClickedPoint(const QPointF& point);
             private:
                 QScatterSeries *m_scatter;
                 QScatterSeries *m_scatter2;
                 QScatterSeries *m_scatter3;
             };
             #endif // MAINWINDOW_H

src/charttheme.cpp +12 -6

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piepresenter_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 chart->setChartBackgroundBrush(m_backgroundGradient);
             }
             void ChartTheme::decorate(QLegend* legend)
             {
                 legend->setBackgroundBrush(m_backgroundGradient);
             }
             void ChartTheme::decorate(AreaChartItem* item, QAreaSeries* series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen != series->pen()){
                    item->setPen(series->pen());
                 } else {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     item->setPen(pen);
                 }
                 if (brush != series->brush()) {
                    item->setBrush(series->brush());
                 } else {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    item->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int index)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setLinePen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                 pen.setWidthF(2);
                 item->setLinePen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     // Pick label color as far as possible from bar color (within gradient).
                     // 0.3 is magic number that was picked as value that gave enough contrast with icy theme gradient :)
                     // TODO: better picking of label color?
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(ScatterChartItem* item, QScatterSeries* series, int index)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
-                // Use a base color for brush
+                QPen pen;
-                item->setBrush(m_seriesColors.at(index % m_seriesColors.size()));
+                QBrush brush;
-                // Take pen near from gradient start, effectively using a lighter color for outline
+                if (pen == series->pen()) {
-                QPen pen(QBrush(Qt::SolidPattern), 3);
+                    pen.setColor(colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 1.0));
-                pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
+                    pen.setWidthF(2);
-                item->setPen(pen);
+                    series->setPen(pen);
+                }
+                if (brush == series->brush()) {
+                    QBrush brush(m_seriesColors.at(count % m_seriesColors.size()));
+                    series->setBrush(brush);
+                }
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int index)
             {
                 // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                 for (int i(0); i < series->slices().count(); i++) {
                     qreal pos = (qreal) i / (qreal) series->count();
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.1);
                     series->slices().at(i)->setSlicePen(penColor);
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     series->slices().at(i)->setSliceBrush(brushColor);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis, AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             void ChartTheme::decorate(SplineChartItem* item, QSplineSeries* series, int index)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 QPen pen;
                 if(pen != series->pen()){
                     item->setLinePen(series->pen());
                 }else{
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(series->pen().widthF());
                     item->setLinePen(series->pen());
                 }
             //    QColor color = m_seriesColors.at(index % m_seriesColors.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
             //    QBrush brush(color, Qt::SolidPattern);
             //    presenter->m_markerBrush = brush;
             //    QPen pen(brush, 3);
             //    pen.setColor(color);
             //    presenter->m_markerPen = pen;
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (QColor color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.05, 0.95);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.cpp +2 -7

             #include "qscatterseries.h"
             #include "qchart.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 scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->add(0, 6);
                 series->add(2, 4);
                 ...
                 chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \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
+                \value MarkerShapeRectangle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QScatterSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on scatter chart.
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QXYSeries(parent),
-                m_shape(QScatterSeries::MarkerShapeDefault),
+                m_shape(QScatterSeries::MarkerShapeCircle),
                 m_size(9.0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
             }
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
                 return (QScatterSeries::MarkerShape) 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)
             {
                 m_shape = shape;
                 emit updated();
             }
             /*!
                 Returns the size of the marker items.
             */
             qreal QScatterSeries::size() const
             {
                 return m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 9.0.
             */
             void QScatterSeries::setSize(qreal size)
             {
                 m_size = size;
                 emit updated();
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +2 -9

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qchartglobal.h"
             #include "qxyseries.h"
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
                 Q_OBJECT
             public:
                 enum MarkerShape {
-                    // TODO: to be defined by the graphics design
+                    MarkerShapeCircle,
-                    // TODO: marker shapes: "x", star, rectangle, tilted rect, triangle, circle, dot
+                    MarkerShapeRectangle
-                    MarkerShapeDefault = 0,
-                    MarkerShapeX,
-                    MarkerShapeRectangle,
-                    MarkerShapeRoundedRectangle,
-                    MarkerShapeTiltedRectangle,
-                    MarkerShapeTriangle,
-                    MarkerShapeCircle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
                 MarkerShape shape() const;
                 void setShape(MarkerShape shape);
                 qreal size() const;
                 void setSize(qreal size);
             signals:
                 void clicked(const QPointF& point);
             private:
                 MarkerShape m_shape;
                 qreal m_size;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterseries/scatterchartitem.cpp +24 -32

             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent) :
                 XYChartItem(series,parent),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(10)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
-                connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
+                QObject::connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
+                QObject::connect(this,SIGNAL(clicked(const QPointF&)), m_series, SIGNAL(clicked(const QPointF&)));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
                 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;
                     switch (m_shape) {
-                               case QScatterSeries::MarkerShapeDefault:
+                               case QScatterSeries::MarkerShapeCircle:{
-                               // Fallthrough, defaults to circle
+                                   QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
-                               case QScatterSeries::MarkerShapeCircle:
+                                   const QRectF& rect = i->boundingRect();
-                                   item = new QGraphicsEllipseItem(0,0,m_size,m_size);
+                                   i->setPos(-rect.width()/2,-rect.height()/2);
-                                   break;
+                                   item = new Marker(i,this);
-                               case QScatterSeries::MarkerShapeRectangle:
-                                   item = new QGraphicsRectItem(0,0,m_size,m_size);
                                    break;
-                               case QScatterSeries::MarkerShapeRoundedRectangle:
-                                   //m_path.addRoundedRect(x, y, size, size, size / 4.0, size / 4.0);
+                               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;
-                               case QScatterSeries::MarkerShapeTiltedRectangle:
-                                   // TODO: tilt the rectangle
+                               default:
-                                   //m_path.addRect(x, y, size, size);
+                                   qWarning()<<"Unsupported marker type";
-                                   //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;
                     }
                     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)
-            void ScatterChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
+                emit clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
-                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 ScatterChartItem::setGeometry(QVector<QPointF>& points)
             {
                 if(points.size()==0) return;
                 int diff = XYChartItem::points().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++) {
-                    QGraphicsItem* item = items.at(i);
+                    Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
+                    item->setIndex(i);
                     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();
                 XYChartItem::setGeometry(points);
             }
             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<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
+                       static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
-                        static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
+                        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();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h +72 -1

             #ifndef SCATTERPRESENTER_H
             #define SCATTERPRESENTER_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
+            class Marker;
             class ScatterChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent = 0);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen& pen);
                 void setBrush(const QBrush& brush);
+                void markerSelected(Marker* item);
             signals:
-                void clicked(QPointF coordinates);
+                void clicked(const QPointF& point);
             public slots:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 virtual void setGeometry(QVector<QPointF>& points);
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
             };
+            class Marker: public QAbstractGraphicsShapeItem
+            {
+            public:
+               Marker(QAbstractGraphicsShapeItem* item , ScatterChartItem* parent):QAbstractGraphicsShapeItem(0),m_item(item),m_parent(parent)
+               {
+               };
+               ~Marker()
+               {
+                   delete m_item;
+               }
+               void setIndex(int index)
+               {
+                   m_index=index;
+               }
+               int index() const
+               {
+                   return m_index;
+               }
+               QPainterPath shape() const
+               {
+                   return m_item->shape();
+               }
+               QRectF boundingRect() const
+               {
+                   return m_item->boundingRect();
+               }
+               bool contains(const QPointF &point) const
+               {
+                   return m_item->contains(point);
+               }
+               void setPen(const QPen& pen)
+               {
+                   m_item->setPen(pen);
+               }
+               void setBrush(const QBrush& brush)
+               {
+                   m_item->setBrush(brush);
+               }
+               void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+               {
+                   m_item->paint(painter,option,widget);
+               }
+            protected:
+               void mousePressEvent( QGraphicsSceneMouseEvent * event )
+               {
+                   m_parent->markerSelected(this);
+               }
+            private:
+               QAbstractGraphicsShapeItem* m_item;
+               ScatterChartItem* m_parent;
+               int m_index;
+            };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/xychart/qxyseries.cpp +9 -4

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
             {
                 m_model = NULL;
                 m_mapX = -1;
                 m_mapY = -1;
                 m_mapOrientation = Qt::Vertical;
             //    m_mapYOrientation = Qt::Vertical;
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QPointF& point)
             {
                 add(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     add(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF& point)
             {
                 replace(point.x(),point.y());
             }
             /*!
-              Removes current \a x and y value.
+              Removes current \a x and \a y value.
             */
-            void QXYSeries::remove(qreal x)
+            void QXYSeries::remove(qreal x,qreal y)
             {
-                int index = m_x.indexOf(x);
+                int index =-1;
+                do{
+                    index = m_x.indexOf(x,index+1);
+                }while(index !=-1 && m_y.at(index)!=y);
+                if(index==-1) return;
                 emit pointRemoved(index);
                 m_x.remove(index);
                 m_y.remove(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
-                remove(point.x());
+                remove(point.x(),point.y());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapX, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapY, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // data is in a column, so return the number of items in single column
                         return m_model->rowCount();
                     else
                         // data is in a row, so return the number of items in single row
                         m_model->columnCount();
                 else
                     // model is not specified, return the number of points in the series internal data store
                     return m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 QList<QPointF> data;
                 for (int i(0); i < m_x.count() && i < m_y.count(); i++)
                     data.append(QPointF(m_x.at(i), m_y.at(i)));
                 return data;
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
                     m_pen=pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setBrush(const QBrush& brush)
             {
                 if(brush!=m_brush){
                     m_brush=brush;
                     emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 add(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 add(points);
                 return *this;
             }
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 emit pointReplaced(topLeft.row());
             }
             bool QXYSeries::setModel(QAbstractItemModel* model) {
                 m_model = model;
                 //    for (int i = 0; i < m_model->rowCount(); i++)
                 //        emit pointAdded(i);
                 connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                 //        connect(m_model,SIGNAL(), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
             }
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 m_mapX = modelX;
                 m_mapY = modelY;
                 m_mapOrientation = orientation;
             }
             //void QXYSeries::setModelMappingY(int modelLineIndex, Qt::Orientation orientation)
             //{
             //    m_mapY = modelLineIndex;
             //    m_mapYOrientation = orientation;
             //}
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +1 -1

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
                 Q_OBJECT
             protected:
                 QXYSeries(QObject* parent=0);
                 virtual ~QXYSeries();
             public:
                 void add(qreal x, qreal y);
                 void add(const QPointF& point);
                 void add(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF& point);
-                void remove(qreal x);
+                void remove(qreal x, qreal y);
                 void remove(const QPointF& point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen& pen);
                 QPen pen() const {return m_pen;}
                 void setBrush(const QBrush& pen);
                 QBrush brush() const {return m_brush;}
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* model() {return m_model;}
                 void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingY(int modelLineIndex, Qt::Orientation orientation = Qt::Vertical);
                 private slots:
                     void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
             signals:
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 QAbstractItemModel* m_model;
                 int m_mapX;
                 Qt::Orientation m_mapOrientation;
                 int m_mapY;
             //    Qt::Orientation m_mapYOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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