HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1218:b8de085c4198

Refactor xychartitem -> xychart

Michal Klocek -

r1218:b8de085c4198

parent child

Context file:

r1218:b8de085c4198

Collapse all files

src/animations/chartanimator.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "splineanimation_p.h"
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include "pieanimation_p.h"
             #include "baranimation_p.h"
             #include "barchartitem_p.h"
             #include "areachartitem_p.h"
             #include "splinechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(QVector<qreal>)
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent),
                 m_state(ShowState)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
             void ChartAnimator::addAnimation(ChartAxis *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new AxisAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(PieChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new PieAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(BarChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new BarAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::removeAnimation(Chart *item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
             void ChartAnimator::updateLayout(ChartAxis *item , QVector<qreal> &newLayout)
             {
                 AxisAnimation *animation = static_cast<AxisAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 QVector<qreal> oldLayout = item->layout();
                 if (newLayout.count() == 0)
                     return;
                 switch (m_state) {
                 case ZoomOutState: {
                     QRectF rect = item->geometry();
                     oldLayout.resize(newLayout.count());
                     for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
                         oldLayout[i] = item->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.bottom();
                         oldLayout[j] = item->axisType() == ChartAxis::X_AXIS ? rect.right() : rect.top();
                     }
                 }
                     break;
                 case ZoomInState: {
                     int index = qMin(oldLayout.count() * (item->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - 1.0);
                     oldLayout.resize(newLayout.count());
                     for(int i = 0; i < oldLayout.count(); i++)
                         oldLayout[i]= oldLayout[index];
                 }
                     break;
                 case ScrollDownState:
                 case ScrollRightState: {
                     oldLayout.resize(newLayout.count());
                     for(int i = 0, j = i + 1; i < oldLayout.count() - 1; ++i, ++j)
                         oldLayout[i]= oldLayout[j];
                 }
                     break;
                 case ScrollUpState:
                 case ScrollLeftState: {
                     oldLayout.resize(newLayout.count());
                     for(int i = oldLayout.count() - 1, j = i - 1; i > 0; --i, --j)
                         oldLayout[i]= oldLayout[j];
                 }
                     break;
                 default: {
                     oldLayout.resize(newLayout.count());
                     QRectF rect = item->geometry();
                     for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
                         oldLayout[i] = item->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
                 }
                     break;
                 }
                 if (animation->state() != QAbstractAnimation::Stopped)
                     animation->stop();
                 animation->setDuration(ChartAnimationDuration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QVariantAnimation::KeyValues value;
                 animation->setKeyValues(value); //workaround for wrong interpolation call
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->addSlice(sliceItem, sliceData, startupAnimation);
             }
             void ChartAnimator::removeAnimation(PieChartItem *item, PieSliceItem *sliceItem)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->removeSlice(sliceItem);
             }
             void ChartAnimator::updateAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(sliceItem, sliceData);
             }
             void ChartAnimator::updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
             {
                 BarAnimation *animation = static_cast<BarAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->setDuration(ChartAnimationDuration);
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::setState(State state, const QPointF &point)
             {
                 m_state = state;
                 m_point = point;
             }
             void ChartAnimator::startAnimation(XYAnimation* animation)
             {
                 Q_ASSERT(animation);
                 if (animation->state() != QAbstractAnimation::Stopped)
                 animation->stop();
                 animation->setDuration(ChartAnimationDuration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             #include "moc_chartanimator_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "xyanimation_p.h"
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
+            XYAnimation::XYAnimation(XYChart *item):ChartAnimation(item),
                 m_item(item),
                 m_dirty(false),
                 m_type(MoveDownAnimation)
             {
             }
             XYAnimation::~XYAnimation()
             {
             }
             void XYAnimation::setAnimationType(Animation type)
             {
                 m_type=type;
             }
             void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 int x = oldPoints.count();
                 int y = newPoints.count();
                 if (x != y && abs(x - y) != 1) {
                     m_oldPoints = newPoints;
                     oldPoints.resize(newPoints.size());
                     setKeyValueAt(0.0, qVariantFromValue(oldPoints));
                     setKeyValueAt(1.0, qVariantFromValue(newPoints));
                     m_dirty = false;
                 }
                 else {
                     if (m_dirty) {
                         m_oldPoints = oldPoints;
                         m_dirty = false;
                     }
                     oldPoints = newPoints;
                     if (y < x)
                         m_oldPoints.remove(index); //remove
                     if (y > x)
                         m_oldPoints.insert(index, x > 0 ? m_oldPoints[index-1] : newPoints[index]); //add
                     setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
                     setKeyValueAt(1.0, qVariantFromValue(newPoints));
                     Q_ASSERT(m_oldPoints.count() == newPoints.count());
                 }
             }
             QVariant XYAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
                 QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
                 QVector<QPointF> result;
                 switch (m_type) {
                 case MoveDownAnimation: {
                     if (startVector.count() != endVector.count())
                         break;
                     for(int i = 0; i < startVector.count(); i++) {
                         qreal x = startVector[i].x() + ((endVector[i].x() - startVector[i].x()) * progress);
                         qreal y = startVector[i].y() + ((endVector[i].y() - startVector[i].y()) * progress);
                         result << QPointF(x, y);
                     }
                 }
                     break;
                 case LineDrawAnimation: {
                     for(int i = 0; i < endVector.count() * qBound(qreal(0), progress, qreal(1)); i++)
                         result << endVector[i];
                 }
                     break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void XYAnimation::updateCurrentValue (const QVariant &value)
             {
                 if(state()!=QAbstractAnimation::Stopped){ //workaround
                     m_dirty = true;
                     QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
                     m_item->setGeometryPoints(vector);
                     m_item->updateGeometry();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation_p.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef XYANIMATION_P_H
             #define XYANIMATION_P_H
             #include "chartanimation_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class XYChartItem;
+            class XYChart;
             class XYAnimation : public ChartAnimation
             {
             public:
                 enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
-                XYAnimation(XYChartItem *item);
+                XYAnimation(XYChart *item);
                 ~XYAnimation();
                 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
                 void setAnimationType(Animation type);
                 Animation animationType() const { return m_type; };
             protected:
                 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress ) const;
                 void updateCurrentValue (const QVariant &value );
             private:
-                XYChartItem *m_item;
+                XYChart *m_item;
                 QVector<QPointF> m_oldPoints;
                 bool m_dirty;
                 Animation m_type;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/linechartitem.cpp +9 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
+            #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
-            LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):XYChartItem(series,presenter),
+            LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):XYChart(series,presenter),
+            QGraphicsItem(presenter ? presenter->rootItem() : 0),
             m_series(series),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     m_path = QPainterPath();
                     return;
                 }
                 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();
+                setPos(origin());
             }
             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(geometryPoints());
                 }
                 painter->restore();
             }
+            void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+            {
+                emit XYChart::clicked(calculateDomainPoint(event->pos()));
+            }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +4 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class ChartPresenter;
-            class LineChartItem :  public XYChartItem
+            class LineChartItem :  public XYChart , public QGraphicsItem
             {
                  Q_OBJECT
+                 Q_INTERFACES(QGraphicsItem)
             public:
                  explicit LineChartItem(QLineSeries *series,ChartPresenter *presenter);
                 ~LineChartItem() {};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
             public Q_SLOTS:
                 void handleUpdated();
             protected:
                 void updateGeometry();
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 QLineSeries* m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterchart/scatterchartitem.cpp +10 -5

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

src/scatterchart/scatterchartitem_p.h +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef SCATTERCHARTITEM_H
             #define SCATTERCHARTITEM_H
             #include "qchartglobal.h"
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
             class Marker;
-            class ScatterChartItem : public XYChartItem
+            class ScatterChartItem : public XYChart, public QGraphicsItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter);
             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);
             public Q_SLOTS:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void updateGeometry();
+                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 setPoint(const QPointF& point)
                {
                    m_point=point;
                }
                QPointF point() const
                {
                    return m_point;
                }
                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)
                {
                    Q_UNUSED(event)
                    m_parent->markerSelected(this);
                }
             private:
                QAbstractGraphicsShapeItem* m_item;
                ScatterChartItem* m_parent;
                QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/splinechart/splinechartitem.cpp +10 -5

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
-            #include <QDebug>
+            #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
-                XYChartItem(series, presenter),
+            XYChart(series, presenter),
+            QGraphicsItem(presenter ? presenter->rootItem() : 0),
             m_series(series),
             m_pointsVisible(false),
             m_animation(0)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             void SplineChartItem::setAnimation(SplineAnimation* animation)
             {
                 m_animation=animation;
-                XYChartItem::setAnimation(animation);
+                XYChart::setAnimation(animation);
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints=points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 QVector<QPointF> controlPoints;
                 if(newPoints.count()>=2) {
                     controlPoints.resize(newPoints.count()*2-2);
                 }
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
                 if (controlPoints.count()<2) {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                     return;
                 }
                 if (m_animation) {
                     m_animation->setValues(oldPoints,newPoints,m_controlPoints,controlPoints,index);
                     animator()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                 }
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
-                return XYChartItem::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
+                return XYChart::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = geometryPoints();
                 const QVector<QPointF> &controlPoints = controlGeometryPoints();
                 if ((points.size()<2) || (controlPoints.size()<2)) {
                     m_path = QPainterPath();
                     return;
                 }
                 Q_ASSERT(points.count()*2-2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
+                setPos(origin());
             }
             //handlers
             void SplineChartItem::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 SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
+            void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+            {
+                emit XYChart::clicked(calculateDomainPoint(event->pos()));
+            }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h +4 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "qsplineseries.h"
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include "splineanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class SplineChartItem : public XYChartItem
+            class SplineChartItem : public XYChart, public QGraphicsItem
             {
                 Q_OBJECT
+                Q_INTERFACES(QGraphicsItem)
             public:
                 SplineChartItem(QSplineSeries *series, ChartPresenter *presenter);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setControlGeometryPoints(QVector<QPointF>& points);
                 QVector<QPointF> controlGeometryPoints() const;
                 void setAnimation(SplineAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; }
             public Q_SLOTS:
                 void handleUpdated();
             protected:
                 void updateGeometry();
                 void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;
             private:
                 QSplineSeries *m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
                 QVector<QPointF> m_controlPoints;
                 SplineAnimation* m_animation;
                 friend class SplineAnimation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

src/xychart/qxyseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QXYModelMapper *modelMapper READ modelMapper)
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d,QObject *parent = 0);
                 ~QXYSeries();
             public:
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> &points);
                 void replace(qreal oldX,qreal oldY,qreal newX,qreal newY);
                 void replace(const QPointF &oldPoint,const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 QList<QPointF> points() const;
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> &points);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 void setModel(QAbstractItemModel *model);
                 virtual void setModelMapper(QXYModelMapper *mapper);
                 QXYModelMapper* modelMapper() const;
             Q_SIGNALS:
                 void clicked(const QPointF &point);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries);
                 Q_DISABLE_COPY(QXYSeries);
                 friend class XYLegendMarker;
-                friend class XYChartItem;
+                friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychart.cpp ~~src/xychart/xychartitem.cpp~~ renamed +21 -32

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
-            #include "xychartitem_p.h"
+            #include "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
-            #include <QGraphicsSceneMouseEvent>
             #include <QAbstractItemModel>
             #include "qxymodelmapper.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
-            XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
+            XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter):Chart(presenter),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series),
             m_animation(0)
             {
                 QObject::connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 QObject::connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
                 QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
                 QObject::connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
                 QObject::connect(series->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
                 QObject::connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
             }
-            void XYChartItem::setGeometryPoints(QVector<QPointF>& points)
+            void XYChart::setGeometryPoints(QVector<QPointF>& points)
             {
                 m_points = points;
             }
-            void XYChartItem::setClipRect(const QRectF &rect)
+            void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
-            void XYChartItem::setAnimation(XYAnimation* animation)
+            void XYChart::setAnimation(XYAnimation* animation)
             {
                 m_animation=animation;
             }
-            QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
+            QPointF XYChart::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
+            QPointF XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX)* deltaX;
                 qreal y = (vector[index].y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
-            QVector<QPointF> XYChartItem::calculateGeometryPoints() const
+            QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX)* deltaX;
                     qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
-            QPointF XYChartItem::calculateDomainPoint(const QPointF &point) const
+            QPointF XYChart::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::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
+            void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (m_animation) {
                     m_animation->setValues(oldPoints, newPoints, index);
                     animator()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     updateGeometry();
                 }
             }
-            void XYChartItem::updateGeometry()
-                update();
             //handlers
-            void XYChartItem::handlePointAdded(int index)
+            void XYChart::handlePointAdded(int index)
             {
                 if (m_series->model() == 0) {
                     Q_ASSERT(index<m_series->count());
                     Q_ASSERT(index>=0);
                 }
                 QVector<QPointF> points = m_points;
                 QPointF point;
                 point = calculateGeometryPoint(index);
                 points.insert(index, point);
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
                 }
                updateChart(m_points,points,index);
             }
-            void XYChartItem::handlePointsAdded(int start, int end)
+            void XYChart::handlePointsAdded(int start, int end)
             {
                 if (m_series->model() == 0) {
                     for (int i = start; i <= end; i++)
                     handlePointAdded(i);
                 }
                 else {
                     int mapFirst = m_series->modelMapper()->first();
                     int mapCount = m_series->modelMapper()->count();
                     if (mapCount != -1 && start >= mapFirst + mapCount) {
                         return;
                     }
                     else {
                         int addedCount = end - start + 1;
                         if (mapCount != -1 && addedCount > mapCount)
                         addedCount = mapCount;
                         int first = qMax(start, mapFirst); // get the index of the first item that will be added
                         int last = qMin(first + addedCount - 1, mapCount + mapFirst - 1);// get the index of the last item that will be added
                         for (int i = first; i <= last; i++) {
                             handlePointAdded(i - mapFirst);
                         }
                         // the map is limited therefore the items that are now outside the map
                         // need to be removed from the drawn points
                         if (mapCount != -1 && m_points.size() > mapCount)
                         for (int i = m_points.size() - 1; i >= mapCount; i--)
                         handlePointRemoved(i);
                     }
                 }
             }
-            void XYChartItem::handlePointRemoved(int index)
+            void XYChart::handlePointRemoved(int index)
             {
                 if (m_series->model() == 0) {
                     Q_ASSERT(index<m_series->count() + 1);
                     Q_ASSERT(index>=0);
                 }
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
                 }
                 updateChart(m_points,points,index);
             }
-            void XYChartItem::handlePointsRemoved(int start, int end)
+            void XYChart::handlePointsRemoved(int start, int end)
             {
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 if (m_series->model() == 0) {
                     for (int i = end; i >= start; i--)
                     handlePointRemoved(i);
                 }
                 else {
                     // series uses model as a data source
                     int mapFirst = m_series->modelMapper()->first();
                     int mapCount = m_series->modelMapper()->count();
                     int removedCount = end - start + 1;
                     if (mapCount != -1 && start >= mapFirst + mapCount) {
                         return;
                     }
                     else {
                         int toRemove = qMin(m_points.size(), removedCount); // first find how many items can actually be removed
                         int first = qMax(start, mapFirst);// get the index of the first item that will be removed.
                         int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1);// get the index of the last item that will be removed.
                         if (last - first == 0) {
                             for (int i = last; i >= first; i--) {
                                 handlePointRemoved(i - mapFirst);
                             }
                         }
                         else {
                             QVector<QPointF> points = m_points;
                             for (int i = last; i >= first; i--)
                             points.remove(i - mapFirst);
                             setGeometryPoints(points);
                             updateGeometry();
                         }
                         if (mapCount != -1) {
                             int itemsAvailable; // check how many are available to be added
                             if (m_series->modelMapper()->orientation() == Qt::Vertical)
                             itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
                             else
                             itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
                             int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size());// add not more items than there is space left to be filled.
                             int currentSize = m_points.size();
                             if (toBeAdded > 0)
                             for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
                                 handlePointAdded(i);
                             }
                         }
                     }
                 }
             }
-            void XYChartItem::handlePointReplaced(int index)
+            void XYChart::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);
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::MoveDownAnimation);
                 }
                 updateChart(m_points,points,index);
             }
-            void XYChartItem::handleReinitialized()
+            void XYChart::handleReinitialized()
             {
                 QVector<QPointF> points = calculateGeometryPoints();
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
                 }
                 updateChart(m_points,points);
             }
-            void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
+            void XYChart::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();
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
                 }
                 updateChart(m_points,points);
             }
-            void XYChartItem::handleGeometryChanged(const QRectF &rect)
+            void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
-                setPos(rect.topLeft());
+                m_origin=rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 if(m_animation) {
                       m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
                   }
                 updateChart(m_points,points);
             }
-            bool XYChartItem::isEmpty()
+            bool XYChart::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
             }
-            void XYChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+            #include "moc_xychart_p.cpp"
-                emit clicked(calculateDomainPoint(event->pos()));
-            #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart.pri +2 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
-                $$PWD/xychartitem.cpp \
+                $$PWD/xychart.cpp \
                 $$PWD/qxyseries.cpp \
                 $$PWD/qxymodelmapper.cpp
             PRIVATE_HEADERS += \
-                $$PWD/xychartitem_p.h \
+                $$PWD/xychart_p.h \
                 $$PWD/qxyseries_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qxyseries.h \
                 $$PWD/qxymodelmapper.h

src/xychart/xychart_p.h ~~src/xychart/xychartitem_p.h~~ renamed +8 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include "xyanimation_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
-            class XYChartItem :  public ChartItem
+            class XYChart :  public Chart
             {
                  Q_OBJECT
             public:
-                 explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
+                 explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
-                ~XYChartItem(){};
+                ~XYChart(){};
                 void setGeometryPoints(QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setClipRect(const QRectF &rect);
                 QRectF clipRect() const { return m_clipRect; }
+                QSizeF size() const { return m_size; }
+                QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; }
-                virtual void updateGeometry();
+                virtual void updateGeometry() = 0;
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointsAdded(int start, int end);
                 void handlePointRemoved(int index);
                 void handlePointsRemoved(int start, int end);
                 void handlePointReplaced(int index);
                 void handleReinitialized();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF& point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
                 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:
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
+                QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation* m_animation;
                 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