HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r671:c28ddd8c89e3

Animation framework for barchart.

sauimone -

r671:c28ddd8c89e3

parent child

Context file:

r671:c28ddd8c89e3

Collapse all files

src/animations/baranimation.cpp created 644 +49 0

@@ -0,0 +1,49
	1	#include "baranimation_p.h"
	2	#include "barchartitem_p.h"
	3	#include <QParallelAnimationGroup>
	4	#include <QTimer>
	5
	6	Q_DECLARE_METATYPE(QVector<QSizeF>)
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	BarAnimation::BarAnimation(BarChartItem *item)
	11	:ChartAnimation(item),
	12	m_item(item)
	13	{
	14	}
	15
	16	BarAnimation::~BarAnimation()
	17	{
	18	}
	19
	20	void BarAnimation::updateValues(const BarLayout& layout)
	21	{
	22	// TODO:
	23	qDebug() << "BarAnimation::updateValues";
	24	}
	25
	26
	27	QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
	28	{
	29	QVector<QSizeF> startVector = qVariantValue<QVector<QSizeF> > (from);
	30	QVector<QSizeF> endVector = qVariantValue<QVector<QSizeF> > (to);
	31	QVector<QSizeF> result;
	32
	33	Q_ASSERT(startVector.count() == endVector.count()) ;
	34
	35	for(int i =0 ;i< startVector.count();i++){
	36	QSizeF value = startVector[i] + ((endVector[i]- endVector[i]) * progress);
	37	result << value;
	38	}
	39	return qVariantFromValue(result);
	40	}
	41
	42	void BarAnimation::updateCurrentValue(const QVariant &)
	43	{
	44	// TODO?
	45	}
	46
	47	#include "moc_baranimation_p.cpp"
	48
	49	QTCOMMERCIALCHART_END_NAMESPACE

src/animations/baranimation_p.h created 644 +36 0

@@ -0,0 +1,36
	1	#ifndef BARANIMATION_P_H_
	2	#define BARANIMATION_P_H_
	3
	4	#include "chartanimation_p.h"
	5	#include "barchartitem_p.h"
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	class BarChartItem;
	10	class QBarSet;
	11	class BarSetAnimation;
	12
	13	class BarAnimation : public ChartAnimation
	14	{
	15	Q_OBJECT
	16
	17	public:
	18	BarAnimation(BarChartItem *item);
	19	~BarAnimation();
	20
	21	void updateValues(const BarLayout& layout);
	22
	23	public: // from QVariantAnimation
	24	virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
	25	virtual void updateCurrentValue (const QVariant & value );
	26
	27	public Q_SLOTS:
	28
	29	private:
	30	BarChartItem *m_item;
	31	QHash<QBarSet, BarSetAnimation> m_animations;
	32	};
	33
	34	QTCOMMERCIALCHART_END_NAMESPACE
	35
	36	#endif

src/animations/animations.pri +6 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/axisanimation.cpp \
                 $$PWD/chartanimator.cpp \
                 $$PWD/xyanimation.cpp \
                 $$PWD/pieanimation.cpp \
                 $$PWD/piesliceanimation.cpp \
-                $$PWD/splineanimation.cpp
+                $$PWD/splineanimation.cpp \
+                $$PWD/baranimation.cpp
             PRIVATE_HEADERS += \
                 $$PWD/axisanimation_p.h \
                 $$PWD/chartanimator_p.h \
                 $$PWD/chartanimation_p.h \
                 $$PWD/xyanimation_p.h \
                 $$PWD/pieanimation_p.h \
                 $$PWD/piesliceanimation_p.h \
-                $$PWD/splineanimation_p.h
+                $$PWD/splineanimation_p.h \
+                $$PWD/baranimation_p.h

src/animations/chartanimator.cpp +24 0

             #include "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "splineanimation_p.h"
             #include "xychartitem_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>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 1000;
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
             void ChartAnimator::addAnimation(AxisItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new AxisAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(SplineChartItem*  item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new SplineAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(ScatterChartItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(LineChartItem*  item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new XYAnimation(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(ChartItem* item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
             void ChartAnimator::updateLayout(AxisItem* 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()==AxisItem::X_AXIS?rect.left():rect.bottom();
                 				oldLayout[j]= item->axisType()==AxisItem::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);
             			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()==AxisItem::X_AXIS?rect.left():rect.top();
             			}
             		}
             		break;
             	}
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 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::updateLayout(SplineChartItem* item, QVector<QPointF>& oldPoints ,QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newControlPoints,int index)
             {
                 SplineAnimation* animation = static_cast<SplineAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if(newPoints.count()<2 || newControlPoints.count()<2) return;
                 bool empty = oldPoints.count()==0;
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                      animation->stop();
                 }
                 animation->setDuration(duration);
                 if(!empty)
                 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints,newPoints,oldControlPoints,newControlPoints,index);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::updateLayout(XYChartItem* item,  QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, int index)
             {
                 XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if(newPoints.count()==0) return;
                 bool empty = oldPoints.count()==0;
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 if(!empty)
                 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints,newPoints,index);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->addSlice(slice, sliceData, isEmpty);
             }
             void ChartAnimator::removeAnimation(PieChartItem* item, QPieSlice *slice)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->removeSlice(slice);
             }
             void ChartAnimator::updateLayout(PieChartItem* item, const PieLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValues(layout);
             }
             void ChartAnimator::updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(slice, sliceData);
             }
+            void ChartAnimator::updateLayout(BarChartItem* item, const BarLayout &layout)
+            {
+                qDebug() << "ChartAnimator::updateLayout";
+                BarAnimation* animation = static_cast<BarAnimation*>(m_animations.value(item));
+                Q_ASSERT(animation);
+                animation->updateValues(layout);
+            }
             void ChartAnimator::setState(State state,const QPointF& point)
             {
             	m_state=state;
             	m_point=point;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +4 0

             #ifndef CHARTANIMATOR_P_H_
             #define CHARTANIMATOR_P_H_
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
+            #include "barchartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class LineChartItem;
             class XYChartItem;
             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};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
                 void addAnimation(AxisItem* 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 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 addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem* item, QPieSlice *slice);
                 void updateLayout(PieChartItem* item, const PieLayout &layout);
                 void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData);
+                void updateLayout(BarChartItem* item, const BarLayout &layout);
                 void setState(State state,const QPointF& point = QPointF());
             private:
                  QMap<ChartItem*,ChartAnimation*> m_animations;
                  State m_state;
                  QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/barchartitem.cpp +36 0

             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
+            #include "chartanimator_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, QChart *parent) :
                 ChartItem(parent),
                 mHeight(0),
                 mWidth(0),
                 mLayoutSet(false),
                 mSeries(series),
                 mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(layoutChanged()));
+            //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
+                connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 initAxisLabels();
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return QRectF(0, 0, mWidth, mHeight);
             }
             void BarChartItem::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 mBars.clear();
                 mFloatingValues.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.append(bar);
                         connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
                         connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
                         connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
                     }
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->categoryCount(); category++) {
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
                         connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
                     }
                 }
             }
             void BarChartItem::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarChartitem::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 int categoryCount = mSeries->categoryCount();
                 int setCount = mSeries->barsetCount();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mSeries->max();
                 qreal scale = (tH/tM);
                 qreal tC = categoryCount + 1;
                 qreal categoryWidth = tW/tC;
                 mBarWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + categoryWidth /2 + mBarWidth/2;
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarWidth, barHeight);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category + categoryWidth/2 + mBarWidth;
                     qreal yPos = mHeight;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                 }
                 update();
             }
+            BarLayout BarChartItem::calculateLayout()
+            {
+                BarLayout layout;
+                foreach(Bar* bar, mBars) {
+                    layout.insert(bar,bar->boundingRect().size());
+                }
+                return layout;
+            }
+            void BarChartItem::applyLayout(const BarLayout &layout)
+            {
+                if (m_animator)
+                    m_animator->updateLayout(this, layout);
+                else
+                    setLayout(layout);
+            }
+            void BarChartItem::setLayout(const BarLayout &layout)
+            {
+                foreach (Bar *bar, layout.keys()) {
+                    bar->setSize(layout.value(bar));
+                }
+                update();
+            }
             void BarChartItem::initAxisLabels()
             {
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 mChart->axisX()->setTicksCount(count+2);
                 qreal min = 0;
                 qreal max = count+1;
                 mChart->axisX()->setMin(min);
                 mChart->axisX()->setMax(max);
                 QChartAxisCategories* categories = mChart->axisX()->categories();
                 categories->clear();
                 for (int i=0; i<count; i++) {
                     categories->insert(i+1,mSeries->categoryName(i));
                 }
                 mChart->axisX()->setLabelsVisible(true);
             }
             //handlers
             void BarChartItem::handleModelChanged(int index)
             {
                 Q_UNUSED(index)
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 // TODO:
                 Q_UNUSED(minX)
                 Q_UNUSED(maxX)
                 Q_UNUSED(minY)
                 Q_UNUSED(maxY)
                 /*
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 // Position labels to domain
                 qreal min = domain.minX();
                 qreal max = domain.maxX();
                 qreal step = (max-min)/count;
                 QChartAxisCategories& categories = mChart->axisX()->categories();
                 categories.clear();
                 for (int i=0; i<count; i++) {
                     categories.insert(min,mSeries->categoryName(i));
                     min += step;
                 }
                 */
             }
             void BarChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
+            void BarChartItem::handleLayoutChanged()
+            {
+                BarLayout layout = calculateLayout();
+                applyLayout(layout);
+                update();
+            }
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h +8 -1

             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class BarValue;
             class QChartAxisCategories;
             class QChart;
-            // Common implemantation of different presenters.
+            typedef QHash<Bar*, QSizeF> BarLayout;
             class BarChartItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QBarSeries *series, QChart *parent = 0);
                 virtual ~BarChartItem();
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
             private slots:
                 virtual void layoutChanged();   // layout has changed -> need to recalculate bar sizes
+            public:
+                BarLayout calculateLayout();
+                void applyLayout(const BarLayout &layout);
+                void setLayout(const BarLayout &layout);
             protected:
                 void initAxisLabels();
             public slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
+                void handleLayoutChanged();
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 qreal mBarWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 // Not owned.
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
                 QList<BarValue*> mFloatingValues;
                 QChart* mChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/chartpresenter.cpp +3 -3

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
                 m_themeForce(false)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault,false);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_chart->padding(),m_chart->padding(), -m_chart->padding(), -m_chart->padding());
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             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);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* 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 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarChartItem* bar = new BarChartItem(barSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
-                     //  m_animator->addAnimation(bar);
+                        m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
-                     //  m_animator->addAnimation(bar);
+                        m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
-                     //  m_animator->addAnimation(bar);
+                        m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(pieSeries, this, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme,bool force)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart,m_themeForce);
                 m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_chart->padding(), -m_chart->padding());
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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