HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r681:223051b363f0

barchart animation mechanics working. still some todo

sauimone -

r681:223051b363f0

parent child

Context file:

r681:223051b363f0

Collapse all files

src/animations/baranimation.cpp +16 -10

             #include <QParallelAnimationGroup>
             #include <QTimer>
-            Q_DECLARE_METATYPE(QVector<QSizeF>)
+            Q_DECLARE_METATYPE(QVector<QRectF>)
+            //Q_DECLARE_METATYPE(BarLayout)     // TODO?
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             {
             }
-            void BarAnimation::updateValues(const BarLayout& /*layout*/)
+            void BarAnimation::updateValues(const QVector<QRectF>& layout)
             {
-                // TODO:
+                // TODO?:
-                qDebug() << "BarAnimation::updateValues";
+            //    qDebug() << "BarAnimation::updateValues" << layout.count();
             }
             QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
-                QVector<QSizeF> startVector = qVariantValue<QVector<QSizeF> > (from);
+                QVector<QRectF> startVector = qVariantValue<QVector<QRectF> > (from);
-                QVector<QSizeF> endVector = qVariantValue<QVector<QSizeF> > (to);
+                QVector<QRectF> endVector = qVariantValue<QVector<QRectF> > (to);
-                QVector<QSizeF> result;
+                QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count()) ;
                 for(int i =0 ;i< startVector.count();i++){
-                       QSizeF value = startVector[i] + ((endVector[i]- endVector[i]) * progress);
+                    //QRectF value = startVector[i] + ((endVector[i] - startVector[i]) * progress);
+                    QPointF topLeft = startVector[i].topLeft() + ((endVector[i].topLeft() - startVector[i].topLeft()) * progress);
+                    QSizeF size = startVector[i].size() + ((endVector[i].size() - startVector[i].size()) * progress);
+                    QRectF value(topLeft,size);
                     result << value;
                 }
                 return qVariantFromValue(result);
             }
-            void BarAnimation::updateCurrentValue(const QVariant &)
+            void BarAnimation::updateCurrentValue(const QVariant &value)
             {
-                // TODO?
+                QVector<QRectF> layout = qVariantValue<QVector<QRectF> >(value);
+                m_item->setLayout(layout);
             }
             #include "moc_baranimation_p.cpp"

src/animations/baranimation_p.h +1 -1

                 BarAnimation(BarChartItem *item);
                 ~BarAnimation();
-                void updateValues(const BarLayout& layout);
+                void updateValues(const QVector<QRectF>& layout);
             public: // from QVariantAnimation
                 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;

src/animations/chartanimator.cpp +7 -2

             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(QVector<qreal>)
+            Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 animation->updateValue(slice, sliceData);
             }
-            void ChartAnimator::updateLayout(BarChartItem* item, const BarLayout &layout)
+            void ChartAnimator::updateLayout(BarChartItem* item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
             {
                 qDebug() << "ChartAnimator::updateLayout";
                 BarAnimation* animation = static_cast<BarAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->updateValues(layout);
+            //    animation->updateValues(layout);
+                animation->setDuration(duration);
+                animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
+                animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
+                QTimer::singleShot(0,animation,SLOT(start()));
             }

src/animations/chartanimator_p.h +1 -1

                 void updateLayout(PieChartItem* item, const PieLayout &layout);
                 void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData);
-                void updateLayout(BarChartItem* item, const BarLayout &layout);
+                void updateLayout(BarChartItem* item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
                 void setState(State state,const QPointF& point = QPointF());

src/barchart/barchartitem.cpp +100 -12

                 mSeries(series)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
-                connect(series, SIGNAL(updatedBars()), this, SLOT(layoutChanged()));
+                connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                 connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 mBars.clear();
                 mFloatingValues.clear();
+                mLayout.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
                         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()));
+                        mLayout.append(QRectF(0,0,0,0));
                     }
                 }
                     }
                 }
             }
+            /*
             void BarChartItem::layoutChanged()
             {
+                qDebug() << "Deprecated BarChartItem::layoutChanged called. aborting";
+                return;
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                 qreal categoryWidth = width/categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
+                BarLayout layout;
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category  + barWidth/2;
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
+                        QRectF rect(xPos,yPos-barHeight,mBarWidth,barHeight);
+                        layout.insert(bar,rect);
                         // TODO: width settable per bar?
                         bar->setRect(xPos, yPos-barHeight,barWidth, barHeight);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
+            //            bar->resize(mBarWidth, barHeight);
+            //            layout.insert(bar,QSizeF(mBarWidth,barHeight));
+                        bar->setPen(mSeries->barsetAt(set)->pen());
+                        bar->setBrush(mSeries->barsetAt(set)->brush());
+            //            bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += barWidth;
                     }
                         xPos += barWidth;
                     }
                 }
-                update();
+            //    update();
             }
+            */
-            BarLayout BarChartItem::calculateLayout()
+            QVector<QRectF> BarChartItem::calculateLayout()
             {
+            //    layoutChanged();
+            /*
                 BarLayout layout;
                 foreach(Bar* bar, mBars) {
                     layout.insert(bar,bar->boundingRect());
                 }
+            */
+                QVector<QRectF> layout;
+                // 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();
+                // Domain:
+                if (mDomainMaxY > tM) {
+                    tM = mDomainMaxY;
+                }
+                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);
+                        QRectF rect(xPos,yPos-barHeight,mBarWidth,barHeight);
+                        //layout.insert(bar,rect);
+                        layout.append(rect);
+                        // TODO: width settable per bar?
+            //            bar->resize(mBarWidth, barHeight);
+            //            layout.insert(bar,QSizeF(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;
+                    }
+                }
                 return layout;
             }
-            void BarChartItem::applyLayout(const BarLayout &layout)
+            void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
-                    animator()->updateLayout(this, layout);
+                    animator()->updateLayout(this, mLayout, layout);
                 else
                     setLayout(layout);
             }
-            void BarChartItem::setLayout(const BarLayout &layout)
+            void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
-                foreach (Bar *bar, layout.keys()) {
+                mLayout = layout;
-                    bar->setRect(layout.value(bar));
+                for (int i=0; i<mBars.count(); i++) {
+                    //mBars.at(i)->setSize(layout.at(i).size());
+                    //mBars.at(i)->setPos(layout.at(i).topLeft());
+                    mBars.at(i)->setRect(layout.at(i));
                 }
                 update();
             }
                 mDomainMaxX = maxX;
                 mDomainMinY = minY;
                 mDomainMaxY = maxY;
-                layoutChanged();
+                handleLayoutChanged();
                 /*
                 int count = mSeries->categoryCount();
             void BarChartItem::handleLayoutChanged()
             {
-                BarLayout layout = calculateLayout();
+                qDebug() << "BarChartItem::handleLayoutChanged";
+                QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }

src/barchart/barchartitem_p.h +7 -5

             class QChartAxisCategories;
             class QChart;
-            typedef QHash<Bar*, QRectF> BarLayout;
+            //typedef QVector<QRectF> BarLayout;
             class BarChartItem : public ChartItem
             {
                 // 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
+                //virtual void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             public:
-                BarLayout calculateLayout();
+                QVector<QRectF> calculateLayout();
-                void applyLayout(const BarLayout &layout);
+                void applyLayout(const QVector<QRectF> &layout);
-                void setLayout(const BarLayout &layout);
+                void setLayout(const QVector<QRectF> &layout);
+                void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
                 QRectF m_rect;
                 bool mLayoutSet;    // True, if component has been laid out.
+                QVector<QRectF> mLayout;
                 // Not owned.
                 QBarSeries* mSeries;

src/barchart/qbarseries.cpp +3 0

             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
+                qDebug() << "add bar set";
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 connect(set, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
+                emit updatedBars();
             }
             /*!
                 disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
+                emit updatedBars();
             }
             void QBarSeries::insertBarSet(int i, QBarSet *set)

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