HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1563:d73e56958c7d

removed double signal emitting from barseries/set

sauimone -

r1563:d73e56958c7d

parent child

Context file:

r1563:d73e56958c7d

Collapse all files

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownchart.h"
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QChart(parent, wFlags)
                 ,m_currentSeries(0)
             {
             }
             void DrilldownChart::changeSeries(DrilldownBarSeries *series)
             {
                 if (m_currentSeries) {
                     removeSeries(m_currentSeries);
                 }
                 m_currentSeries = series;
                 // Reset axis
                 QCategoriesAxis* axis = new QCategoriesAxis();
                 axis->append(m_currentSeries->categories());
                 addSeries(series);
                 setAxisX(series,axis);
                 setTitle(series->name());
             }
-            void DrilldownChart::handleClicked(QBarSet *barset, int index)
+            void DrilldownChart::handleClicked(int index, QBarSet *barset)
             {
                 Q_UNUSED(barset)
                 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                 changeSeries(series->drilldownSeries(index));
             }
             #include "moc_drilldownchart.cpp"

examples/stackedbarchartdrilldown/drilldownchart.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DRILLDOWNCHART_H
             #define DRILLDOWNCHART_H
             #include <QChart>
             #include "drilldownseries.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             //! [1]
             class DrilldownChart : public QChart
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 void changeSeries(DrilldownBarSeries *series);
             public Q_SLOTS:
-                void handleClicked(QBarSet *barset, int index);
+                void handleClicked(int index, QBarSet *barset);
             private:
                 DrilldownBarSeries* m_currentSeries;
             };
             //! [1]
             #endif // DRILLDOWNCHART_H

examples/stackedbarchartdrilldown/main.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSet>
             #include <QLegend>
             #include "drilldownseries.h"
             #include "drilldownchart.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
             //! [1]
                 DrilldownChart* drilldownChart =  new DrilldownChart();
                 drilldownChart->setTheme(QChart::ChartThemeBlueIcy);
                 drilldownChart->setAnimationOptions(QChart::SeriesAnimations);
             //! [1]
             //! [2]
                 // Define categories
                 QStringList months;
                 months << "May" << "Jun" << "Jul" << "Aug" << "Sep";
                 QStringList weeks;
                 weeks << "week 1" << "week 2" << "week 3" << "week 4";
                 QStringList plants;
                 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
             //! [2]
             //! [3]
                 // Create drilldown structure
                 DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
                 seasonSeries->setName("Crop by month - Season");
                 // Each month in season series has drilldown series for weekly data
                 for (int month=0; month < months.count(); month++) {
                     // Create drilldown series for every week
                     DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
                     seasonSeries->mapDrilldownSeries(month, weeklySeries);
                     // Drilling down from weekly data brings us back to season data.
                     for (int week=0; week < weeks.count(); week++) {
                         weeklySeries->mapDrilldownSeries(week, seasonSeries);
                         weeklySeries->setName(QString("Crop by week - " + months.at(month)));
                     }
-                    // Use right click signal to implement drilldown
+                    // Use clicked signal to implement drilldown
-                    QObject::connect(weeklySeries, SIGNAL(clicked(QBarSet*,int)), drilldownChart, SLOT(handleClicked(QBarSet*,int)));
+                    QObject::connect(weeklySeries, SIGNAL(clicked(int, QBarSet*)), drilldownChart, SLOT(handleClicked(int, QBarSet*)));
                 }
-                // Enable drilldown from season series using right click.
+                // Enable drilldown from season series using clicked signal
-                QObject::connect(seasonSeries, SIGNAL(clicked(QBarSet*,int)), drilldownChart, SLOT(handleClicked(QBarSet*,int)));
+                QObject::connect(seasonSeries, SIGNAL(clicked(int, QBarSet*)), drilldownChart, SLOT(handleClicked(int, QBarSet*)));
             //! [3]
             //! [4]
                 // Fill monthly and weekly series with data
                 foreach (QString plant, plants) {
                     QBarSet* monthlyCrop = new QBarSet(plant);
                     for (int month=0; month<months.count(); month++) {
                         QBarSet* weeklyCrop = new QBarSet(plant);
                         for (int week=0; week<weeks.count(); week++) {
                             *weeklyCrop << (qrand() % 20);
                         }
                         // Get the drilldown series from season series and add crop to it.
                         seasonSeries->drilldownSeries(month)->append(weeklyCrop);
                         *monthlyCrop << weeklyCrop->sum();
                     }
                     seasonSeries->append(monthlyCrop);
                 }
             //! [4]
             //! [5]
                 // Show season series in initial view
                 drilldownChart->changeSeries(seasonSeries);
                 drilldownChart->setTitle(seasonSeries->name());
             //! [5]
             //! [6]
                 drilldownChart->axisX()->setGridLineVisible(false);
                 //TODO: drilldownChart->axisY()->setNiceNumbersEnabled(true);
                 drilldownChart->legend()->setVisible(true);
                 drilldownChart->legend()->setAlignment(Qt::AlignBottom);
             //! [6]
                 QChartView *chartView = new QChartView(drilldownChart);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/barchart/bar.cpp +15 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "bar_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QBarSet *barset, int index, QGraphicsItem *parent) : QGraphicsRectItem(parent),
                 m_index(index),
-                m_barset(barset)
+                m_barset(barset),
+                m_hovering(false)
             {
                 setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
+            Bar::~Bar()
+            {
+                // End hover event, if bar is deleted during it
+                if (m_hovering) {
+                    emit hovered(false, m_barset);
+                }
+            }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
-                emit clicked(m_barset, m_index);
+                emit clicked(m_index, m_barset);
-                emit clicked(m_index);
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
-                emit hovered(m_barset, true);
+                m_hovering = true;
-                emit hovered(true);
+                emit hovered(true, m_barset);
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
-                emit hovered(m_barset, false);
+                m_hovering = false;
-                emit hovered(false);
+                emit hovered(false, m_barset);
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar_p.h +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BAR_H
             #define BAR_H
             #include "qchartglobal.h"
             #include <QGraphicsRectItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             // Single visual bar item of chart
             class Bar : public QObject, public QGraphicsRectItem
             {
                 Q_OBJECT
             public:
                 Bar(QBarSet *barset, int index, QGraphicsItem *parent = 0);
+                ~Bar();
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             Q_SIGNALS:
-                void clicked(QBarSet *barset, int index);
+                void clicked(int index, QBarSet *barset);
-                void hovered(QBarSet *barset, bool status);
+                void hovered(bool status, QBarSet *barset);
-                void clicked(int index);
-                void hovered(bool status);
             private:
                 int m_index;
+                bool m_hovering;
                 QBarSet *m_barset;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BAR_H

src/barchart/barchartitem.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 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()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
                         qreal xPos = (barSet->at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->at(category).y())) {
                             label->setText(QString::number(barSet->at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         label->setBrush(barSet->labelBrush());
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             void BarChartItem::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));
                 }
             }
             //handlers
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void BarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem* label, m_labels) {
                     label->setVisible(visible);
                 }
                 update();
             }
             void BarChartItem::handleDataStructureChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 bool labelsVisible = m_series->isLabelsVisible();
                 // 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(QBarSet*,int)), m_series, SIGNAL(clicked(QBarSet*,int)));
+                        connect(bar, SIGNAL(clicked(int, QBarSet*)), m_series, SIGNAL(clicked(int, QBarSet*)));
-                        connect(bar, SIGNAL(hovered(QBarSet*,bool)), m_series, SIGNAL(hovered(QBarSet*,bool)));
+                        connect(bar, SIGNAL(hovered(bool, QBarSet*)), m_series, SIGNAL(hovered(bool, QBarSet*)));
-                        connect(bar, SIGNAL(clicked(int)), set, SIGNAL(clicked(int)));
+                        connect(bar, SIGNAL(clicked(int, QBarSet*)), set, SIGNAL(clicked(int)));
-                        connect(bar, SIGNAL(hovered(bool)), set, SIGNAL(hovered(bool)));
+                        connect(bar, SIGNAL(hovered(bool, QBarSet*)), set, SIGNAL(hovered(bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                         // Labels
                         QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
                         label->setVisible(labelsVisible);
                         m_labels.append(label);
                     }
                 }
                 // TODO: Is this the right place to call it?
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 handleLayoutChanged();
             }
             void BarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 handleLabelsVisibleChanged(visible);
                 foreach(QGraphicsItem *item, childItems()) {
                     item->setVisible(visible);
                 }
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QBarSeries::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 QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \qmlproperty real BarSeries::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 QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int BarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool BarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
-                \fn void QBarSeries::clicked(QBarSet *barset, int index)
+                \fn void QBarSeries::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 BarSeries::onClicked(BarSet barset, int index)
+                \qmlsignal BarSeries::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 QBarSeries::hovered(QBarSet* barset, bool status)
+                \fn void QBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
-                \qmlsignal BarSeries::onHovered(BarSet barset, bool status)
+                \qmlsignal BarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal BarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSeries::onAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSeries::onRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet BarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet BarSeries::append(string label, VariantList values)
                 Adds 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.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                     myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet BarSeries::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 BarSeries::append()
             */
             /*!
                 \qmlmethod bool BarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successfull, false otherwise.
             */
             /*!
                 \qmlmethod BarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 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 QGroupedBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QBarSeries::barWidth() const
             {
                 Q_D(const QBarSeries);
                 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 QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 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 succesfully. 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 QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all of the bar sets from the series
             */
             void QBarSeries::clear()
             {
                 Q_D(QBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::count() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QBarSeriesPrivate::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 QBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QBarSeriesPrivate::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).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::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).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::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).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::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).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::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 QBarSeriesPrivate::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)->at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::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)->at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             QAbstractAxis* QBarSeriesPrivate::createAxisX(QObject* parent)
             {
                 return new QValuesAxis(parent);
             }
             QAbstractAxis* QBarSeriesPrivate::createAxisY(QObject* parent)
             {
                 return new QValuesAxis(parent);
             }
             bool QBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 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
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 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
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     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
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     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
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.insert(index, set);
                 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
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : 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)
             public:
                 explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(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;
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
-                void clicked(QBarSet *barset, int index);
+                void clicked(int index, QBarSet *barset);
-                void hovered(QBarSet* barset, bool status);
+                void hovered(bool status, QBarSet *barset);
                 void countChanged();
                 void labelsVisibleChanged();
                 void barsetsAdded(QList<QBarSet*> sets);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
             class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarSeries *parent);
                 int categoryCount() const;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 QAbstractAxis* createAxisX(QObject* parent = 0);
                 QAbstractAxis* createAxisY(QObject* parent = 0);
                 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();
             Q_SIGNALS:
-                void clicked(QBarSet *barset, int index);
+                void clicked(int index, QBarSet *barset);
                 void updatedBars();
                 void restructuredBars();
                 void labelsVisibleChanged(bool visible);
             protected:
                 QList<QBarSet *> m_barSets;
                 qreal m_barWidth;
                 bool m_labelsVisible;
                 bool m_visible;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

tests/auto/qbarseries/tst_qbarseries.cpp +32 -32

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             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 appendList_data();
                 void appendList();
                 void count_data();
                 void count();
                 void barSets_data();
                 void barSets();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void clearWithAnimations();
             private:
                 QBarSeries* m_barseries;
                 QBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
             };
             void tst_QBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
             }
             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);
                     delete 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);
             }
             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::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);
                 // 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::mouseclicked_data()
             {
             }
             void tst_QBarSeries::mouseclicked()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
+                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);
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(102,142));
                 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(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                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, QPoint(186,142));
                 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(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                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, QPoint(271,142));
                 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(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                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, QPoint(127,142));
                 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(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                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, QPoint(212,142));
                 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(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                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, QPoint(296,142));
                 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(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                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()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
+                QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 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);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(102,142));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(127,142));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(127,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
             }
             void tst_QBarSeries::clearWithAnimations()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,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();
             }
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

tests/auto/qgroupedbarseries/tst_qgroupedbarseries.cpp +32 -32

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qgroupedbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <QBarModelMapper>
             #include <QStandardItemModel>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QGroupedBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qgroupedbarseries_data();
                 void qgroupedbarseries();
                 void type_data();
                 void type();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QGroupedBarSeries* m_barseries;
             };
             void tst_QGroupedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QGroupedBarSeries::cleanupTestCase()
             {
             }
             void tst_QGroupedBarSeries::init()
             {
                 m_barseries = new QGroupedBarSeries();
             }
             void tst_QGroupedBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QGroupedBarSeries::qgroupedbarseries_data()
             {
             }
             void tst_QGroupedBarSeries::qgroupedbarseries()
             {
                 QGroupedBarSeries *barseries = new QGroupedBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QGroupedBarSeries::type_data()
             {
             }
             void tst_QGroupedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeGroupedBar);
             }
             void tst_QGroupedBarSeries::mouseclicked_data()
             {
             }
             void tst_QGroupedBarSeries::mouseclicked()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(95,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(187,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(280,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(118,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(210,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(303,143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QGroupedBarSeries::mousehovered_data()
             {
             }
             void tst_QGroupedBarSeries::mousehovered()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
+                QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
                 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);
             //=======================================================================
             // move mouse to left border
                 qDebug() << "move mouse to left border";
                 QTest::mouseMove(view.viewport(), QPoint(0, 143));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 qDebug() << "move mouse on top of set1";
                 QTest::mouseMove(view.viewport(), QPoint(95,143));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 qDebug() << "move mouse from top of set1 to top of set2";
                 QTest::mouseMove(view.viewport(), QPoint(118,143));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 qDebug() << "move mouse from top of set2 to background";
                 QTest::mouseMove(view.viewport(), QPoint(118,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
             }
             QTEST_MAIN(tst_QGroupedBarSeries)
             #include "tst_qgroupedbarseries.moc"

tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp +32 -32

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qpercentbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             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 mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QPercentBarSeries* m_barseries;
             };
             void tst_QPercentBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QPercentBarSeries::cleanupTestCase()
             {
             }
             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);
             }
             void tst_QPercentBarSeries::type_data()
             {
             }
             void tst_QPercentBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypePercentBar);
             }
             void tst_QPercentBarSeries::mouseclicked_data()
             {
             }
             void tst_QPercentBarSeries::mouseclicked()
             {
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(106,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(199,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(292,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(106,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(199,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(292,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QPercentBarSeries::mousehovered_data()
             {
             }
             void tst_QPercentBarSeries::mousehovered()
             {
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
+                QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
                 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);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(106,190));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() ==  QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() ==  QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(106,95));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(106,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
             }
             QTEST_MAIN(tst_QPercentBarSeries)
             #include "tst_qpercentbarseries.moc"

tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp +32 -32

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             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 mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QStackedBarSeries* m_barseries;
             };
             void tst_QStackedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QStackedBarSeries::cleanupTestCase()
             {
             }
             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);
             }
             void tst_QStackedBarSeries::type_data()
             {
             }
             void tst_QStackedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeStackedBar);
             }
             void tst_QStackedBarSeries::mouseclicked_data()
             {
             }
             void tst_QStackedBarSeries::mouseclicked()
             {
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(int, QBarSet*)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(106,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(199,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(292,190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(106,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(199,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(292,95));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
+                QVERIFY(seriesSpyArg.at(0).toInt() == 2);
             }
             void tst_QStackedBarSeries::mousehovered_data()
             {
             }
             void tst_QStackedBarSeries::mousehovered()
             {
                 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);
-                QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
+                QSignalSpy seriesSpy(series,SIGNAL(hovered(bool, QBarSet*)));
                 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);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 190));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(106,190));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(106,95));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == true);
+                QVERIFY(seriesSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(106,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
-                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
+                QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
+                QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
-                QVERIFY(seriesSpyArg.at(1).toBool() == false);
+                QVERIFY(seriesSpyArg.at(0).toBool() == false);
             }
             QTEST_MAIN(tst_QStackedBarSeries)
             #include "tst_qstackedbarseries.moc"

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