HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r571:0bb609016fcc

Refactors click signal to line,area,spline,scatter charts

Michal Klocek -

r571:0bb609016fcc

parent child

Context file:

r571:0bb609016fcc

Collapse all files

examples/presenterchart/chartview.cpp +10 0

             #include "chartview.h"
             #include <qlineseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qareaseries.h>
             #include <QTime>
             ChartView::ChartView(QWidget* parent):QChartView(parent),
             m_index(0)
             {
                 QTime now = QTime::currentTime();
                 qsrand((uint)now.msec());
                 setChartTitle("Three random line charts");
                 QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(handleTimeout()));
                 m_timer.setInterval(3000);
             //![1]
                 QLineSeries* series0 = new QLineSeries(this);
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QScatterSeries* series1 = new QScatterSeries(this);
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 series1->setBrush(Qt::white);
                 QSplineSeries* series2 = new QSplineSeries(this);
                 QPen green(Qt::green);
                 green.setWidth(3);
                 series2->setPen(green);
                 QAreaSeries* series3 = new QAreaSeries(series0);
                 QPen yellow(Qt::black);
                 yellow.setWidth(3);
                 series3->setPen(yellow);
                 series3->setBrush(Qt::yellow);
             //![1]
             //![2]
                 int numPoints = 10;
                 for (int x = 0; x <= numPoints; ++x) {
                     qreal y = qrand() % 100;
                     series0->add(x,y);
                     series1->add(x,y);
                     series2->add(x,y);
                 }
             //![2]
             //![3]
                 m_series<<series0;
                 m_titles<<chartTitle()+": LineChart";
                 m_series<<series1;
                 m_titles<<chartTitle()+": ScatterChart";
                 m_series<<series2;
                 m_titles<<chartTitle()+": SplineChart";
                 m_series<<series3;
                 m_titles<<chartTitle()+": AreaChart";
             //![3]
                 addSeries(series0);
                 setChartTitle(m_titles.at(0));
+                foreach (QSeries* series, m_series) {
+                    QObject::connect(series,SIGNAL(clicked(const QPointF&)),this,SLOT(handlePointClicked(const QPointF&)));
+                }
                 m_timer.start();
             }
             ChartView::~ChartView()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 qDeleteAll(m_series);
             }
             //![4]
             void ChartView::handleTimeout()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 m_index++;
                 m_index=m_index%m_series.size();
                 addSeries(m_series.at(m_index));
                 setChartTitle(m_titles.at(m_index));
             }
             //![4]
+            void ChartView::handlePointClicked(const QPointF& point)
+            {
+                setChartTitle(m_titles.at(m_index) + QString(" x: %1 y: %2").arg(point.x()).arg(point.y()));
+            }

examples/presenterchart/chartview.h +1 0

             #ifndef CHARTVIEW_H_
             #define CHARTVIEW_H_
             #include <qchartview.h>
             #include <QTimer>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //![1]
             class ChartView: public QChartView
             {
                 Q_OBJECT
             public:
                 ChartView(QWidget* parent=0);
                 virtual ~ChartView();
             public slots:
                 void handleTimeout();
+                void handlePointClicked(const QPointF& point);
             private:
                 QTimer m_timer;
                 QList<QSeries*> m_series;
                 QStringList m_titles;
                 int m_index;
             };
             //![1]
             #endif /* CHARTVIEW_H_ */

src/areachart/areachartitem.cpp +7 0

             #include "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
+            #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,QGraphicsItem *parent):ChartItem(parent),
             m_series(areaSeries),
             m_upper(0),
             m_lower(0),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries());
                 if(m_series->lowerSeries()){
                 m_lower = new AreaBoundItem(this,m_series->lowerSeries());
                 }
                 QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
+                QObject::connect(this,SIGNAL(clicked(const QPointF&)),areaSeries,SIGNAL(clicked(const QPointF&)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             };
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path.connectPath(m_upper->shape());
                 if(m_lower){
                 path.connectPath(m_lower->shape().toReversed());
                 }
                 else{
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path=path;
                 m_rect=path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             void AreaChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_upper->handleDomainChanged(minX,maxX,minY,maxY);
                 if(m_lower)
                 m_lower->handleDomainChanged(minX,maxX,minY,maxY);
             }
             void AreaChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if(m_lower)
                 m_lower->handleGeometryChanged(rect);
             }
             //painter
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->points());
                        if(m_lower)  painter->drawPoints(m_lower->points());
                 }
                 painter->restore();
             }
+            void AreaChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
+            {
+                emit clicked(m_upper->calculateDomainPoint(event->pos()));
+            }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem_p.h +7 0

             #ifndef AREACHARTITEM_H
             #define AREACHARTITEM_H
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaSeries;
             class AreaChartItem;
             class AreaChartItem :  public QObject ,public ChartItem
             {
                 Q_OBJECT
             public:
                 AreaChartItem(QAreaSeries* areaSeries, QGraphicsItem *parent = 0);
                 ~ AreaChartItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 LineChartItem* upperLineItem() const { return m_upper ;}
                 LineChartItem* lowerLineItem() const { return m_lower ;}
                 void updatePath();
+            protected:
+                void mousePressEvent( QGraphicsSceneMouseEvent * event );
+            signals:
+                void clicked(const QPointF& point);
             public slots:
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 QAreaSeries* m_series;
                 LineChartItem* m_upper;
                 LineChartItem* m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 QBrush m_brush;
                 bool m_pointsVisible;
             };
             class AreaBoundItem : public LineChartItem
             {
             public:
                 AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries):LineChartItem(lineSeries),
                 m_item(item){};
                 ~AreaBoundItem(){};
                 void setLayout(QVector<QPointF>& points){
                     LineChartItem::setLayout(points);
                     m_item->updatePath();
                 }
             private:
                 AreaChartItem* m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/areachart/qareaseries.cpp +12 -3

             #include "qareaseries.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
             	\image areachart.png
             	Creating basic area chart is simple:
             	\code
             	QLineSeries* lineSeries = new QLineSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	QAreaSeries* areaSeries = new QAreaSeries(lineSeries);
             	...
             	chartView->addSeries(areaSeries);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QAreaSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn QLineSeries* QAreaSeries::upperSeries() const
                \brief Returns upperSeries used to define one of area boundaries.
             */
             /*!
                \fn QLineSeries* QAreaSeries::lowerSeries() const
                \brief Returns lowerSeries used to define one of area boundaries. Note if QAreaSeries where counstucted wihtout a\ lowerSeries
                 this function return Null pointer.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                \fn bool  QAreaSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QAreaSeries::QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries):QSeries(upperSeries),
             m_upperSeries(upperSeries),
             m_lowerSeries(lowerSeries),
             m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen& pen)
             {
-                m_pen=pen;
+                if(m_pen!=pen){
+                    m_pen=pen;
+                    emit updated();
+                }
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush& brush)
             {
-                m_brush=brush;
+                if(m_brush!=brush){
+                    m_brush=brush;
+                    emit updated();
+                }
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
-                m_pointsVisible=visible;
+                if(m_pointsVisible!=visible){
+                    m_pointsVisible=visible;
+                    emit updated();
+                }
             }
             #include "moc_qareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.h +1 0

             #ifndef QAREASERIES_H_
             #define QAREASERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries=0);
                 virtual ~QAreaSeries();
             public: // from QChartSeries
                 virtual QSeriesType type() const { return QSeries::SeriesTypeArea;}
                 QLineSeries* upperSeries() const { return m_upperSeries;}
                 QLineSeries* lowerSeries() const { return m_lowerSeries;}
                 void setPen(const QPen& pen);
                 QPen pen() const { return m_pen;}
                 void setBrush(const QBrush& brush);
                 QBrush brush() const { return m_brush;}
                 void setPointsVisible(bool visible);
                 bool pointsVisible() const {return m_pointsVisible;}
             signals:
                 void updated();
+                void clicked(const QPointF& point);
             private:
                 QBrush m_brush;
                 QPen m_pen;
                 QLineSeries* m_upperSeries;
                 QLineSeries* m_lowerSeries;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/linechartitem.cpp 0 -7

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
-            #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):XYChartItem(series,parent),
             m_series(series),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
-                QObject::connect(this,SIGNAL(clicked(const QPointF&)),series,SIGNAL(clicked(const QPointF&)));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 QList<QGraphicsItem*> items = m_items.childItems();
                 QPainterPath linePath(points.at(0));
                 for(int i=1; i< points.size();i++) {
                     linePath.lineTo(points.at(i));
                 }
                 prepareGeometryChange();
                 m_path = linePath;
                 m_rect = linePath.boundingRect();
                 XYChartItem::setLayout(points);
             }
             void LineChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setClipRect(clipRect());
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                 	painter->setPen(m_pointPen);
                 	painter->drawPoints(points());
                 }
                 painter->restore();
             }
-            void LineChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
-                emit clicked(calculateDomainPoint(event->pos()));
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h 0 -4

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class LineChartItem :  public XYChartItem
             {
                  Q_OBJECT
             public:
                  explicit LineChartItem(QLineSeries* series,QGraphicsItem *parent = 0);
                 ~ LineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
             public slots:
                 void handleUpdated();
-            signals:
-                void clicked(const QPointF& point);
             protected:
                 void setLayout(QVector<QPointF>& points);
-                void mousePressEvent( QGraphicsSceneMouseEvent * event );
             private:
                 QLineSeries* m_series;
                 QGraphicsItemGroup m_items;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp +2 -4

             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn bool QLineSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                \fn QPen QLineSeries::linePen() const
                \brief  Returns the pen used to draw line connecting points.
                 \sa setPen()
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent),
             m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
             }
             /*!
                 Sets \a pen used for drawing line connecting points.
             */
             void QLineSeries::setLinePen(const QPen& pen)
             {
                 if(pen!=m_pen){
                 m_pen=pen;
-                emit updated();
+                emit QXYSeries::updated();
                 }
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QLineSeries::setPointsVisible(bool visible)
             {
                 if(m_pointsVisible!=visible){
                 m_pointsVisible=visible;
-                emit updated();
+                emit QXYSeries::updated();
                 }
             }
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
-            #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h 0 -4

             #ifndef QLINESERIES_H_
             #define QLINESERIES_H_
             #include "qchartglobal.h"
             #include "qxyseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
-            	Q_OBJECT
             public:
             	QLineSeries(QObject* parent=0);
             	virtual ~QLineSeries();
             	void setLinePen(const QPen& pen);
             	QPen linePen() const {return m_pen;}
             	void setPointsVisible(bool visible);
             	bool pointsVisible() const {return m_pointsVisible;}
-            signals:
-                void clicked(const QPointF& point);
             public: // from QChartSeries
             	virtual QSeriesType type() const {return QSeries::SeriesTypeLine;}
                 friend QDebug operator<< (QDebug d, const QLineSeries series);
             private:
                 QPen m_pen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchart.cpp +22 -13

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
                 \value ChartThemeDefault
                 \value ChartThemeVanilla
                 \value ChartThemeIcy
                 \value ChartThemeGrayscale
                 \value ChartThemeScientific
             */
             /*!
                 \enum QChart::AnimationOption
                 For enabling/disabling animations. Defaults to NoAnimation.
                 \value NoAnimation
                 \value GridAxisAnimations
                 \value SeriesAnimations
                 \value AllAnimations
             */
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             /*!
                 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_legend(new QLegend(this)),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
                 connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
                 disconnect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 disconnect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the chart \a title. The description text that is drawn above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
+                updateLayout();
             }
             /*!
                 Returns the chart title. The description text that is drawn above the chart.
             */
             QString QChart::chartTitle() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
                 else
                 return QString();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
+                updateLayout();
             }
             /*!
                 Sets the \a brush used for rendering the title text.
             */
             void QChart::setChartTitleBrush(const QBrush &brush)
             {
                 createChartTitleItem();
                 m_titleItem->setBrush(brush);
+                updateLayout();
             }
             /*!
                 Returns the brush used for rendering the title text.
             */
             QBrush QChart::chartTitleBrush()
             {
                 createChartTitleItem();
                 return m_titleItem->brush();
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa setMargin()
             */
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             /*!
                 Sets the chart \a margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa margin()
             */
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
+                updateLayout();
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 m_presenter->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             /*!
                 Resets to the default view.
             */
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
                 Returns the legend object of the chart
             */
             QLegend* QChart::legend()
             {
                 return m_legend;
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
-                QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
+                updateLayout();
-                // recalculate title position
-                if (m_titleItem) {
-                    QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
-                    m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
-                //recalculate background gradient
-                if (m_backgroundItem) {
-                    m_backgroundItem->setRect(rect);
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             void QChart::scroll(int dx,int dy)
             {
             	//temporary
             	if(dx>0)
             	 m_presenter->scroll(m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             	if(dx<0)
             	 m_presenter->scroll(-m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             	if(dy>0)
             	 m_presenter->scroll(0,m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             	if(dy<0)
             	 m_presenter->scroll(0,-m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
+            void QChart::updateLayout()
+            {
+                if(!m_rect.isValid()) return;
+                QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
+                // recalculate title position
+                if (m_titleItem) {
+                    QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
+                    m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
+                }
+                //recalculate background gradient
+                if (m_backgroundItem) {
+                    m_backgroundItem->setRect(rect);
+                }
+            }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 0

             #ifndef QCHART_H
             #define QCHART_H
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             class QLegend;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific
                     //ChartThemeUnnamed1
                     /*! The default theme follows the GUI style of the Operating System */
                 };
                 enum  AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                     };
                     Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QSeries* series, QChartAxis* axisY = 0);
                 void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 QString chartTitle() const;
                 void setChartTitleFont(const QFont& font);
                 void setChartTitleBrush(const QBrush &brush);
                 QBrush chartTitleBrush();
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 void scroll(int dx,int dy);
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
                 QLegend* legend();
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
+                void updateLayout();
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 QRectF m_rect;
                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/scatterseries/qscatterseries.cpp 0 -4

             #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 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::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 0 -4

             #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 {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             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 +5 -2

             #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);
                 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::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker* marker)
             {
-                emit clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
+                emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }
             void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     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++) {
                     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::setLayout(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<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //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());
             }
+            void ScatterChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
+            {
+            }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h +1 -3

             #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(const QPointF& point);
             public slots:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void setLayout(QVector<QPointF>& points);
+                void mousePressEvent( QGraphicsSceneMouseEvent * event );
             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/splinechart/splinechartitem_p.h 0 -2

             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "qsplineseries.h"
             #include "xychartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplineChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 SplineChartItem(QSplineSeries* series, QGraphicsItem *parent = 0);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
-                void setPointsVisible(bool visible);
             public slots:
                 void handleUpdated();
             protected:
                 void setLayout(QVector<QPointF>& points);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;
             private:
                 QSplineSeries* m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

src/xychart/qxyseries.h +1 0

             #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, 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;}
                 virtual 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);
                     void modelDataAdded(QModelIndex parent, int start, int end);
                     void modelDataRemoved(QModelIndex parent, int start, int end);
             signals:
+                void clicked(const QPointF& point);
                 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

src/xychart/xychartitem.cpp +7 -1

             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
+            #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChartItem::XYChartItem(QXYSeries* series, QGraphicsItem *parent):ChartItem(parent),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series)
             {
                 QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+                QObject::connect(this,SIGNAL(clicked(const QPointF&)),series,SIGNAL(clicked(const QPointF&)));
             }
             QPointF XYChartItem::calculateGeometryPoint(const QPointF& point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (m_series->x(index) - m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
             QPointF XYChartItem::calculateDomainPoint(const QPointF& point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
             void XYChartItem::applyLayout(QVector<QPointF>& points)
             {
                 if(m_animator){
                    m_animator->applyLayout(this,points);
                 }
                    else setLayout(points);
             }
             void XYChartItem::updateLayout(QVector<QPointF>& points)
             {
                 setLayout(points);
             }
             void XYChartItem::setLayout(QVector<QPointF>& points)
             {
                 m_points = points;
             }
             //handlers
             void XYChartItem::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
                 updateLayout(points);
                 update();
             }
             void XYChartItem::handlePointRemoved(int index)
             {
                 Q_ASSERT(index<m_series->count() + 1);
                 Q_ASSERT(index>=0);
             //    QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 updateLayout(points);
                 update();
             }
             void XYChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.replace(index,point);
                 updateLayout(points);
                 update();
             }
             void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if(isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 applyLayout(points);
                 update();
             }
             void XYChartItem::handleGeometryChanged(const QRectF& rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
                 if(isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
             	applyLayout(points);
             	update();
             }
             bool XYChartItem::isEmpty()
             {
                return !m_clipRect.isValid() ||  m_maxX - m_minX == 0 || m_maxY - m_minY ==0 ;
             }
+            void XYChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
+            {
+                emit clicked(calculateDomainPoint(event->pos()));
+            }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychartitem_p.h +5 0

             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                  explicit XYChartItem(QXYSeries* series, QGraphicsItem *parent = 0);
                 ~ XYChartItem(){};
                 QVector<QPointF> points() const {return m_points;}
                 QRectF clipRect() const { return m_clipRect;}
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
+            signals:
+                void clicked(const QPointF& point);
             protected:
                 virtual void setLayout(QVector<QPointF>& points);
                 QPointF calculateGeometryPoint(const QPointF& point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF& point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
+                void mousePressEvent( QGraphicsSceneMouseEvent * event );
             private:
                 void applyLayout(QVector<QPointF>& points);
                 void updateLayout(QVector<QPointF>& points);
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 friend class XYAnimation;
+                friend class AreaChartItem;
             };
             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