HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2316:74962bdcee07

Bar animations refactored

Marek Rosa -

r2316:74962bdcee07

parent child

Context file:

r2316:74962bdcee07

Expand all files

src/animations/animations.pri +2 -14

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/axisanimation.cpp \
                 $$PWD/xyanimation.cpp \
                 $$PWD/pieanimation.cpp \
                 $$PWD/piesliceanimation.cpp \
                 $$PWD/splineanimation.cpp \
-                $$PWD/baranimation.cpp \
+                $$PWD/baranimation.cpp
-                $$PWD/stackedbaranimation.cpp \
-                $$PWD/percentbaranimation.cpp \
-                $$PWD/abstractbaranimation.cpp \
-                $$PWD/horizontalbaranimation.cpp \
-                $$PWD/horizontalstackedbaranimation.cpp \
-                $$PWD/horizontalpercentbaranimation.cpp
             PRIVATE_HEADERS += \
                 $$PWD/axisanimation_p.h \
                 $$PWD/chartanimation_p.h \
                 $$PWD/xyanimation_p.h \
                 $$PWD/pieanimation_p.h \
                 $$PWD/piesliceanimation_p.h \
                 $$PWD/splineanimation_p.h \
-                $$PWD/baranimation_p.h \
+                $$PWD/baranimation_p.h
-                $$PWD/stackedbaranimation_p.h \
-                $$PWD/percentbaranimation_p.h \
-                $$PWD/abstractbaranimation_p.h \
-                $$PWD/horizontalbaranimation_p.h \
-                $$PWD/horizontalstackedbaranimation_p.h \
-                $$PWD/horizontalpercentbaranimation_p.h

src/animations/baranimation.cpp +24 -17

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "baranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarAnimation::BarAnimation(AbstractBarChartItem *item)
-                : AbstractBarAnimation(item)
+                : ChartAnimation(item),
+                  m_item(item)
             {
+                setDuration(ChartAnimationDuration);
+                setEasingCurve(QEasingCurve::OutQuart);
             }
             BarAnimation::~BarAnimation()
             {
             }
             QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
             {
                 QVector<QRectF> startVector = qvariant_cast<QVector<QRectF> >(from);
                 QVector<QRectF> endVector = qvariant_cast<QVector<QRectF> >(to);
                 QVector<QRectF> result;
                 Q_ASSERT(startVector.count() == endVector.count());
                 for (int i = 0; i < startVector.count(); i++) {
                     QRectF start = startVector[i].normalized();
                     QRectF end = endVector[i].normalized();
+                    qreal x1 = start.left() + progress * (end.left() - start.left());
+                    qreal x2 = start.right() + progress * (end.right() - start.right());
+                    qreal y1 = start.top() + progress * (end.top() - start.top());
+                    qreal y2 = start.bottom() + progress * (end.bottom() - start.bottom());
-                    qreal x = end.left();
+                    QRectF value(QPointF(x1, y1), QPointF(x2, y2));
-                    qreal y;
-                    qreal w = end.width();
-                    qreal h;
-                    if (endVector[i].height() < 0) {
-                        // Negative bar
-                        y = end.top();
-                        h = start.height() + ((end.height() - start.height()) * progress);
-                    } else {
-                        h = startVector[i].height() + ((endVector[i].height() - startVector[i].height()) * progress);
-                        y = endVector[i].top() + endVector[i].height() - h;
-                    QRectF value(x, y, w, h);
                     result << value.normalized();
                 }
                 return qVariantFromValue(result);
             }
+            void BarAnimation::updateCurrentValue(const QVariant &value)
+            {
+                QVector<QRectF> layout = qvariant_cast<QVector<QRectF> >(value);
+                m_item->setLayout(layout);
+            }
+            void BarAnimation::setup(const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
+            {
+                QVariantAnimation::KeyValues value;
+                setKeyValues(value); //workaround for wrong interpolation call
+                setKeyValueAt(0.0, qVariantFromValue(oldLayout));
+                setKeyValueAt(1.0, qVariantFromValue(newLayout));
+            }
             #include "moc_baranimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/baranimation_p.h +10 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
-            #ifndef BARANIMATION_P_H
+            #ifndef ABSTRACTBARANIMATION_P_H
-            #define BARANIMATION_P_H
+            #define ABSTRACTBARANIMATION_P_H
-            #include "abstractbaranimation_p.h"
             #include "chartanimation_p.h"
-            #include "abstractbarchartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AbstractBarChartItem;
-            class BarAnimation : public AbstractBarAnimation
+            class BarAnimation : public ChartAnimation
             {
                 Q_OBJECT
             public:
                 BarAnimation(AbstractBarChartItem *item);
                 ~BarAnimation();
             public: // from QVariantAnimation
                 virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
+                virtual void updateCurrentValue(const QVariant &value);
+                void setup(const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
+            protected:
+                AbstractBarChartItem *m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif
+            #endif // ABSTRACTBARANIMATION_P_H

src/barchart/abstractbarchartitem.cpp +17 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
-            #include "abstractbaranimation_p.h"
+            #include "baranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
                 handleVisibleChanged();
                 handleUpdatedBars();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
-                if (m_animation) {
+                QSizeF size = geometry().size();
-                    m_animation->setup(m_layout, layout);
+                if (geometry().size().isValid()) {
-                    presenter()->startAnimation(m_animation);
+                    if (m_animation) {
-                } else {
+                        if (m_layout.count() == 0 || m_oldSize != size) {
-                    setLayout(layout);
+                            initializeLayout();
-                    update();
+                            m_oldSize = size;
+                        }
+                        m_animation->setup(m_layout, layout);
+                        presenter()->startAnimation(m_animation);
+                    } else {
+                        setLayout(layout);
+                        update();
+                    }
                 }
             }
-            void AbstractBarChartItem::setAnimation(AbstractBarAnimation *animation)
+            void AbstractBarChartItem::setAnimation(BarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i = 0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                     QGraphicsSimpleTextItem *label = m_labels.at(i);
                     label->setPos(layout.at(i).center() - label->boundingRect().center());
                 }
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 QRectF rect(QPointF(0,0),domain()->size());
                 if(m_rect != rect){
                     prepareGeometryChange();
                     m_rect = rect;
                 }
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0))
                     return; // rect size zero.
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 handleUpdatedBars();
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem *label, m_labels)
                     label->setVisible(visible);
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set, c, this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), m_series, SIGNAL(hovered(bool,QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), set, SIGNAL(hovered(bool)));
-                        m_layout.append(QRectF(0, 0, 0, 0));
+                        //            m_layout.append(QRectF(0, 0, 1, 1));
                         // Labels
                         m_labels.append(new QGraphicsSimpleTextItem(this));
                     }
                 }
                 if(themeManager()) themeManager()->updateSeries(m_series);
                 handleLayoutChanged();
                 handleVisibleChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 if (visible)
                     handleLabelsVisibleChanged(m_series->isLabelsVisible());
                 else
                     handleLabelsVisibleChanged(visible);
                 foreach (QGraphicsItem *bar, m_bars)
                     bar->setVisible(visible);
             }
             void AbstractBarChartItem::handleOpacityChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     item->setOpacity(m_series->opacity());
             }
             void AbstractBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         label->setText(QString("%1").arg(barSet->value(category)));
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem_p.h +5 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef ABSTRACTBARCHARTITEM_H
             #define ABSTRACTBARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qabstractbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
-            class AbstractBarAnimation;
+            class BarAnimation;
             class AbstractBarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
                 virtual ~AbstractBarChartItem();
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual QVector<QRectF> calculateLayout() = 0;
+                virtual void initializeLayout() = 0;
                 virtual void applyLayout(const QVector<QRectF> &layout);
-                virtual void setAnimation(AbstractBarAnimation *animation);
+                virtual void setAnimation(BarAnimation *animation);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleDomainUpdated();
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items
                 void handleVisibleChanged();
                 void handleOpacityChanged();
                 virtual void handleUpdatedBars();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
-                AbstractBarAnimation *m_animation;
+                BarAnimation *m_animation;
                 QAbstractBarSeries *m_series; // Not owned.
                 QList<Bar *> m_bars;
                 QList<QGraphicsSimpleTextItem *> m_labels;
+                QSizeF m_oldSize;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTBARCHARTITEM_H

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +31 -11

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
                 : AbstractBarChartItem(series, item)
             {
             }
+            void HorizontalBarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2 + set/setCount * barWidth));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category + barWidth / 2 + (set + 1)/setCount * barWidth));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2 + set/setCount * barWidth));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2 + (set + 1)/setCount * barWidth));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> HorizontalBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
-                int itemIndex(0);
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
-                            topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2 + (set + 1)/(setCount) * barWidth));
+                            topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2 + set/setCount * barWidth));
                         else
-                            topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2 + (set + 1)/(setCount) * barWidth));
+                            topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2 + set/setCount * barWidth));
-                        QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(value, category - barWidth / 2 + (set)/(setCount) * barWidth));
+                        QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(value, category - barWidth / 2 + (set + 1)/setCount * barWidth));
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
-                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        label->setPos(rect.center() - label->boundingRect().center());
-                        label->setZValue(200);
-                        itemIndex++;
-                        label->setBrush(Qt::black);
                     }
                 }
                 return layout;
             }
             #include "moc_horizontalbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/bar/horizontalbarchartitem_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef HORIZONTALBARCHARTITEM_H
             #define HORIZONTALBARCHARTITEM_H
             #include "abstractbarchartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class HorizontalBarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 HorizontalBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // HORIZONTALBARCHARTITEM_H

src/barchart/horizontal/bar/qhorizontalbarseries.cpp 0 -13

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhorizontalbarseries.h"
             #include "qhorizontalbarseries_p.h"
             #include "horizontalbarchartitem_p.h"
-            #include "horizontalbaranimation_p.h"
             #include "qbarcategoryaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalBarSeries
                 \brief Series for creating horizontal bar chart
                 \mainclass
                 QHorizontalBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalBarChart Example} {horizontal bar chart example} to learn how to create a horizontal bar chart.
                 \image examples_horizontalbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalPercentBarSeries
             */
             /*!
                 \qmlclass HorizontalBarSeries QHorizontalBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple horizontal bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View9.qml 1
                 \beginfloatleft
                 \image demos_qmlchart9.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalBarSeries.
                 QHorizontalBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor
                 Removes series from chart.
             */
             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalBar.
             */
             QAbstractSeries::SeriesType QHorizontalBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q)
                 : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, min());
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, max());
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalBarSeries);
                 HorizontalBarChartItem *bar = new HorizontalBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QHorizontalBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                HorizontalBarChartItem *bar = static_cast<HorizontalBarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new HorizontalBarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qhorizontalbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/bar/qhorizontalbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QHORIZONTALBARSERIES_P_H
             #define QHORIZONTALBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QHorizontalBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHORIZONTALBARSERIES_P_H

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +31 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalpercentbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
                 : AbstractBarChartItem(series, item)
             {
             }
+            void HorizontalPercentBarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category + barWidth / 2));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(0, category + barWidth / 2));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft;
                         if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
-                            topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : domain()->minX(), category + barWidth/2));
+                            topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : domain()->minX(), category - barWidth/2));
                         else
-                            topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : 0, category + barWidth/2));
+                            topLeft = domain()->calculateGeometryPoint(QPointF(set ? 100 * sum/categorySum : 0, category - barWidth/2));
-                        QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(100 * (value + sum)/categorySum, category - barWidth/2));
+                        QPointF bottomRight = domain()->calculateGeometryPoint(QPointF(100 * (value + sum)/categorySum, category + barWidth/2));
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
                         sum +=value;
                     }
                 }
                 return layout;
             }
             void HorizontalPercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         int p = m_series->d_func()->percentageAt(set, category) * 100;
                         QString vString(QString::number(p));
                         vString.truncate(3);
                         vString.append("%");
                         label->setText(vString);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_horizontalpercentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/horizontalpercentbarchartitem_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef HORIZONTALPERCENTBARCHARTITEM_P_H
             #define HORIZONTALPERCENTBARCHARTITEM_P_H
             #include "abstractbarchartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class HorizontalPercentBarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
                 void handleUpdatedBars();
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // HORIZONTALPERCENTBARCHARTITEM_P_H

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhorizontalpercentbarseries.h"
             #include "qhorizontalpercentbarseries_p.h"
             #include "horizontalpercentbarchartitem_p.h"
-            #include "horizontalpercentbaranimation_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalPercentBarSeries
                 \brief Series for creating horizontal percent bar chart
                 \mainclass
                 QHorizontalPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalPercentBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalPercentBarChart Example} {horizontal percent bar chart example} to learn how to create a horizontal percent bar chart.
                 \image examples_horizontalpercentbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalBarSeries
             */
             /*!
                 \qmlclass HorizontalPercentBarSeries QHorizontalPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple horizontal percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View11.qml 1
                 \beginfloatleft
                 \image demos_qmlchart11.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalPercentBarSeries.
                 QHorizontalPercentBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalPercentBarSeries::QHorizontalPercentBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalPercentBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalPercentBar.
             */
             QAbstractSeries::SeriesType QHorizontalPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalPercentBar;
             }
             /*!
                 Destructor
                 Removes series from chart.
             */
             QHorizontalPercentBarSeries::~QHorizontalPercentBarSeries()
             {
                 Q_D(QHorizontalPercentBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalPercentBarSeriesPrivate::QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalPercentBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = 0;
                 maxX = 100;
                 minY = qMin(minY, - (qreal)0.5);
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalPercentBarSeries);
                 HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QHorizontalPercentBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                HorizontalPercentBarChartItem *bar = static_cast<HorizontalPercentBarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new HorizontalPercentBarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qhorizontalpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/qhorizontalpercentbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QHORIZONTALPERCENTBARSERIES_P_H
             #define QHORIZONTALPERCENTBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QHorizontalPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHORIZONTALPERCENTBARSERIES_P_H

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +28 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalstackedbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
                 : AbstractBarChartItem(series, item)
             {
             }
+            void HorizontalStackedBarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category - barWidth / 2));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(domain()->minX(), category + barWidth / 2));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(0, category - barWidth / 2));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(0, category + barWidth / 2));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> HorizontalStackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal positiveSum = 0;
                     qreal negativeSum = 0;
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (value < 0) {
                             bottomRight = domain()->calculateGeometryPoint(QPointF(value + negativeSum, category - barWidth / 2));
                             if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                                 topLeft = domain()->calculateGeometryPoint(QPointF(set ? negativeSum : domain()->minX(), category + barWidth / 2));
                             else
                                 topLeft = domain()->calculateGeometryPoint(QPointF(set ? negativeSum : 0, category + barWidth / 2));
                             negativeSum += value;
                         } else {
                             bottomRight = domain()->calculateGeometryPoint(QPointF(value + positiveSum, category - barWidth / 2));
                             if (domain()->type() == AbstractDomain::LogXYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                                 topLeft = domain()->calculateGeometryPoint(QPointF(set ? positiveSum : domain()->minX(), category + barWidth / 2));
                             else
                                 topLeft = domain()->calculateGeometryPoint(QPointF(set ? positiveSum : 0, category + barWidth / 2));
                             positiveSum += value;
                         }
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
                     }
                 }
                 return layout;
             }
             #include "moc_horizontalstackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/horizontalstackedbarchartitem_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef HORIZONTALSTACKEDBARCHARTITEM_P_H
             #define HORIZONTALSTACKEDBARCHARTITEM_P_H
             #include "abstractbarchartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class HorizontalStackedBarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 HorizontalStackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // HORIZONTALSTACKEDBARCHARTITEM_P_H

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhorizontalstackedbarseries.h"
             #include "qhorizontalstackedbarseries_p.h"
             #include "horizontalstackedbarchartitem_p.h"
-            #include "horizontalstackedbaranimation_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalStackedBarSeries
                 \brief Series for creating horizontal stacked bar chart
                 \mainclass
                 QHorizontalStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalStackedBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalStackedBarChart Example} {horizontal stacked bar chart example} to learn how to create a horizontal stacked bar chart.
                 \image examples_horizontalstackedbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalPercentBarSeries, QHorizontalBarSeries
             */
             /*!
                 \qmlclass HorizontalStackedBarSeries QHorizontalStackedBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple horizontal stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View10.qml 1
                 \beginfloatleft
                 \image demos_qmlchart10.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalStackedBarSeries.
                 QHorizontalStackedBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor
                 Removes series from chart.
             */
             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalStackedBar.
             */
             QAbstractSeries::SeriesType QHorizontalStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalStackedBarSeriesPrivate::QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalStackedBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, bottom());
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, top());
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QHorizontalStackedBarSeries);
                 HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QHorizontalStackedBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                HorizontalStackedBarChartItem *bar = static_cast<HorizontalStackedBarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new HorizontalStackedBarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qhorizontalstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/qhorizontalstackedbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QHORIZONTALSTACKEDBARSERIES_P_H
             #define QHORIZONTALSTACKEDBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QHorizontalStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHORIZONTALSTACKEDBARSERIES_P_H

src/barchart/qabstractbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "abstractdomain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qbarlegendmarker.h"
+            #include "baranimation_p.h"
+            #include "abstractbarchartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass AbstractBarSeries QAbstractBarSeries
                 \inherits QAbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QAbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QBarSeries
             */
             /*!
                 \qmlproperty real AbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int AbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool AbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values is a list of reals.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa AbstractBarSeries::append()
             */
             /*!
                 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successful, false otherwise.
             */
             /*!
                 \qmlmethod AbstractBarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
                 : QAbstractSeries(o, parent)
             {
                 Q_D(QAbstractSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the barset object.
                 NOTE: The series remains as the barset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QAbstractBarSeries::take(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QAbstractBarSeries::append(QList<QBarSet *> sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all barsets from the series. Deletes removed sets.
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBarSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet *> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count)
                         count = m_barSets.at(i)->count();
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0)
                     width = 0.0;
                 m_barWidth = width;
                 emit updatedLayout();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit visibleChanged();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if (qFuzzyCompare(sum, 0))
                     return 0;
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::categoryTop(int category)
             {
                 // Returns top (sum of all positive values) of category.
                 // Returns 0, if all values are negative
                 qreal top(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp > 0) {
                             top += temp;
                         }
                     }
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
             {
                 // Returns bottom (sum of all negative values) of category
                 // Returns 0, if all values are positive
                 qreal bottom(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp < 0) {
                             bottom += temp;
                         }
                     }
                 }
                 return bottom;
             }
             qreal QAbstractBarSeriesPrivate::top()
             {
                 // Returns top of all categories
                 qreal top(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryTop(i);
                     if (temp > top)
                         top = temp;
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::bottom()
             {
                 // Returns bottom of all categories
                 qreal bottom(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryBottom(i);
                     if (temp < bottom)
                         bottom = temp;
                 }
                 return bottom;
             }
             void QAbstractBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     QBarLegendMarker* marker = new QBarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 if (!m_barSets.contains(set))
                     return false; // Fail if set is not in list
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
             {
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             void QAbstractBarSeriesPrivate::initializeAxes()
             {
                 Q_Q(QAbstractBarSeries);
                 foreach(QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         switch (q->type()) {
                             case QAbstractSeries::SeriesTypeHorizontalBar:
                             case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                             case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                             if (axis->orientation() == Qt::Vertical)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                             break;
                             case QAbstractSeries::SeriesTypeBar:
                             case QAbstractSeries::SeriesTypePercentBar:
                             case QAbstractSeries::SeriesTypeStackedBar:
                             if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                             break;
                             default:
                             qWarning() << "Unexpected series type";
                             break;
                         }
                     }
                 }
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_Q(const QAbstractBarSeries);
                 switch (q->type()) {
                 case QAbstractSeries::SeriesTypeHorizontalBar:
                 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                 case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                     if (orientation == Qt::Vertical)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 case QAbstractSeries::SeriesTypeBar:
                 case QAbstractSeries::SeriesTypePercentBar:
                 case QAbstractSeries::SeriesTypeStackedBar:
                     if (orientation == Qt::Horizontal)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 default:
                     qWarning() << "Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValue;
             }
             void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < categoryCount() + 1; i++)
                         categories << QString::number(i);
                     axis->append(categories);
                 }
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 const QList<QGradient> gradients = theme->seriesGradients();
                 QBrush brush;
                 QPen pen;
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (m_barSets.count() > 1) {
                     step = 1.0 / (qreal) m_barSets.count();
                     if (m_barSets.count() % gradients.count())
                     step *= gradients.count();
                     else
                     step *= (gradients.count() - 1);
                 }
                 for (int i(0); i < m_barSets.count(); i++) {
                     int colorIndex = (index + i) % gradients.count();
                     if (i > 0 && i %gradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                         takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (forced || brush == m_barSets.at(i)->brush())
                         m_barSets.at(i)->setBrush(ChartThemeManager::colorAt(gradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (forced || brush == m_barSets.at(i)->labelBrush()) {
                         if (takeAtPos < 0.3)
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1));
                         else
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0));
                     }
                     if (forced || pen == m_barSets.at(i)->pen()) {
                         QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                         m_barSets.at(i)->setPen(c);
                     }
                 }
             }
+            void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            {
+                AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
+                    bar->setAnimation(new BarAnimation(bar));
+                }else{
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
+            }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTBARSERIES_P_H
             #define QABSTRACTBARSERIES_P_H
             #include "qabstractbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
             class QBarCategoryAxis;
             class QLegendMarker;
             class QAbstractBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QAbstractBarSeriesPrivate(QAbstractBarSeries *parent);
                 int categoryCount() const;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
                 void initializeDomain();
                 void initializeAxes();
+                void initializeAnimations(QChart::AnimationOptions options);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 QList<QLegendMarker*> createLegendMarkers(QLegend *legend);
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                 QAbstractAxis* createDefaultAxis(Qt::Orientation orientation) const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet *> sets);
                 bool remove(QList<QBarSet *> sets);
                 bool insert(int index, QBarSet *set);
                 QBarSet *barsetAt(int index);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
                 qreal minX();
                 qreal maxX();
                 qreal categoryTop(int category);
                 qreal categoryBottom(int category);
                 qreal top();
                 qreal bottom();
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void updatedBars();
                 void updatedLayout();
                 void restructuredBars();
                 void labelsVisibleChanged(bool visible);
                 void visibleChanged();
             private:
                 void populateCategories(QBarCategoryAxis *axis);
             protected:
                 QList<QBarSet *> m_barSets;
                 qreal m_barWidth;
                 bool m_labelsVisible;
                 bool m_visible;
             private:
                 Q_DECLARE_PUBLIC(QAbstractBarSeries)
                 friend class HorizontalBarChartItem;
                 friend class BarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTBARSERIES_P_H

src/barchart/vertical/bar/barchartitem.cpp +29 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
             }
+            void BarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + set/setCount * barWidth, domain()->minY()));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2 + (set + 1)/setCount * barWidth, domain()->minY()));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + set/setCount * barWidth, 0));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/setCount * barWidth, 0));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set)/(setCount) * barWidth, value));
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/(setCount) * barWidth, domain()->minY()));
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/(setCount) * barWidth, 0));
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
                     }
                 }
                 return layout;
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/barchartitem_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "abstractbarchartitem_p.h"
             #include "qstackedbarseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/vertical/bar/qbarseries.cpp 0 -13

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "barchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "baranimation_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a grouped bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeBar.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, min());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, max());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBarSeries);
                 BarChartItem *bar = new BarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                BarChartItem *bar = static_cast<BarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new BarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/qbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QBarSeriesPrivate(QBarSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIES_P_H

src/barchart/vertical/percent/percentbarchartitem.cpp +29 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
             }
+            void PercentBarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, domain()->minY()));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal sum = 0;
                     qreal categorySum = m_series->d_func()->categorySum(category);
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth/2, 100 * (value + sum)/categorySum));
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? 100 * sum/categorySum : domain()->minY()));
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? 100 * sum/categorySum : 0));
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
                         sum +=value;
                     }
                 }
                 return layout;
             }
             void PercentBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         int p = m_series->d_func()->percentageAt(set, category) * 100;
                         QString vString(QString::number(p));
                         vString.truncate(3);
                         vString.append("%");
                         label->setText(vString);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/percentbarchartitem_p.h +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PERCENTBARCHARTITEM_H
             #define PERCENTBARCHARTITEM_H
             #include "abstractbarchartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractBarSeries;
             class PercentBarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
                 void handleUpdatedBars();
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARCHARTITEM_H

src/barchart/vertical/percent/qpercentbarseries.cpp 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
-            #include "percentbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief Series for creating percent bar chart
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
                 \sa QBarSet, QStackedBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 minY = 0;
                 maxY = 100;
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem *bar = new PercentBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QPercentBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                PercentBarChartItem *bar = static_cast<PercentBarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new PercentBarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/qpercentbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QPERCENTBARSERIES_P_H
             #define QPERCENTBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QPercentBarSeriesPrivate(QPercentBarSeries *q);
                 void initializeDomain();
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
             private:
                 Q_DECLARE_PUBLIC(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/vertical/stacked/qstackedbarseries.cpp 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
-            #include "stackedbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, bottom());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, top());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem *bar = new StackedBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QStackedBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                StackedBarChartItem *bar = static_cast<StackedBarChartItem *>(m_item.data());
-                Q_ASSERT(bar);
-                if (options.testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimation(new StackedBarAnimation(bar));
-                }else{
-                    bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/qstackedbarseries_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QSTACKEDBARSERIES_P_H
             #define QSTACKEDBARSERIES_P_H
             #include "qabstractbarseries_p.h"
             #include "abstractdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QStackedBarSeriesPrivate(QStackedBarSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/vertical/stacked/stackedbarchartitem.cpp +32 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
             }
+            void StackedBarChartItem::initializeLayout()
+            {
+                qreal categoryCount = m_series->d_func()->categoryCount();
+                qreal setCount = m_series->count();
+                qreal barWidth = m_series->d_func()->barWidth();
+                m_layout.clear();
+                for(int category = 0; category < categoryCount; category++) {
+                    for (int set = 0; set < setCount; set++) {
+                        QRectF rect;
+                        QPointF topLeft;
+                        QPointF bottomRight;
+                        if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain) {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, domain()->minY()));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()));
+                        } else {
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0));
+                            bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0));
+                        }
+                        rect.setTopLeft(topLeft);
+                        rect.setBottomRight(bottomRight);
+                        m_layout.append(rect.normalized());
+                    }
+                }
+            }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 qreal barWidth = m_series->d_func()->barWidth();
                 for(int category = 0; category < categoryCount; category++) {
                     qreal positiveSum = 0;
                     qreal negativeSum = 0;
                     for (int set = 0; set < setCount; set++) {
                         qreal value = m_series->barSets().at(set)->at(category);
                         QRectF rect;
                         QPointF topLeft;
                         QPointF bottomRight;
                         if (value < 0) {
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, value + negativeSum));
                             if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                                 topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? negativeSum : domain()->minY()));
                             else
                                 topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? negativeSum : 0));
                             negativeSum += value;
                         } else {
-                            bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, value + positiveSum));
+                            topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, value + positiveSum));
                             if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
-                                topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : domain()->minY()));
+                                bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : domain()->minY()));
                             else
-                                topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : 0));
+                                bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : 0));
                             positiveSum += value;
                         }
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
-                        layout.append(rect);
+                        layout.append(rect.normalized());
                     }
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/stackedbarchartitem_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef STACKEDBARCHARTITEM_H
             #define STACKEDBARCHARTITEM_H
             #include "abstractbarchartitem_p.h"
             #include "qstackedbarseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class StackedBarChartItem : public AbstractBarChartItem
             {
                 Q_OBJECT
             public:
                 StackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item =0);
             private:
                 virtual QVector<QRectF> calculateLayout();
+                void initializeLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARCHARTITEM_H

src/animations/abstractbaranimation.cpp removed 0 -68

NO CONTENT: file was removed

src/animations/abstractbaranimation_p.h removed 0 -59

NO CONTENT: file was removed

src/animations/horizontalbaranimation.cpp removed 0 -74

NO CONTENT: file was removed

src/animations/horizontalbaranimation_p.h removed 0 -52

NO CONTENT: file was removed

src/animations/horizontalpercentbaranimation.cpp removed 0 -64

NO CONTENT: file was removed

src/animations/horizontalpercentbaranimation_p.h removed 0 -52

NO CONTENT: file was removed

src/animations/horizontalstackedbaranimation.cpp removed 0 -64

NO CONTENT: file was removed

src/animations/horizontalstackedbaranimation_p.h removed 0 -52

NO CONTENT: file was removed

src/animations/percentbaranimation.cpp removed 0 -64

NO CONTENT: file was removed

src/animations/percentbaranimation_p.h removed 0 -55

NO CONTENT: file was removed

src/animations/stackedbaranimation.cpp removed 0 -63

NO CONTENT: file was removed

src/animations/stackedbaranimation_p.h removed 0 -55

NO CONTENT: file was removed

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