HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r635:c28f6c761b2a

Renames axisitem applyLayout to updateLayout

Michal Klocek -

r635:c28f6c761b2a

parent child

Context file:

r635:c28f6c761b2a

Collapse all files

src/animations/chartanimator.cpp +1 -1

             #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 "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::removeAnimation(ChartItem* item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
-            void ChartAnimator::applyLayout(AxisItem* item , QVector<qreal>& newLayout)
+            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 PieSliceLayout &layout, bool isEmpty)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->addSlice(slice, layout, 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 PieSliceLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(slice, layout);
             }
             void ChartAnimator::setState(State state,const QPointF& point)
             {
             	m_state=state;
             	m_point=point;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +1 -1

             #ifndef CHARTANIMATOR_P_H_
             #define CHARTANIMATOR_P_H_
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_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 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 applyLayout(AxisItem* item, QVector<qreal>& layout);
+                void updateLayout(AxisItem* item, QVector<qreal>& layout);
                 void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout, bool isEmpty);
                 void removeAnimation(PieChartItem* item, QPieSlice *slice);
                 void updateLayout(PieChartItem* item, const PieLayout &layout);
                 void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &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/axis/axisitem.cpp +1 -1

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_presenter(presenter),
             m_chartAxis(axis),
             m_type(type),
             m_labelsAngle(0),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent),
             m_axis(parent),
             m_min(0),
             m_max(0),
             m_ticksCount(0)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
                 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()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return QRectF();
             }
             void AxisItem::createItems(int count)
             {
                 if(m_axis.children().size()==0)
                        m_axis.addToGroup(new QGraphicsLineItem());
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem());
                        m_labels.addToGroup(new QGraphicsSimpleTextItem());
                        m_axis.addToGroup(new QGraphicsLineItem());
                       if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
                    }
             }
             void AxisItem::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 QList<QGraphicsItem *> axis = m_axis.childItems();
                 for (int i = 0; i < count; ++i) {
                     if(lines.size()%2 && lines.size()>1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void AxisItem::updateLayout(QVector<qreal>& layout)
             {
                 if(m_animator){
-                   m_animator->applyLayout(this,layout);
+                   m_animator->updateLayout(this,layout);
                 }
                 else setLayout(layout);
             }
             QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>0);
                 QStringList labels;
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 for(int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     if(categories->count()==0) {
                         labels << QString::number(value);
                     }
                     else {
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return labels;
             }
             void AxisItem::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal AxisItem::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setAxisPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> AxisItem::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i] = x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
             void AxisItem::setLayout(QVector<qreal>& layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
             	if(diff>0) {
             		deleteItems(diff);
             	}
             	else if(diff<0) {
             		createItems(-diff);
             	}
             	if(diff!=0) handleAxisUpdated();
                 QStringList ticksList = createLabels(layout.size(),m_min,m_max);
             	QList<QGraphicsItem *> lines = m_grid.childItems();
             	QList<QGraphicsItem *> labels = m_labels.childItems();
             	QList<QGraphicsItem *> shades = m_shades.childItems();
             	QList<QGraphicsItem *> axis = m_axis.childItems();
             	Q_ASSERT(labels.size() == ticksList.size());
             	Q_ASSERT(layout.size() == ticksList.size());
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
             				labelItem->setText(ticksList.at(i));
             				QPointF center = labelItem->boundingRect().center();
             				labelItem->setTransformOriginPoint(center.x(), center.y());
             				labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
             				if((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
             				labelItem->setText(ticksList.at(i));
             				QPointF center = labelItem->boundingRect().center();
             				labelItem->setTransformOriginPoint(center.x(), center.y());
             				labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
             				if((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
             			}
             		}
             		break;
             		default:
             		qDebug()<<"Unknown axis type";
             		break;
             	}
             	m_layoutVector=layout;
             }
             bool AxisItem::isEmpty()
             {
                 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
             }
             //handlers
             void AxisItem::handleAxisCategoriesUpdated()
             {
             	if(isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void AxisItem::handleAxisUpdated()
             {
                 if(isEmpty()) return;
                 if(m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(m_chartAxis->labelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void AxisItem::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if(min==max || tickCount<2) return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if(isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 if(isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             //painter
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_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