HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2802:458692a5a594

Added support for bar series value label angle...

Miikka Heikkinen -

r2802:458692a5a594

parent child

Context file:

r2802:458692a5a594

Collapse all files

src/charts/barchart/abstractbarchartitem.cpp +91 -9

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/abstractbarchartitem_p.h>
             #include <private/bar_p.h>
             #include <QtCharts/QBarSet>
             #include <private/qbarset_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <private/qabstractbarseries_p.h>
             #include <QtCharts/QChart>
             #include <private/chartpresenter_p.h>
             #include <private/charttheme_p.h>
             #include <private/baranimation_p.h>
             #include <private/chartdataset_p.h>
             #include <QtGui/QPainter>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 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()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(handleUpdatedBars()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
+                connect(series, SIGNAL(labelsAngleChanged(qreal)), this, SLOT(positionLabels()));
                 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)
             {
                 QSizeF size = geometry().size();
                 if (geometry().size().isValid()) {
                     if (m_animation) {
                         if (m_layout.count() == 0 || m_oldSize != size) {
                             initializeLayout();
                             m_oldSize = size;
                         }
                         m_animation->setup(m_layout, layout);
                         presenter()->startAnimation(m_animation);
                     } else {
                         setLayout(layout);
                         update();
                     }
                 }
             }
             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));
                 positionLabels();
             }
             //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 (QGraphicsTextItem *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, int, QBarSet*)), m_series, SIGNAL(hovered(bool, int, QBarSet*)));
                         connect(bar, SIGNAL(pressed(int, QBarSet*)), m_series, SIGNAL(pressed(int, QBarSet*)));
                         connect(bar, SIGNAL(released(int, QBarSet*)),
                                 m_series, SIGNAL(released(int, QBarSet*)));
                         connect(bar, SIGNAL(doubleClicked(int, QBarSet*)),
                                 m_series, SIGNAL(doubleClicked(int, QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool, int, QBarSet*)), set, SIGNAL(hovered(bool, int)));
                         connect(bar, SIGNAL(pressed(int, QBarSet*)), set, SIGNAL(pressed(int)));
                         connect(bar, SIGNAL(released(int, QBarSet*)), set, SIGNAL(released(int)));
                         connect(bar, SIGNAL(doubleClicked(int, QBarSet*)), set, SIGNAL(doubleClicked(int)));
                         //            m_layout.append(QRectF(0, 0, 1, 1));
                         // Labels
                         QGraphicsTextItem *newLabel = new QGraphicsTextItem(this);
                         newLabel->document()->setDocumentMargin(ChartPresenter::textMargin());
                         m_labels.append(newLabel);
                     }
                 }
                 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()
             {
                 if (!m_series->d_func()->blockBarUpdate()) {
                     // Handle changes in pen, brush, labels etc.
                     int categoryCount = m_series->d_func()->categoryCount();
                     int setCount = m_series->count();
                     int itemIndex(0);
                     static const QString valueTag(QLatin1String("@value"));
                     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();
                             QGraphicsTextItem *label = m_labels.at(itemIndex);
                             QString valueLabel;
                             if (presenter()) { // At startup presenter is not yet set, yet somehow update comes
                                 if (m_series->labelsFormat().isEmpty()) {
                                     valueLabel = presenter()->numberToString(barSet->value(category));
                                 } else {
                                     valueLabel = m_series->labelsFormat();
                                     valueLabel.replace(valueTag,
                                                        presenter()->numberToString(barSet->value(category)));
                                 }
                             }
                             label->setHtml(valueLabel);
                             label->setFont(barSet->m_labelFont);
                             label->setDefaultTextColor(barSet->m_labelBrush.color());
                             label->update();
                             itemIndex++;
                         }
                     }
                 }
             }
             void AbstractBarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void AbstractBarChartItem::positionLabels()
             {
+                // By default position labels on horizontal bar series
+                // Vertical bar series overload positionLabels() to call positionLabelsVertical()
+                QTransform transform;
+                const qreal angle = m_series->d_func()->labelsAngle();
+                if (angle != 0.0)
+                    transform.rotate(angle);
                 for (int i = 0; i < m_layout.count(); i++) {
                     QGraphicsTextItem *label = m_labels.at(i);
+                    QRectF labelRect = label->boundingRect();
+                    QPointF center = labelRect.center();
                     qreal xPos = 0;
-                    qreal yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
+                    qreal yPos = m_layout.at(i).center().y() - center.y();
+                    int xDiff = 0;
+                    if (angle != 0.0) {
+                        label->setTransformOriginPoint(center.x(), center.y());
+                        label->setRotation(m_series->d_func()->labelsAngle());
+                        qreal oldWidth = labelRect.width();
+                        labelRect = transform.mapRect(labelRect);
+                        xDiff = (labelRect.width() - oldWidth) / 2;
+                    }
                     int offset = m_bars.at(i)->pen().width() / 2 + 2;
-                    if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
-                        xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
+                    switch (m_series->labelsPosition()) {
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
+                    case QAbstractBarSeries::LabelsCenter:
-                        xPos = m_layout.at(i).right() - label->boundingRect().width() - offset;
+                        xPos = m_layout.at(i).center().x() - center.x();
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
+                        break;
-                        xPos = m_layout.at(i).left() + offset;
+                    case QAbstractBarSeries::LabelsInsideEnd:
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
+                        xPos = m_layout.at(i).right() - labelRect.width() - offset + xDiff;
-                        xPos = m_layout.at(i).right() + offset;
+                        break;
+                    case QAbstractBarSeries::LabelsInsideBase:
+                        xPos = m_layout.at(i).left() + offset + xDiff;
+                        break;
+                    case QAbstractBarSeries::LabelsOutsideEnd:
+                        xPos = m_layout.at(i).right() + offset + xDiff;
+                        break;
+                    default:
+                        // Invalid position, never comes here
+                        break;
+                    }
+                    label->setPos(xPos, yPos);
+                    label->setZValue(zValue() + 1);
+                }
+            }
+            void AbstractBarChartItem::positionLabelsVertical()
+            {
+                QTransform transform;
+                const qreal angle = m_series->d_func()->labelsAngle();
+                if (angle != 0.0)
+                    transform.rotate(angle);
+                for (int i = 0; i < m_layout.count(); i++) {
+                    QGraphicsTextItem *label = m_labels.at(i);
+                    QRectF labelRect = label->boundingRect();
+                    QPointF center = labelRect.center();
+                    qreal xPos = m_layout.at(i).center().x() - center.x();
+                    qreal yPos = 0;
+                    int yDiff = 0;
+                    if (angle != 0.0) {
+                        label->setTransformOriginPoint(center.x(), center.y());
+                        label->setRotation(m_series->d_func()->labelsAngle());
+                        qreal oldHeight = labelRect.height();
+                        labelRect = transform.mapRect(labelRect);
+                        yDiff = (labelRect.height() - oldHeight) / 2;
+                    }
+                    int offset = m_bars.at(i)->pen().width() / 2 + 2;
+                    switch (m_series->labelsPosition()) {
+                    case QAbstractBarSeries::LabelsCenter:
+                        yPos = m_layout.at(i).center().y() - center.y();
+                        break;
+                    case QAbstractBarSeries::LabelsInsideEnd:
+                        yPos = m_layout.at(i).top() + offset + yDiff;
+                        break;
+                    case QAbstractBarSeries::LabelsInsideBase:
+                        yPos = m_layout.at(i).bottom() - labelRect.height() - offset + yDiff;
+                        break;
+                    case QAbstractBarSeries::LabelsOutsideEnd:
+                        yPos = m_layout.at(i).top() - labelRect.height() - offset + yDiff;
+                        break;
+                    default:
+                        // Invalid position, never comes here
+                        break;
+                    }
                     label->setPos(xPos, yPos);
                     label->setZValue(zValue() + 1);
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/abstractbarchartitem_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise 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 <private/chartitem_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtGui/QPen>
             #include <QtGui/QBrush>
             QT_CHARTS_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
             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(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();
                 void handleLabelsPositionChanged();
                 virtual void positionLabels();
             protected:
+                void positionLabelsVertical();
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
                 BarAnimation *m_animation;
                 QAbstractBarSeries *m_series; // Not owned.
                 QList<Bar *> m_bars;
                 QList<QGraphicsTextItem *> m_labels;
                 QSizeF m_oldSize;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // ABSTRACTBARCHARTITEM_H

src/charts/barchart/qabstractbarseries.cpp +39 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractBarSeries>
             #include <private/qabstractbarseries_p.h>
             #include <QtCharts/QBarSet>
             #include <private/qbarset_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QBarLegendMarker>
             #include <private/baranimation_p.h>
             #include <private/abstractbarchartitem_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
                 \inmodule Qt Charts
                 \brief Series for creating a bar chart.
                 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
             */
             /*!
                 \qmltype AbstractBarSeries
                 \instantiates QAbstractBarSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief Series type for creating a bar chart.
                 The following QML shows how to create a simple bar chart:
                 \snippet qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image examples_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a BarCategoriesAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \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
             */
             /*!
                 \property QAbstractBarSeries::labelsFormat
                 The \a format used for showing labels in series.
                 QAbstractBarSeries supports the following format tag:
                 \table
                   \row
                     \li @value      \li The value of the bar
                 \endtable
                 For example, the following usage of the format tags would produce labels that show the value
                 followed by unit ('u'):
                 \code
                 series->setLabelsFormat("@value u");
                 \endcode
                 By default, the labels shows the value of the bar. For percent bar series '%' is added after
                 the value. The labels are shown on the plot area, labels on the edge of the plot area are cut.
                 If the bars are close to each other the labels may overlap.
                 \sa QAbstractBarSeries::labelsVisible, QAbstractBarSeries::labelsPosition
             */
             /*!
                 \qmlproperty string AbstractBarSeries::labelsFormat
                 The format used for showing labels in series.
                 \sa QAbstractBarSeries::labelsFormat, labelsVisible, labelsPosition
             */
             /*!
                 \fn void QAbstractBarSeries::labelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data value labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data value labels is changed.
             */
             /*!
              \enum QAbstractBarSeries::LabelsPosition
              This enum describes the position of the data value labels.
              \value LabelsCenter Label is in the center of the bar.
              \value LabelsInsideEnd Label is inside the bar at the high end of it.
              \value LabelsInsideBase Label is inside the bar at the low end of it.
              \value LabelsOutsideEnd Label is outside the bar at the high end of it.
              */
             /*!
                 \property QAbstractBarSeries::labelsPosition
                 Defines the \a position of value labels.
                 \sa QAbstractBarSeries::labelsVisible, QAbstractBarSeries::labelsFormat
             */
             /*!
                 \qmlproperty string AbstractBarSeries::labelsPosition
                 Defines the \a position of value labels.
                 \sa labelsVisible, labelsFormat
             */
             /*!
                 \fn void QAbstractBarSeries::labelsPositionChanged(QAbstractBarSeries::LabelsPosition position)
                 Signal is emitted when the \a position of value labels is changed.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onLabelsPositionChanged(LabelsPosition position)
                 Signal is emitted when the \a position of value labels is changed.
             */
             /*!
+                \property QAbstractBarSeries::labelsAngle
+                The angle of the value labels in degrees.
+            */
+            /*!
+                \qmlproperty qreal QAbstractBarSeries::labelsAngle
+                The angle of the value labels in degrees.
+            */
+            /*!
+                \fn void QAbstractBarSeries::labelsAngleChanged(qreal angle)
+                Signal is emitted when the \a angle of the value labels is changed.
+            */
+            /*!
+                \qmlsignal AbstractBarSeries::onLabelsAngleChanged(qreal angle)
+                Signal is emitted when the \a angle of the value labels is changed.
+            */
+            /*!
                 \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::pressed(int index, QBarSet *barset)
                 The signal is emitted if the user presses with a mouse on top of QBarSet \a barset.
                 Pressed bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onPressed(int index, BarSet barset)
                 The signal is emitted if the user presses with a mouse on top of BarSet.
                 Pressed bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::released(int index, QBarSet *barset)
                 The signal is emitted if the user releases with a mouse on top of QBarSet \a barset.
                 Released bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onReleased(int index, BarSet barset)
                 The signal is emitted if the user releases with a mouse on top of BarSet.
                 Released bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::doubleClicked(int index, QBarSet *barset)
                 The signal is emitted if the user doubleclicks with a mouse on top of QBarSet \a barset.
                 DoubleClicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onDoubleClicked(int index, BarSet barset)
                 The signal is emitted if the user doubleclicks with a mouse on top of BarSet.
                 Doubleclicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::hovered(bool status, int index, 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.
                 Hovered bar inside the set is indexed by \a index.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onHovered(bool status, int index, 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.
                 Hovered bar inside the set is indexed by \a index.
             */
             /*!
                 \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) {
                     foreach (QBarSet *set, sets)
                         set->setParent(this);
                     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;
             }
             void QAbstractBarSeries::setLabelsFormat(const QString &format)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsFormat != format) {
                     d->m_labelsFormat = format;
                     emit labelsFormatChanged(format);
                 }
             }
             QString QAbstractBarSeries::labelsFormat() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsFormat;
             }
+            void QAbstractBarSeries::setLabelsAngle(qreal angle)
+            {
+                Q_D(QAbstractBarSeries);
+                if (d->m_labelsAngle != angle) {
+                    d->m_labelsAngle = angle;
+                    emit labelsAngleChanged(angle);
+                }
+            }
+            qreal QAbstractBarSeries::labelsAngle() const
+            {
+                Q_D(const QAbstractBarSeries);
+                return d->m_labelsAngle;
+            }
             void QAbstractBarSeries::setLabelsPosition(QAbstractBarSeries::LabelsPosition position)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsPosition != position) {
                     d->m_labelsPosition = position;
                     emit labelsPositionChanged(position);
                 }
             }
             QAbstractBarSeries::LabelsPosition QAbstractBarSeries::labelsPosition() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsPosition;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true),
                 m_blockBarUpdate(false),
                 m_labelsFormat(),
-                m_labelsPosition(QAbstractBarSeries::LabelsCenter)
+                m_labelsPosition(QAbstractBarSeries::LabelsCenter),
+                m_labelsAngle(0)
             {
             }
             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;
             }
             bool QAbstractBarSeriesPrivate::blockBarUpdate()
             {
                 return m_blockBarUpdate;
             }
+            qreal QAbstractBarSeriesPrivate::labelsAngle() const
+            {
+                return m_labelsAngle;
+            }
             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:
                         case QAbstractSeries::SeriesTypeBoxPlot:
                             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:
                 case QAbstractSeries::SeriesTypeBoxPlot:
                     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 << presenter()->numberToString(i);
                     axis->append(categories);
                 }
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 if (defaultAxisType(orientation) == QAbstractAxis::AxisTypeBarCategory)
                     return new QBarCategoryAxis;
                 else
                     return new QValueAxis;
             }
             void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 m_blockBarUpdate = true; // Ensures that the bars are not updated before the theme is ready
                 const QList<QGradient> gradients = theme->seriesGradients();
                 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 || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_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 || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_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 || QChartPrivate::defaultPen() == m_barSets.at(i)->d_ptr->m_pen) {
                         QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                         m_barSets.at(i)->setPen(c);
                     }
                 }
                 m_blockBarUpdate = false;
                 emit updatedBars();
             }
             void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
                 Q_ASSERT(bar);
                 if (bar->animation())
                     bar->animation()->stopAndDestroyLater();
                 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"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/qabstractbarseries.h +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef QABSTRACTBARSERIES_H
             #define QABSTRACTBARSERIES_H
             #include <QtCharts/QAbstractSeries>
             #include <QtCore/QStringList>
             QT_CHARTS_BEGIN_NAMESPACE
             class QBarSet;
             class QAbstractBarSeriesPrivate;
             // Container for series
             class QT_CHARTS_EXPORT QAbstractBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QString labelsFormat READ labelsFormat WRITE setLabelsFormat NOTIFY labelsFormatChanged)
                 Q_PROPERTY(LabelsPosition labelsPosition READ labelsPosition WRITE setLabelsPosition NOTIFY labelsPositionChanged)
+                Q_PROPERTY(qreal labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_ENUMS(LabelsPosition)
             public:
                 enum LabelsPosition {
                     LabelsCenter = 0,
                     LabelsInsideEnd,
                     LabelsInsideBase,
                     LabelsOutsideEnd
                 };
             public:
                 virtual ~QAbstractBarSeries();
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool take(QBarSet *set);
                 bool append(QList<QBarSet *> sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
                 QList<QBarSet *> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 bool isLabelsVisible() const;
                 void setLabelsFormat(const QString &format);
                 QString labelsFormat() const;
+                void setLabelsAngle(qreal angle);
+                qreal labelsAngle() const;
                 void setLabelsPosition(QAbstractBarSeries::LabelsPosition position);
                 QAbstractBarSeries::LabelsPosition labelsPosition() const;
             protected:
                 explicit QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void hovered(bool status, int index, QBarSet *barset);
                 void pressed(int index, QBarSet *barset);
                 void released(int index, QBarSet *barset);
                 void doubleClicked(int index, QBarSet *barset);
                 void countChanged();
                 void labelsVisibleChanged();
                 void labelsFormatChanged(const QString &format);
                 void labelsPositionChanged(QAbstractBarSeries::LabelsPosition position);
+                void labelsAngleChanged(qreal angle);
                 void barsetsAdded(QList<QBarSet *> sets);
                 void barsetsRemoved(QList<QBarSet *> sets);
             protected:
                 Q_DECLARE_PRIVATE(QAbstractBarSeries)
                 friend class AbstractBarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class BoxPlotChartItem;
                 friend class BarChartItem;
                 friend class HorizontalBarChartItem;
                 friend class HorizontalStackedBarChartItem;
                 friend class HorizontalPercentBarChartItem;
                 friend class BarSet;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QABSTRACTBARSERIES_H

src/charts/barchart/qabstractbarseries_p.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise 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 <QtCharts/QAbstractBarSeries>
             #include <private/qabstractseries_p.h>
             #include <QtCore/QStringList>
             #include <QtCharts/QAbstractSeries>
             QT_CHARTS_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();
                 bool blockBarUpdate();
+                qreal labelsAngle() const;
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void pressed(int index, QBarSet *barset);
                 void released(int index, QBarSet *barset);
                 void doubleClicked(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;
                 bool m_blockBarUpdate;
                 QString m_labelsFormat;
                 QAbstractBarSeries::LabelsPosition m_labelsPosition;
+                qreal m_labelsAngle;
             private:
                 Q_DECLARE_PUBLIC(QAbstractBarSeries)
                 friend class HorizontalBarChartItem;
                 friend class BarChartItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QABSTRACTBARSERIES_P_H

src/charts/barchart/vertical/bar/barchartitem.cpp +1 -18

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/barchartitem_p.h>
             #include <private/bar_p.h>
             #include <private/qabstractbarseries_p.h>
             #include <QtCharts/QBarSet>
             #include <private/qbarset_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
             }
             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()), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/setCount * barWidth, domain()->minY()), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + set/setCount * barWidth, 0), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/setCount * barWidth, 0), m_validData);
                         }
                         if (!m_validData)
                              return;
                         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), m_validData);
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/(setCount) * barWidth, domain()->minY()), m_validData);
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2 + (set + 1)/(setCount) * barWidth, 0), m_validData);
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                     }
                 }
                 return layout;
             }
             void BarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void BarChartItem::positionLabels()
             {
-                for (int i = 0; i < m_layout.count(); i++) {
+                positionLabelsVertical();
-                    QGraphicsTextItem *label = m_labels.at(i);
-                    qreal xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
-                    qreal yPos = 0;
-                    int offset = m_bars.at(i)->pen().width() / 2 + 2;
-                    if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
-                        yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
-                        yPos = m_layout.at(i).top() - offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
-                        yPos = m_layout.at(i).bottom() - label->boundingRect().height() + offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
-                        yPos = m_layout.at(i).top() - label->boundingRect().height() + offset;
-                    label->setPos(xPos, yPos);
-                    label->setZValue(zValue() + 1);
             }
             #include "moc_barchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/vertical/percent/percentbarchartitem.cpp +1 -18

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/percentbarchartitem_p.h>
             #include <private/bar_p.h>
             #include <private/qabstractbarseries_p.h>
             #include <QtCharts/QBarSet>
             #include <private/qbarset_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
             }
             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()), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0), m_validData);
                         }
                         if (!m_validData)
                              return;
                         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;
                         qreal topY = 0;
                         qreal newSum = value + sum;
                         if (newSum > 0)
                             topY = 100 * newSum / categorySum;
                         qreal bottomY = 0;
                         if (sum > 0)
                             bottomY = 100 * sum / categorySum;
                         QPointF topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth/2, topY), m_validData);
                         QPointF bottomRight;
                         if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? bottomY : domain()->minY()), m_validData);
                         else
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth/2, set ? bottomY : 0), m_validData);
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                         sum = newSum;
                     }
                 }
                 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);
                 static const QString valueTag(QLatin1String("@value"));
                 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();
                         QGraphicsTextItem *label = m_labels.at(itemIndex);
                         qreal p = m_series->d_func()->percentageAt(set, category) * 100.0;
                         QString vString(presenter()->numberToString(p, 'f', 0));
                         QString valueLabel;
                         if (m_series->labelsFormat().isEmpty()) {
                             vString.append(QStringLiteral("%"));
                             valueLabel = vString;
                         } else {
                             valueLabel = m_series->labelsFormat();
                             valueLabel.replace(valueTag, vString);
                         }
                         label->setHtml(valueLabel);
                         label->setFont(barSet->m_labelFont);
                         label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             void PercentBarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void PercentBarChartItem::positionLabels()
             {
-                for (int i = 0; i < m_layout.count(); i++) {
+                positionLabelsVertical();
-                    QGraphicsTextItem *label = m_labels.at(i);
-                    qreal xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
-                    qreal yPos = 0;
-                    int offset = m_bars.at(i)->pen().width() / 2 + 2;
-                    if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
-                        yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
-                        yPos = m_layout.at(i).top() - offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
-                        yPos = m_layout.at(i).bottom() - label->boundingRect().height() + offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
-                        yPos = m_layout.at(i).top() - label->boundingRect().height() + offset;
-                    label->setPos(xPos, yPos);
-                    label->setZValue(zValue() + 1);
             }
             #include "moc_percentbarchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/vertical/stacked/stackedbarchartitem.cpp +1 -18

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/stackedbarchartitem_p.h>
             #include <private/bar_p.h>
             #include <private/qbarset_p.h>
             #include <private/qabstractbarseries_p.h>
             #include <QtCharts/QBarSet>
             QT_CHARTS_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 AbstractBarChartItem(series, item)
             {
                 connect(series, SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)),
                         this, SLOT(handleLabelsPositionChanged()));
                 connect(series, SIGNAL(labelsFormatChanged(QString)), this, SLOT(positionLabels()));
             }
             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()), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, domain()->minY()), m_validData);
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, 0), m_validData);
                             bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, 0), m_validData);
                         }
                         if (!m_validData)
                              return;
                         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), m_validData);
                             if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                                 topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? negativeSum : domain()->minY()), m_validData);
                             else
                                 topLeft = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? negativeSum : 0), m_validData);
                             negativeSum += value;
                         } else {
                             topLeft = domain()->calculateGeometryPoint(QPointF(category - barWidth / 2, value + positiveSum), m_validData);
                             if (domain()->type() == AbstractDomain::XLogYDomain || domain()->type() == AbstractDomain::LogXLogYDomain)
                                 bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : domain()->minY()), m_validData);
                             else
                                 bottomRight = domain()->calculateGeometryPoint(QPointF(category + barWidth / 2, set ? positiveSum : 0), m_validData);
                             positiveSum += value;
                         }
                         rect.setTopLeft(topLeft);
                         rect.setBottomRight(bottomRight);
                         layout.append(rect.normalized());
                     }
                 }
                 return layout;
             }
             void StackedBarChartItem::handleLabelsPositionChanged()
             {
                 positionLabels();
             }
             void StackedBarChartItem::positionLabels()
             {
-                for (int i = 0; i < m_layout.count(); i++) {
+                positionLabelsVertical();
-                    QGraphicsTextItem *label = m_labels.at(i);
-                    qreal xPos = m_layout.at(i).center().x() - label->boundingRect().center().x();
-                    qreal yPos = 0;
-                    int offset = m_bars.at(i)->pen().width() / 2 + 2;
-                    if (m_series->labelsPosition() == QAbstractBarSeries::LabelsCenter)
-                        yPos = m_layout.at(i).center().y() - label->boundingRect().center().y();
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideEnd)
-                        yPos = m_layout.at(i).top() - offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsInsideBase)
-                        yPos = m_layout.at(i).bottom() - label->boundingRect().height() + offset;
-                    else if (m_series->labelsPosition() == QAbstractBarSeries::LabelsOutsideEnd)
-                        yPos = m_layout.at(i).top() - label->boundingRect().height() + offset;
-                    label->setPos(xPos, yPos);
-                    label->setZValue(zValue() + 1);
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

tests/auto/qbarseries/tst_qbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QList<QBarSet*>)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarseries_data();
                 void qbarseries();
                 void type_data();
                 void type();
                 void append_data();
                 void append();
                 void remove_data();
                 void remove();
                 void take_data();
                 void take();
                 void appendList_data();
                 void appendList();
                 void count_data();
                 void count();
                 void barSets_data();
                 void barSets();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void opacity();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void clearWithAnimations();
                 void destruction();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QBarSeries* m_barseries;
                 QBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
             };
             void tst_QBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QList<QBarSet*> >("QList<QBarSet*>");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QBarSeries::init()
             {
                 m_barseries = new QBarSeries();
                 m_barseries_with_sets = new QBarSeries();
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
                     m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::cleanup()
             {
                 foreach (QBarSet* s, m_testSets) {
                     m_barseries_with_sets->remove(s);
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
             }
             void tst_QBarSeries::qbarseries_data()
             {
             }
             void tst_QBarSeries::qbarseries()
             {
                 QBarSeries *barseries = new QBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QBarSeries::type_data()
             {
             }
             void tst_QBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
             void tst_QBarSeries::append_data()
             {
             }
             void tst_QBarSeries::append()
             {
                 QVERIFY(m_barseries->count() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
                 ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding same set again
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding null set
                 ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
             }
             void tst_QBarSeries::remove_data()
             {
             }
             void tst_QBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
                 ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
                 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // remove some sets
                 ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
                     ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 0);
             }
             void tst_QBarSeries::take_data()
             {
             }
             void tst_QBarSeries::take()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->count() == count);
                 QSignalSpy countSpy(m_barseries_with_sets,SIGNAL(countChanged()));
                 QSignalSpy removedSpy(m_barseries_with_sets,SIGNAL(barsetsRemoved(QList<QBarSet*>)));
                 for (int i=0; i<m_testSets.count(); i++) {
                     QBarSet* set = m_testSets.at(i);
                     bool success = m_barseries_with_sets->take(set);
                     QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                     QVERIFY(success);
                     TRY_COMPARE(countSpy.count(),1);
                     TRY_COMPARE(removedSpy.count(),1);
                     QList<QVariant> removedSpyArg = removedSpy.takeFirst();
                     QList<QBarSet*> removedSets = qvariant_cast<QList<QBarSet*> > (removedSpyArg.at(0));
                     QCOMPARE(removedSets.at(0), m_testSets.at(i));
                     countSpy.takeFirst();
                 }
             }
             void tst_QBarSeries::appendList_data()
             {
             }
             void tst_QBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->count() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Append same sets again (should fail, count should remain same)
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 delete invalidList.at(0);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
                 ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
             }
             void tst_QBarSeries::count_data()
             {
             }
             void tst_QBarSeries::count()
             {
                 QVERIFY(m_barseries->count() == 0);
                 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
             }
             void tst_QBarSeries::barSets_data()
             {
             }
             void tst_QBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
                 QVERIFY(m_barseries->isLabelsVisible() == false);
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
             }
             void tst_QBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                             == QBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QBarSeries::LabelsCenter);
             }
+            void tst_QBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QBarSeries::opacity()
             {
                 QSignalSpy opacitySpy(m_barseries, SIGNAL(opacityChanged()));
                 QCOMPARE(m_barseries->opacity(), 1.0);
                 m_barseries->setOpacity(0.5);
                 QCOMPARE(m_barseries->opacity(), 0.5);
                 QCOMPARE(opacitySpy.count(), 1);
                 m_barseries->setOpacity(0.0);
                 QCOMPARE(m_barseries->opacity(), 0.0);
                 QCOMPARE(opacitySpy.count(), 2);
                 m_barseries->setOpacity(1.0);
                 QCOMPARE(m_barseries->opacity(), 1.0);
                 QCOMPARE(opacitySpy.count(), 3);
             }
             void tst_QBarSeries::mouseclicked_data()
             {
             }
             void tst_QBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = (scaleX / setCount) * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
                         xPos -= series->count()*rectWidth/2;
                         xPos += set*rectWidth;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QBarSeries::mousehovered_data()
             {
             }
             void tst_QBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = (scaleX / setCount) * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
                         xPos -= series->count()*rectWidth/2;
                         xPos += set*rectWidth;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(0).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(1).center().x(), 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 // should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set 2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 // should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of view between set1 and set2 to check the index
             // (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(2).right() + layout.at(3).left()) / 2, 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 // should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of the view between bar1 and bar2 to check the index
             //(hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(3).right() + layout.at(3).left()) / 2, 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QBarSeries::clearWithAnimations()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
                 view.chart()->addSeries(series);
                 view.show();
                 series->clear();
             }
             void tst_QBarSeries::destruction()
             {
                 // add a barset
                 QBarSeries *series = new QBarSeries();
                 QBarSet *set = new QBarSet("testset");
                 QSignalSpy spy1(set, SIGNAL(destroyed()));
                 series->append(set);
                 // delete the series
                 delete series;
                 // check that series deletes the set
                 QCOMPARE(spy1.count(), 1);
             }
             void tst_QBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = (scaleX / setCount) * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
                         xPos -= series->count()*rectWidth/2;
                         xPos += set*rectWidth;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = (scaleX / setCount) * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
                         xPos -= series->count()*rectWidth/2;
                         xPos += set*rectWidth;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = (scaleX / setCount) * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
                         xPos -= series->count()*rectWidth/2;
                         xPos += set*rectWidth;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QHorizontalBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QHorizontalBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qhorizontalbarseries_data();
                 void qhorizontalbarseries();
                 void type_data();
                 void type();
                 void append_data();
                 void append();
                 void remove_data();
                 void remove();
                 void appendList_data();
                 void appendList();
                 void count_data();
                 void count();
                 void barSets_data();
                 void barSets();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void clearWithAnimations();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QHorizontalBarSeries* m_barseries;
                 QHorizontalBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
             };
             void tst_QHorizontalBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QHorizontalBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QHorizontalBarSeries::init()
             {
                 m_barseries = new QHorizontalBarSeries();
                 m_barseries_with_sets = new QHorizontalBarSeries();
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
                     m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QHorizontalBarSeries::cleanup()
             {
                 foreach (QBarSet* s, m_testSets) {
                     m_barseries_with_sets->remove(s);
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
             }
             void tst_QHorizontalBarSeries::qhorizontalbarseries_data()
             {
             }
             void tst_QHorizontalBarSeries::qhorizontalbarseries()
             {
                 QHorizontalBarSeries *barseries = new QHorizontalBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QHorizontalBarSeries::type_data()
             {
             }
             void tst_QHorizontalBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalBar);
             }
             void tst_QHorizontalBarSeries::append_data()
             {
             }
             void tst_QHorizontalBarSeries::append()
             {
                 QVERIFY(m_barseries->count() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
                 ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding same set again
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding null set
                 ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
             }
             void tst_QHorizontalBarSeries::remove_data()
             {
             }
             void tst_QHorizontalBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
                 ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
                 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // remove some sets
                 ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
                     ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 0);
             }
             void tst_QHorizontalBarSeries::appendList_data()
             {
             }
             void tst_QHorizontalBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->count() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Append same sets again (should fail, count should remain same)
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 delete invalidList.at(0);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
                 ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
             }
             void tst_QHorizontalBarSeries::count_data()
             {
             }
             void tst_QHorizontalBarSeries::count()
             {
                 QVERIFY(m_barseries->count() == 0);
                 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
             }
             void tst_QHorizontalBarSeries::barSets_data()
             {
             }
             void tst_QHorizontalBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QHorizontalBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QHorizontalBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
                 QVERIFY(m_barseries->isLabelsVisible() == false);
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
             }
             void tst_QHorizontalBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QHorizontalBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QHorizontalBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QHorizontalBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalBarSeries::LabelsCenter);
             }
+            void tst_QHorizontalBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QHorizontalBarSeries::mouseclicked_data()
             {
             }
             void tst_QHorizontalBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeY = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
                         yPos += setCount*rectHeight/2;
                         yPos -= set*rectHeight;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalBarSeries::mousehovered_data()
             {
             }
             void tst_QHorizontalBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeY = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
                         yPos += setCount*rectHeight/2;
                         yPos -= set*rectHeight;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //=======================================================================
             // move mouse to bottom border
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(0).center().x(), 300));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(0).center().y()));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 // should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set 2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 // should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of view between set1 and set2 to check the index
             // (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint(0, (layout.at(2).top() + layout.at(3).bottom()) / 2));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 // should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of the view between bar1 and bar2 to check the index
             //(hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint(0, (layout.at(3).top() + layout.at(3).bottom()) / 2));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QHorizontalBarSeries::clearWithAnimations()
             {
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
                 view.chart()->addSeries(series);
                 view.show();
                 series->clear();
             }
             void tst_QHorizontalBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
                         yPos += setCount*rectHeight/2;
                         yPos -= set*rectHeight;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
                         yPos += setCount*rectHeight/2;
                         yPos -= set*rectHeight;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalBarSeries* series = new QHorizontalBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
                         yPos += setCount*rectHeight/2;
                         yPos -= set*rectHeight;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QHorizontalBarSeries)
             #include "tst_qhorizontalbarseries.moc"

tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QHorizontalPercentBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QHorizontalPercentBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qhorizontalpercentbarseries_data();
                 void qhorizontalpercentbarseries();
                 void type_data();
                 void type();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void zeroValuesInSeries();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QHorizontalPercentBarSeries* m_barseries;
             };
             void tst_QHorizontalPercentBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QHorizontalPercentBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QHorizontalPercentBarSeries::init()
             {
                 m_barseries = new QHorizontalPercentBarSeries();
             }
             void tst_QHorizontalPercentBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QHorizontalPercentBarSeries::qhorizontalpercentbarseries_data()
             {
             }
             void tst_QHorizontalPercentBarSeries::qhorizontalpercentbarseries()
             {
                 QHorizontalPercentBarSeries *barseries = new QHorizontalPercentBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QHorizontalPercentBarSeries::type_data()
             {
             }
             void tst_QHorizontalPercentBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalPercentBar);
             }
             void tst_QHorizontalPercentBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QHorizontalPercentBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalPercentBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QHorizontalPercentBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalPercentBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalPercentBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalPercentBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalPercentBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalPercentBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QHorizontalPercentBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalPercentBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalPercentBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalPercentBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalPercentBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalPercentBarSeries::LabelsCenter);
             }
+            void tst_QHorizontalPercentBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QHorizontalPercentBarSeries::mouseclicked_data()
             {
             }
             void tst_QHorizontalPercentBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3;   // 3 values per set
                 qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         xPos += rectWidth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalPercentBarSeries::mousehovered_data()
             {
             }
             void tst_QHorizontalPercentBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3;   // 3 values per set
                 qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         xPos += rectWidth;
                     }
                 }
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(4).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(4).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(5).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(5).center().x(), 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(3).left(),
                                                          (layout.at(3).top() + layout.at(4).bottom()) / 2));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(3).left(),
                                                          (layout.at(3).top() + layout.at(4).bottom()) / 2));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QHorizontalPercentBarSeries::zeroValuesInSeries()
             {
                 QHorizontalPercentBarSeries *series = new QHorizontalPercentBarSeries();
                 QBarSet *set1 = new QBarSet(QString("set 1"));
                 *set1 << 100 << 0.0 << 10;
                 series->append(set1);
                 QBarSet *set2 = new QBarSet(QString("set 2"));
                 *set2 << 0.0 << 0.0 << 70;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.chart()->addSeries(series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             }
             void tst_QHorizontalPercentBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         xPos += rectWidth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalPercentBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         xPos += rectWidth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalPercentBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
                 qreal rangeY = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         xPos += rectWidth;
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QHorizontalPercentBarSeries)
             #include "tst_qhorizontalpercentbarseries.moc"

tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QHorizontalStackedBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QHorizontalStackedBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qhorizontalstackedbarseries_data();
                 void qhorizontalstackedbarseries();
                 void type_data();
                 void type();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QHorizontalStackedBarSeries* m_barseries;
             };
             void tst_QHorizontalStackedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QHorizontalStackedBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QHorizontalStackedBarSeries::init()
             {
                 m_barseries = new QHorizontalStackedBarSeries();
             }
             void tst_QHorizontalStackedBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QHorizontalStackedBarSeries::qhorizontalstackedbarseries_data()
             {
             }
             void tst_QHorizontalStackedBarSeries::qhorizontalstackedbarseries()
             {
                 QHorizontalStackedBarSeries *barseries = new QHorizontalStackedBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QHorizontalStackedBarSeries::type_data()
             {
             }
             void tst_QHorizontalStackedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeHorizontalStackedBar);
             }
             void tst_QHorizontalStackedBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QHorizontalStackedBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalStackedBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QHorizontalStackedBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalStackedBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalStackedBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalStackedBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalStackedBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalStackedBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QHorizontalStackedBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalStackedBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalStackedBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QHorizontalStackedBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QHorizontalStackedBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QHorizontalStackedBarSeries::LabelsCenter);
             }
+            void tst_QHorizontalStackedBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QHorizontalStackedBarSeries::mouseclicked_data()
             {
             }
             void tst_QHorizontalStackedBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3;   // 3 values per set
                 qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xMax = -scaleX * domainMinX + plotArea.left();
                     qreal xMin = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMin += rectWidth;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalStackedBarSeries::mousehovered_data()
             {
             }
             void tst_QHorizontalStackedBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3;   // 3 values per set
                 qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xMax = -scaleX * domainMinX + plotArea.left();
                     qreal xMin = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMin += rectWidth;
                         }
                     }
                 }
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(4).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(4).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(5).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(5).center().y(), 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(3).left(),
                                                          (layout.at(3).top() + layout.at(4).bottom()) / 2));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(3).left(),
                                                          (layout.at(3).top() + layout.at(4).bottom()) / 2));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QHorizontalStackedBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3; // 3 values per set
                 qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xMax = -scaleX * domainMinX + plotArea.left();
                     qreal xMin = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMin += rectWidth;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalStackedBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3; // 3 values per set
                 qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xMax = -scaleX * domainMinX + plotArea.left();
                     qreal xMin = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMin += rectWidth;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QHorizontalStackedBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 3; // 3 values per set
                 qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
                 qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
                 qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal xMax = -scaleX * domainMinX + plotArea.left();
                     qreal xMin = -scaleX * domainMinX + plotArea.left();
                     for (int set = 0; set < setCount; set++) {
                         qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
                         qreal rectWidth = barSets.at(set)->at(i) * scaleX;
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             xMin += rectWidth;
                         }
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QHorizontalStackedBarSeries)
             #include "tst_qhorizontalstackedbarseries.moc"

tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QPercentBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qpercentbarseries_data();
                 void qpercentbarseries();
                 void type_data();
                 void type();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void zeroValuesInSeries();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QPercentBarSeries* m_barseries;
             };
             void tst_QPercentBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QPercentBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QPercentBarSeries::init()
             {
                 m_barseries = new QPercentBarSeries();
             }
             void tst_QPercentBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QPercentBarSeries::qpercentbarseries_data()
             {
             }
             void tst_QPercentBarSeries::qpercentbarseries()
             {
                 QPercentBarSeries *barseries = new QPercentBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QPercentBarSeries::type_data()
             {
             }
             void tst_QPercentBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypePercentBar);
             }
             void tst_QPercentBarSeries::mouseclicked_data()
             {
             }
             void tst_QPercentBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QPercentBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QPercentBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QPercentBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QPercentBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QPercentBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QPercentBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QPercentBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QPercentBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QPercentBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QPercentBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QPercentBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QPercentBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QPercentBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QPercentBarSeries::LabelsCenter);
             }
+            void tst_QPercentBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QPercentBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
                         QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
                         layout.append(rect);
                         yPos -= rectHeigth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QPercentBarSeries::mousehovered_data()
             {
             }
             void tst_QPercentBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 100;  // From 0 to 100 because range is scaled to 100%
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * percentage * scaleY;
                         QRectF rect(xPos, yPos-rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         yPos -= rectHeight;
                     }
                 }
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(0).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() ==  QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(1).center().x(), 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(3).right() + layout.at(4).left()) /2,
                                                          layout.at(2).top()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(3).right() + layout.at(4).left()) /2,
                                                          layout.at(2).top()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QPercentBarSeries::zeroValuesInSeries()
             {
                 QPercentBarSeries *series = new QPercentBarSeries();
                 QBarSet *set1 = new QBarSet(QString("set 1"));
                 *set1 << 100 << 0.0 << 10;
                 series->append(set1);
                 QBarSet *set2 = new QBarSet(QString("set 2"));
                 *set2 << 0.0 << 0.0 << 70;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.chart()->addSeries(series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             }
             void tst_QPercentBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
                         QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
                         layout.append(rect);
                         yPos -= rectHeigth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QPercentBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
                         QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
                         layout.append(rect);
                         yPos -= rectHeigth;
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QPercentBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
                 qreal rangeX = 3; // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
                         QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
                         layout.append(rect);
                         yPos -= rectHeigth;
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QPercentBarSeries)
             #include "tst_qpercentbarseries.moc"

tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QChart>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             Q_DECLARE_METATYPE(QAbstractBarSeries::LabelsPosition)
             class tst_QStackedBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qstackedbarseries_data();
                 void qstackedbarseries();
                 void type_data();
                 void type();
                 void setLabelsFormat();
                 void setLabelsPosition();
+                void setLabelsAngle();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QStackedBarSeries* m_barseries;
             };
             void tst_QStackedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
                 qRegisterMetaType<QAbstractBarSeries::LabelsPosition>("QAbstractBarSeries::LabelsPosition");
             }
             void tst_QStackedBarSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QStackedBarSeries::init()
             {
                 m_barseries = new QStackedBarSeries();
             }
             void tst_QStackedBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QStackedBarSeries::qstackedbarseries_data()
             {
             }
             void tst_QStackedBarSeries::qstackedbarseries()
             {
                 QStackedBarSeries *barseries = new QStackedBarSeries();
                 QVERIFY(barseries != 0);
                 delete barseries;
             }
             void tst_QStackedBarSeries::type_data()
             {
             }
             void tst_QStackedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeStackedBar);
             }
             void tst_QStackedBarSeries::setLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_barseries, SIGNAL(labelsFormatChanged(QString)));
                 QCOMPARE(m_barseries->labelsFormat(), QString());
                 QString format("(@value)");
                 m_barseries->setLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 QCOMPARE(m_barseries->labelsFormat(), format);
                 m_barseries->setLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
                 QCOMPARE(m_barseries->labelsFormat(), QString());
             }
             void tst_QStackedBarSeries::setLabelsPosition()
             {
                 QSignalSpy labelsPositionSpy(m_barseries,
                                          SIGNAL(labelsPositionChanged(QAbstractBarSeries::LabelsPosition)));
                 QCOMPARE(m_barseries->labelsPosition(), QStackedBarSeries::LabelsCenter);
                 m_barseries->setLabelsPosition(QStackedBarSeries::LabelsInsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 QList<QVariant> arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QStackedBarSeries::LabelsInsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QStackedBarSeries::LabelsInsideEnd);
                 m_barseries->setLabelsPosition(QStackedBarSeries::LabelsInsideBase);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QStackedBarSeries::LabelsInsideBase);
                 QCOMPARE(m_barseries->labelsPosition(), QStackedBarSeries::LabelsInsideBase);
                 m_barseries->setLabelsPosition(QStackedBarSeries::LabelsOutsideEnd);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QStackedBarSeries::LabelsOutsideEnd);
                 QCOMPARE(m_barseries->labelsPosition(), QStackedBarSeries::LabelsOutsideEnd);
                 m_barseries->setLabelsPosition(QStackedBarSeries::LabelsCenter);
                 TRY_COMPARE(labelsPositionSpy.count(), 1);
                 arguments = labelsPositionSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QAbstractBarSeries::LabelsPosition>()
                         == QStackedBarSeries::LabelsCenter);
                 QCOMPARE(m_barseries->labelsPosition(), QStackedBarSeries::LabelsCenter);
             }
+            void tst_QStackedBarSeries::setLabelsAngle()
+            {
+                QSignalSpy labelsAngleSpy(m_barseries,
+                                         SIGNAL(labelsAngleChanged(qreal)));
+                QCOMPARE(m_barseries->labelsAngle(), 0.0);
+                m_barseries->setLabelsAngle(55.0);
+                TRY_COMPARE(labelsAngleSpy.count(), 1);
+                QList<QVariant> arguments = labelsAngleSpy.takeFirst();
+                QVERIFY(arguments.at(0).value<qreal>() == 55.0);
+                QCOMPARE(m_barseries->labelsAngle(), 55.0);
+            }
             void tst_QStackedBarSeries::mouseclicked_data()
             {
             }
             void tst_QStackedBarSeries::mouseclicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yMax = height + scaleY * domainMinY + plotArea.top();
                     qreal yMin = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMin -= rectHeight;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QStackedBarSeries::mousehovered_data()
             {
             }
             void tst_QStackedBarSeries::mousehovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesIndexSpy(series, SIGNAL(hovered(bool, int, QBarSet*)));
                 QSignalSpy setIndexSpy1(set1, SIGNAL(hovered(bool, int)));
                 QSignalSpy setIndexSpy2(set2, SIGNAL(hovered(bool, int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yMax = height + scaleY * domainMinY + plotArea.top();
                     qreal yMin = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMin -= rectHeight;
                         }
                     }
                 }
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.at(0).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesIndexSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 QList<QVariant> seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QList<QVariant> setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.at(1).center().x(), 0));
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 // should leave set2
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
             //=======================================================================
             // move mouse on top of set1, bar0 to check the index (hover into set1)
                 QTest::mouseMove(view.viewport(), layout.at(0).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should enter set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set2, bar0 to check the index (hover out set1,
             // hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(1).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
             //=======================================================================
             // move mouse on top of set1, bar1 to check the index (hover out set2,
             // hover in set1)
                 QTest::mouseMove(view.viewport(), layout.at(2).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 2);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set2, bar0
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 0);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 0);
                 //should enter set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set1)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(3).right() + layout.at(4).left()) /2,
                                                          layout.at(2).top()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 1);
                 TRY_COMPARE(setIndexSpy2.count(), 0);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set1);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy1.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse on top of set2, bar1 to check the index (hover in set2)
                 QTest::mouseMove(view.viewport(), layout.at(3).center().toPoint());
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should enter set2, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == true);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             //=======================================================================
             // move mouse between set1 and set2 (hover out set2)
                 QTest::mouseMove(view.viewport(), QPoint((layout.at(3).right() + layout.at(4).left()) /2,
                                                          layout.at(2).top()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 TRY_COMPARE(seriesIndexSpy.count(), 1);
                 TRY_COMPARE(setIndexSpy1.count(), 0);
                 TRY_COMPARE(setIndexSpy2.count(), 1);
                 //should leave set1, bar1
                 seriesIndexSpyArg = seriesIndexSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesIndexSpyArg.at(2)), set2);
                 QVERIFY(seriesIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(seriesIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(seriesIndexSpyArg.at(1).toInt() == 1);
                 setIndexSpyArg = setIndexSpy2.takeFirst();
                 QVERIFY(setIndexSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setIndexSpyArg.at(0).toBool() == false);
                 QVERIFY(setIndexSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
             }
             void tst_QStackedBarSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yMax = height + scaleY * domainMinY + plotArea.top();
                     qreal yMin = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMin -= rectHeight;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QStackedBarSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(released(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(released(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yMax = height + scaleY * domainMinY + plotArea.top();
                     qreal yMin = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMin -= rectHeight;
                         }
                     }
                 }
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QStackedBarSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QList<QBarSet*> barSets = series->barSets();
                 QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for bars
                 QRectF plotArea = view.chart()->plotArea();
                 qreal width = plotArea.width();
                 qreal height = plotArea.height();
                 qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
                 qreal rangeX = 3;   // 3 values per set
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal setCount = series->count();
                 qreal domainMinY = 0;       // These come from internal domain used by barseries.
                 qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
                 qreal rectWidth = scaleX * series->barWidth();
                 QVector<QRectF> layout;
                 // 3 = count of values in set
                 // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
                 for (int i = 0; i < 3; i++) {
                     qreal yMax = height + scaleY * domainMinY + plotArea.top();
                     qreal yMin = height + scaleY * domainMinY + plotArea.top();
                     for (int set = 0; set < setCount; set++) {
                         qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
                         qreal rectHeight = barSets.at(set)->at(i) * scaleY;
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             yMin -= rectHeight;
                         }
                     }
                 }
                 // barset 1, bar 0
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             }
             QTEST_MAIN(tst_QStackedBarSeries)
             #include "tst_qstackedbarseries.moc"

tests/manual/qmlchartproperties/qml/qmlchartproperties/BarEditor.qml +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             Row {
                 anchors.fill: parent
                 spacing: 5
                 property variant series
                 // buttons for selecting the edited object: series, barset or label
                 Flow {
                     spacing: 5
                     flow: Flow.TopToBottom
                     Button {
                         id: seriesButton
                         text: "series"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = true;
                             setFlow.visible = false;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             setButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: setButton
                         text: "BarSet"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             setFlow.visible = true;
                             labelsFlow.visible = false;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             labelButton.color = "#79bd8f";
                         }
                     }
                     Button {
                         id: labelButton
                         text: "label"
                         unpressedColor: "#79bd8f"
                         onClicked: {
                             seriesFlow.visible = false;
                             setFlow.visible = false;
                             labelsFlow.visible = true;
                             color = "#00a388";
                             seriesButton.color = "#79bd8f";
                             setButton.color = "#79bd8f";
                         }
                     }
                 }
                 // Buttons for editing series
                 Flow {
                     id: seriesFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "visible"
                         onClicked: series.visible = !series.visible;
                     }
                     Button {
                         text: "opacity +"
                         onClicked: series.opacity += 0.1;
                     }
                     Button {
                         text: "opacity -"
                         onClicked: series.opacity -= 0.1;
                     }
                     Button {
                         text: "bar width +"
                         onClicked: series.barWidth += 0.1;
                     }
                     Button {
                         text: "bar width -"
                         onClicked: series.barWidth -= 0.1;
                     }
                 }
                 // Buttons for editing sets
                 Flow {
                     id: setFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "append set"
                         onClicked: {
                             var count = series.count;
                             series.append("set" + count, [0, 0.1 * count, 0.2 * count, 0.3 * count, 0.4 * count, 0.5 * count, 0.6 * count]);
                         }
                     }
                     Button {
                         text: "insert set"
                         onClicked: {
                             var count = series.count;
                             series.insert(count - 1, "set" + count, [0, 0.1 * count, 0.2 * count, 0.3 * count, 0.4 * count, 0.5 * count, 0.6 * count]);
                         }
                     }
                     Button {
                         text: "remove set"
                         onClicked: series.remove(series.at(series.count - 1));
                     }
                     Button {
                         text: "clear sets"
                         onClicked: series.clear();
                     }
                     Button {
                         text: "set 1 append"
                         onClicked: series.at(0).append(series.at(0).count + 1);
                     }
                     Button {
                         text: "set 1 replace"
                         onClicked: series.at(0).replace(series.at(0).count - 1, series.at(0).at(series.at(0).count - 1) + 1.5);
                     }
                     Button {
                         text: "set 1 remove"
                         onClicked: series.at(0).remove(series.at(0).count - 1);
                     }
                     Button {
                         text: "set 1 color"
                         onClicked: series.at(0).color = main.nextColor();
                     }
                     Button {
                         text: "set 1 border color"
                         onClicked: series.at(0).borderColor = main.nextColor();
                     }
                     Button {
                         text: "set 1 borderWidth +"
                         onClicked: series.at(0).borderWidth += 0.5;
                     }
                     Button {
                         text: "set 1 borderWidth -"
                         onClicked: series.at(0).borderWidth -= 0.5;
                     }
                 }
                 Flow {
                     id: labelsFlow
                     spacing: 5
                     flow: Flow.TopToBottom
                     visible: false
                     Button {
                         text: "labels visible"
                         onClicked: series.labelsVisible = !series.labelsVisible;
                     }
                     Button {
                         text: "labels format"
                         onClicked: {
                             if (series.labelsFormat === "@value")
                                 series.labelsFormat = "@value%"
                             else
                                 series.labelsFormat = "@value"
                         }
                     }
                     Button {
                         text: "labels position"
                         onClicked: series.changeLabelsPosition();
                     }
                     Button {
                         text: "set 1 label color"
                         onClicked: series.at(0).labelColor = main.nextColor();
                     }
+                    Button {
+                        text: "labels angle +"
+                        onClicked: series.labelsAngle = series.labelsAngle + 5;
+                    }
+                    Button {
+                        text: "labels angle -"
+                        onClicked: series.labelsAngle = series.labelsAngle - 5;
+                    }
                     FontEditor {
                         id: fontEditor
                         fontDescription: "label"
                         function editedFont() {
                             return series.at(0).labelFont;
                         }
                     }
                 }
             }

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