HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r677:2b967c4f6e8e

Refactors chartitem...

Michal Klocek -

r677:2b967c4f6e8e

parent child

Context file:

r677:2b967c4f6e8e

Expand all files

examples/linechart/main.cpp 0 -1

                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);

src/animations/axisanimation.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AxisAnimation::AxisAnimation(AxisItem *axis): ChartAnimation(axis),
+            AxisAnimation::AxisAnimation(Axis *axis): ChartAnimation(axis),
                 m_axis(axis)
             {
             }

src/animations/axisanimation_p.h +2 -2

             class AxisAnimation: public ChartAnimation
             {
             public:
-                AxisAnimation(AxisItem *axis);
+                AxisAnimation(Axis *axis);
                 ~AxisAnimation();
             protected:
                 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
                 virtual void updateCurrentValue (const QVariant & value );
             private:
-                AxisItem* m_axis;
+                Axis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator.cpp +7 -7

             {
             }
-            void ChartAnimator::addAnimation(AxisItem* item)
+            void ChartAnimator::addAnimation(Axis* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
             }
-            void ChartAnimator::removeAnimation(ChartItem* item)
+            void ChartAnimator::removeAnimation(Chart* item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
-            void ChartAnimator::updateLayout(AxisItem* item , QVector<qreal>& newLayout)
+            void ChartAnimator::updateLayout(Axis* item , QVector<qreal>& newLayout)
             {
                 AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
                 			for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
                 			{
-                				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.bottom();
+                				oldLayout[i]= item->axisType()==Axis::X_AXIS?rect.left():rect.bottom();
-                				oldLayout[j]= item->axisType()==AxisItem::X_AXIS?rect.right():rect.top();
+                				oldLayout[j]= item->axisType()==Axis::X_AXIS?rect.right():rect.top();
                 			}
                 		}
                 	break;
             		case ZoomInState: {
-            			int index = qMin(oldLayout.count()*(item->axisType()==AxisItem::X_AXIS?m_point.x():(1 -m_point.y())),newLayout.count()-1.0);
+            			int index = qMin(oldLayout.count()*(item->axisType()==Axis::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++)
             			QRectF rect = item->geometry();
             			for(int i=0, j=oldLayout.count()-1;i<oldLayout.count();i++,j--)
             			{
-            				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.top();
+            				oldLayout[i]= item->axisType()==Axis::X_AXIS?rect.left():rect.top();
             			}
             		}
             		break;

src/animations/chartanimator_p.h +7 -6

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
-            class AxisItem;
+            class Axis;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class ChartAnimator : public QObject {
             public:
-            	//TODO: this should be flags in case of two state at the time
             	enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState,ScrollRightState,ZoomInState,ZoomOutState};
+            	Q_DECLARE_FLAGS(States, State);
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
-                void addAnimation(AxisItem* item);
+                void addAnimation(Axis* item);
                 void addAnimation(PieChartItem* item);
                 void addAnimation(ScatterChartItem* item);
                 void addAnimation(LineChartItem* item);
                 void addAnimation(SplineChartItem* item);
                 void addAnimation(BarChartItem* item);
-                void removeAnimation(ChartItem* item);
+                void removeAnimation(Chart* item);
                 void animationStarted();
                 void updateLayout(XYChartItem* item, QVector<QPointF>& oldLayout,QVector<QPointF>& newLayout,int index);
                 void updateLayout(SplineChartItem* item,  QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newContorlPoints,int index);
-                void updateLayout(AxisItem* item, QVector<qreal>& layout);
+                void updateLayout(Axis* item, QVector<qreal>& layout);
                 void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem* item, QPieSlice *slice);
                 void setState(State state,const QPointF& point = QPointF());
             private:
-                 QMap<ChartItem*,ChartAnimation*> m_animations;
+                 QMap<Chart*,ChartAnimation*> m_animations;
                  State m_state;
                  QPointF m_point;
             };

src/animations/xyanimation.cpp +1 -1

                     }
                         break;
                     default:
-                        qWarning()<<"Unknow type of animation";
+                        qWarning()<<"Unknown type of animation";
                         break;
                 }

src/areachart/areachartitem.cpp +3 -3

             //TODO: optimize : remove points which are not visible
-            AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,QGraphicsItem *parent):ChartItem(parent),
+            AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,ChartPresenter *presenter):Chart(presenter),QGraphicsItem(presenter->rootItem()),
             m_series(areaSeries),
             m_upper(0),
             m_lower(0),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
-                m_upper = new AreaBoundItem(this,m_series->upperSeries());
+                m_upper = new AreaBoundItem(this,m_series->upperSeries(),presenter);
                 if(m_series->lowerSeries()){
-                m_lower = new AreaBoundItem(this,m_series->lowerSeries());
+                m_lower = new AreaBoundItem(this,m_series->lowerSeries(),presenter);
                 }
                 QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));

src/areachart/areachartitem_p.h +3 -3

             class QAreaSeries;
             class AreaChartItem;
-            class AreaChartItem :  public QObject ,public ChartItem
+            class AreaChartItem : public Chart, public QGraphicsItem
             {
                 Q_OBJECT
             public:
-                AreaChartItem(QAreaSeries* areaSeries, QGraphicsItem *parent = 0);
+                AreaChartItem(QAreaSeries* areaSeries, ChartPresenter *presenter);
                 ~ AreaChartItem();
                 //from QGraphicsItem
             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries):LineChartItem(lineSeries),
+                AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries,ChartPresenter *presenter):LineChartItem(lineSeries,presenter),
                 m_item(item){};
                 ~AreaBoundItem(){};

src/axis/axisitem.cpp +41 -50

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
+            Axis::Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type) :
-            ChartItem(parent),
+            Chart(presenter),
-            m_presenter(presenter),
             m_chartAxis(axis),
             m_type(type),
             m_labelsAngle(0),
-            m_grid(parent),
+            m_grid(presenter->rootItem()),
-            m_shades(parent),
+            m_shades(presenter->rootItem()),
-            m_labels(parent),
+            m_labels(presenter->rootItem()),
-            m_axis(parent),
+            m_axis(presenter->rootItem()),
             m_min(0),
             m_max(0),
             m_ticksCount(0)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
+                m_axis.setHandlesChildEvents(false);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
-                setFlags(QGraphicsItem::ItemHasNoContents);
                 QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
-            AxisItem::~AxisItem()
+            Axis::~Axis()
-            QRectF AxisItem::boundingRect() const
             {
-                return QRectF();
             }
-            void AxisItem::createItems(int count)
+            void Axis::createItems(int count)
             {
                 if(m_axis.children().size()==0)
-                       m_axis.addToGroup(new QGraphicsLineItem());
+                       m_axis.addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem());
                        m_labels.addToGroup(new QGraphicsSimpleTextItem());
                    }
             }
-            void AxisItem::deleteItems(int count)
+            void Axis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 }
             }
-            void AxisItem::updateLayout(QVector<qreal>& layout)
+            void Axis::updateLayout(QVector<qreal>& layout)
             {
-                if(m_animator){
+                if(animator()){
-                   m_animator->updateLayout(this,layout);
+                   animator()->updateLayout(this,layout);
                 }
                 else setLayout(layout);
             }
-            QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
+            QStringList Axis::createLabels(int ticks, qreal min, qreal max) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>0);
                 return labels;
             }
-            void AxisItem::setAxisOpacity(qreal opacity)
+            void Axis::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
-            qreal AxisItem::axisOpacity() const
+            qreal Axis::axisOpacity() const
             {
                 return m_axis.opacity();
             }
-            void AxisItem::setGridOpacity(qreal opacity)
+            void Axis::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
-            qreal AxisItem::gridOpacity() const
+            qreal Axis::gridOpacity() const
             {
                 return m_grid.opacity();
             }
-            void AxisItem::setLabelsOpacity(qreal opacity)
+            void Axis::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
-            qreal AxisItem::labelsOpacity() const
+            qreal Axis::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
-            void AxisItem::setShadesOpacity(qreal opacity)
+            void Axis::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
-            qreal AxisItem::shadesOpacity() const
+            qreal Axis::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
-            void AxisItem::setLabelsAngle(int angle)
+            void Axis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                 m_labelsAngle=angle;
             }
-            void AxisItem::setLabelsPen(const QPen& pen)
+            void Axis::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
-            void AxisItem::setLabelsBrush(const QBrush& brush)
+            void Axis::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
-            void AxisItem::setLabelsFont(const QFont& font)
+            void Axis::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
-            void AxisItem::setShadesBrush(const QBrush& brush)
+            void Axis::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
-            void AxisItem::setShadesPen(const QPen& pen)
+            void Axis::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
-            void AxisItem::setAxisPen(const QPen& pen)
+            void Axis::setAxisPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
-            void AxisItem::setGridPen(const QPen& pen)
+            void Axis::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
-            QVector<qreal> AxisItem::calculateLayout() const
+            QVector<qreal> Axis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 return points;
             }
-            void AxisItem::setLayout(QVector<qreal>& layout)
+            void Axis::setLayout(QVector<qreal>& layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
             	m_layoutVector=layout;
             }
-            bool AxisItem::isEmpty()
+            bool Axis::isEmpty()
             {
                 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
             }
             //handlers
-            void AxisItem::handleAxisCategoriesUpdated()
+            void Axis::handleAxisCategoriesUpdated()
             {
             	if(isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
-            void AxisItem::handleAxisUpdated()
+            void Axis::handleAxisUpdated()
             {
                 if(isEmpty()) return;
             }
-            void AxisItem::handleRangeChanged(qreal min, qreal max,int tickCount)
+            void Axis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if(min==max || tickCount<2) return;
             }
-            void AxisItem::handleGeometryChanged(const QRectF& rect)
+            void Axis::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 if(isEmpty()) return;
                 updateLayout(layout);
             }
-            //painter
+            void Axis::axisSelected()
-            void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(painter)
+                qDebug()<<"TODO axis clicked";
-                Q_UNUSED(option)
-                Q_UNUSED(widget)
             }
             //TODO "nice numbers algorithm"

src/axis/axisitem_p.h +35 -9

             #define AXISITEM_H_
             #include "domain_p.h"
-            #include "chartitem_p.h"
+            #include "chart_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartPresenter;
-            class AxisItem : public QObject, public ChartItem
+            class Axis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
-                AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
+                Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS);
-                ~AxisItem();
+                ~Axis();
-                //from QGraphicsItem
-                QRectF boundingRect() const;
-                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
                 void setLayout(QVector<qreal>& layout);
                 QStringList createLabels(int ticks, qreal min, qreal max) const;
+                void axisSelected();
             private:
-                ChartPresenter* m_presenter;
                 QChartAxis* m_chartAxis;
                 AxisType m_type;
                 QRectF m_rect;
                 qreal m_zoomFactor;
                 friend class AxisAnimation;
+                friend class AxisItem;
+            };
+            class AxisItem: public QGraphicsLineItem
+            {
+            public:
+                AxisItem(Axis* axis,QGraphicsItem* parent=0):QGraphicsLineItem(parent),m_axis(axis){};
+            protected:
+               void mousePressEvent(QGraphicsSceneMouseEvent *event)
+               {
+                   Q_UNUSED(event)
+                   m_axis->axisSelected();
+               }
+               QRectF boundingRect() const
+               {
+                   return QGraphicsLineItem::boundingRect().adjusted(0,0,m_axis->axisType()!=Axis::X_AXIS?10:0,m_axis->axisType()!=Axis::Y_AXIS?10:0);
+               }
+               QPainterPath shape() const
+               {
+                   QPainterPath path;
+                   path.addRect(boundingRect());
+                   return path;
+               }
+            private:
+               Axis* m_axis;
             };

src/barchart/barchartitem.cpp +3 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartItem::BarChartItem(QBarSeries *series, QChart *parent) :
+            BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
-                ChartItem(parent),
+                ChartItem(presenter),
                 mHeight(0),
                 mWidth(0),
                 mLayoutSet(false),
-                mSeries(series),
+                mSeries(series)
-                mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(layoutChanged()));

src/barchart/barchartitem_p.h +4 -2

             {
                 Q_OBJECT
             public:
-                BarChartItem(QBarSeries *series, QChart *parent = 0);
+                BarChartItem(QBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
+            // Common implemantation of different presenters. Not to be instantiated.
+            // TODO: combine this with BarPresenter and derive other presenters from it?
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
                 QList<BarValue*> mFloatingValues;
-                QChart* mChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartitem.cpp +2 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter* presenter) :
-            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, QChart *parent) :
+                BarChartItem(series, presenter)
-                BarChartItem(series, parent)
             {
             }

src/barchart/separator.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Separator::Separator(QGraphicsItem *parent)
-                : ChartItem(parent)
+                : QGraphicsItem(parent)
             {
             }

src/barchart/separator_p.h +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class Separator : public ChartItem
+            class Separator : public QGraphicsItem
             {
             public:
                 Separator(QGraphicsItem *parent = 0);

src/barchart/stackedbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarChartItem::StackedBarChartItem(QBarSeries *series, QChart *parent) :
+            StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
-                BarChartItem(series,parent)
+                BarChartItem(series,presenter)
             {
             }

src/chartitem_p.h +4 -18

@@ -1,31 +1,17
1	#ifndef CHARTITEM_H_	1	#ifndef CHARTITEM_H_
2	#define CHARTITEM_H_	2	#define CHARTITEM_H_
3		3
4	#include "~~domain~~_p.h"	4	#include "chart_p.h"
		5	#include "chartpresenter_p.h"
5	#include <QGraphicsItem>	6	#include <QGraphicsItem>
6		7
7	QTCOMMERCIALCHART_BEGIN_NAMESPACE	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
8		9
9	class ChartAnimator;	10	class ChartItem : public QGraphicsItem, public Chart
10
11	class ChartItem : public QGraphicsItem
12	{	11	{
13	enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};	12	enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};
14	public:	13	public:
15	ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent),	14	ChartItem(ChartPresenter *presenter):QGraphicsItem(presenter->rootItem()),Chart(presenter){};
16	m_animator(0){};
17	//TODO make pure
18	virtual void handleGeometryChanged(const QRectF&){};
19	virtual void handleDomainChanged(qreal,qreal,qreal,qreal){};
20
21	void setAnimator(ChartAnimator* animator){
22	m_animator=animator;
23	}
24
25	virtual ~ChartItem(){};
26
27	protected:
28	ChartAnimator* m_animator;
29	};	15	};
30		16
31	QTCOMMERCIALCHART_END_NAMESPACE	17	QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +12 -12

             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
-                AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
+                Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
-                AxisItem* item = m_axisItems.take(axis);
+                Axis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
-            	ChartItem *item = 0 ;
+            	Chart *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
-                    LineChartItem* line = new LineChartItem(lineSeries,m_chart);
+                    LineChartItem* line = new LineChartItem(lineSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
-                    AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
+                    AreaChartItem* area = new AreaChartItem(areaSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
-                    BarChartItem* bar = new BarChartItem(barSeries,m_chart);
+                    BarChartItem* bar = new BarChartItem(barSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
-                    StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,m_chart);
+                    StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
-                    PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,m_chart);
+                    PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
-                        ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
+                        ScatterChartItem *scatter = new ScatterChartItem(scatterSeries,this);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    PieChartItem* pie = new PieChartItem(pieSeries, this, m_chart);
+                    PieChartItem* pie = new PieChartItem(pieSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
-                    SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
+                    SplineChartItem* spline  = new SplineChartItem(splineSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
-                ChartItem* item = m_chartItems.take(series);
+                Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations

src/chartpresenter_p.h +6 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartItem;
+            class Chart;
             class QSeries;
             class ChartDataSet;
             class Domain;
-            class AxisItem;
+            class Axis;
             class ChartTheme;
             class ChartAnimator;
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
+                QGraphicsItem* rootItem() const {return m_chart;};
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 int m_zoomIndex;
-                QMap<QSeries*,ChartItem*> m_chartItems;
+                QMap<QSeries*,Chart*> m_chartItems;
-                QMap<QChartAxis*,AxisItem*> m_axisItems;
+                QMap<QChartAxis*,Axis*> m_axisItems;
                 QVector<QRectF> m_zoomStack;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;

src/linechart/linechartitem.cpp +1 -1

             //TODO: optimize : remove points which are not visible
-            LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):XYChartItem(series,parent),
+            LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):XYChartItem(series,presenter),
             m_series(series),
             m_pointsVisible(false)
             {

src/linechart/linechartitem_p.h +2 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
+            class ChartPresenter;
             class LineChartItem :  public XYChartItem
             {
                  Q_OBJECT
             public:
-                 explicit LineChartItem(QLineSeries* series,QGraphicsItem *parent = 0);
+                 explicit LineChartItem(QLineSeries* series,ChartPresenter *presenter);
                 ~ LineChartItem(){};
                 //from QGraphicsItem

src/piechart/piechartitem.cpp +9 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter *presenter, QGraphicsItem *parent)
+            PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
-                :ChartItem(parent),
+                :ChartItem(presenter),
-                m_series(series),
+                m_series(series)
-                m_presenter(presenter)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
             {
                 bool isEmpty = m_slices.isEmpty();
-                m_presenter->theme()->decorate(m_series, m_presenter->dataSet()->seriesIndex(m_series));
+                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
-                m_presenter->theme()->decorate(m_series, m_presenter->dataSet()->seriesIndex(m_series));
+                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
-                    if (m_animator)
+                    if (animator())
-                        m_animator->removeAnimation(this, s);
+                        animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
-                if (m_animator)
+                if (animator())
-                    m_animator->updateLayout(this, layout);
+                    animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }

src/piechart/piechartitem_p.h +2 -3

             typedef QHash<QPieSlice*, PieSliceData> PieLayout;
-            class PieChartItem : public QObject, public ChartItem
+            class PieChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
-                PieChartItem(QPieSeries *series, ChartPresenter *presenter, QGraphicsItem *parent);
+                PieChartItem(QPieSeries *series, ChartPresenter *presenter);
                 ~PieChartItem();
             public: // from QGraphicsItem
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
-                ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class AxisItem;
+            class Axis;
             class QSeries;
             class PlotDomain;
             class BarChartItem;

src/scatterseries/scatterchartitem.cpp +2 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent) :
+            ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
-                XYChartItem(series,parent),
+                XYChartItem(series,presenter),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
-                Q_ASSERT(parent);
-                Q_ASSERT(series);
                 QObject::connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);

src/scatterseries/scatterchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent = 0);
+                explicit ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter);
             public:
                 //from QGraphicsItem

src/splinechart/splinechartitem.cpp +4 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsItem *parent) :
+            SplineChartItem::SplineChartItem(QSplineSeries* series, ChartPresenter *presenter) :
-            XYChartItem(series, parent),
+            XYChartItem(series, presenter),
             m_series(series),
             m_pointsVisible(false)
             {
                     return;
                 }
-                if(m_animator){
+                if(animator()){
-                   m_animator->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
+                   animator()->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
                 }else{
                    setLayout(newPoints,controlPoints);
                 }

src/splinechart/splinechartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                SplineChartItem(QSplineSeries* series, QGraphicsItem *parent = 0);
+                SplineChartItem(QSplineSeries* series, ChartPresenter *presenter);
                 //from QGraphicsItem
                 QRectF boundingRect() const;

src/src.pro +4 -2

                 qseries.cpp \
                 qlegend.cpp \
                 legendmarker.cpp \
-                chartbackground.cpp
+                chartbackground.cpp \
+                chart.cpp
             PRIVATE_HEADERS += \
                 chartdataset_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 domain_p.h \
                 legendmarker_p.h \
-                chartbackground_p.h
+                chartbackground_p.h \
+                chart_p.h
             PUBLIC_HEADERS += \
                 qchart.h \
                 qchartglobal.h \

src/xychart/xychartitem.cpp +3 -3

             //TODO: optimize : remove points which are not visible
-            XYChartItem::XYChartItem(QXYSeries* series, QGraphicsItem *parent):ChartItem(parent),
+            XYChartItem::XYChartItem(QXYSeries* series, ChartPresenter *presenter):ChartItem(presenter),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             void XYChartItem::updateLayout(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index)
             {
-                if(m_animator){
+                if(animator()){
-                   m_animator->updateLayout(this,oldPoints,newPoints,index);
+                   animator()->updateLayout(this,oldPoints,newPoints,index);
                 }else{
                     setLayout(newPoints);
                 }

src/xychart/xychartitem_p.h +5 -2

             class ChartPresenter;
             class QXYSeries;
-            class XYChartItem :  public QObject , public ChartItem
+            class XYChartItem :  public ChartItem
             {
                  Q_OBJECT
             public:
-                 explicit XYChartItem(QXYSeries* series, QGraphicsItem *parent = 0);
+                 explicit XYChartItem(QXYSeries* series, ChartPresenter *presenter);
                 ~ 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 clicked(const QPointF& point);
             protected:
                 virtual void setLayout(QVector<QPointF>& points);
                 virtual void updateLayout(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;

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