Add pressed, released and doubleClicked signals

Added pressed, released and doubleClicked signals for all series. The
signals are also added to QPieSlice and QBoxPlotSet.

Change-Id: If94948be439a3b53ed48c02d0092091e836222a4
Task-number: QTRD-2384
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@theqtcompany.com>

24 files changed, 3120 insertions, 0 deletions

diff --git a/tests/auto/qbarseries/tst_qbarseries.cpp b/tests/auto/qbarseries/tst_qbarseries.cpp
index 029a445c..9f318ee2 100644
--- a/tests/auto/qbarseries/tst_qbarseries.cpp
+++ b/tests/auto/qbarseries/tst_qbarseries.cpp
@@ -69,6 +69,9 @@ private slots:
     void mousehovered();
     void clearWithAnimations();
     void destruction();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QBarSeries* m_barseries;
@@ -926,6 +929,410 @@ void tst_QBarSeries::destruction()
     QCOMPARE(spy1.count(), 1);
 }
 
+void tst_QBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QBarSeries* series = new QBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = (scaleX / setCount) * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
+            xPos -= series->count()*rectWidth/2;
+            xPos += set*rectWidth;
+
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QBarSeries* series = new QBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = (scaleX / setCount) * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
+            xPos -= series->count()*rectWidth/2;
+            xPos += set*rectWidth;
+
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QBarSeries* series = new QBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = (scaleX / setCount) * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left();
+            xPos -= series->count()*rectWidth/2;
+            xPos += set*rectWidth;
+
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
+
 QTEST_MAIN(tst_QBarSeries)
 
 #include "tst_qbarseries.moc"
diff --git a/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp b/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp
index 29bb682f..a209becc 100644
--- a/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp
+++ b/tests/auto/qhorizontalbarseries/tst_qhorizontalbarseries.cpp
@@ -64,6 +64,9 @@ private slots:
     void mousehovered_data();
     void mousehovered();
     void clearWithAnimations();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QHorizontalBarSeries* m_barseries;
@@ -859,6 +862,409 @@ void tst_QHorizontalBarSeries::clearWithAnimations()
     series->clear();
 }
 
+void tst_QHorizontalBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalBarSeries* series = new QHorizontalBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
+            yPos += setCount*rectHeight/2;
+            yPos -= set*rectHeight;
+
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalBarSeries* series = new QHorizontalBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
+            yPos += setCount*rectHeight/2;
+            yPos -= set*rectHeight;
+
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalBarSeries* series = new QHorizontalBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 10;  // From 0 to 10 because of maximum value in set is 10
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = (scaleY / setCount) * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = plotArea.bottom() + (domainMinY - i) * scaleY;
+            yPos += setCount*rectHeight/2;
+            yPos -= set*rectHeight;
+
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
 QTEST_MAIN(tst_QHorizontalBarSeries)
 
 #include "tst_qhorizontalbarseries.moc"
diff --git a/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp b/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp
index 2c3f4bd8..add938c6 100644
--- a/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp
+++ b/tests/auto/qhorizontalpercentbarseries/tst_qhorizontalpercentbarseries.cpp
@@ -52,6 +52,9 @@ private slots:
     void mousehovered_data();
     void mousehovered();
     void zeroValuesInSeries();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QHorizontalPercentBarSeries* m_barseries;
@@ -604,6 +607,411 @@ void tst_QHorizontalPercentBarSeries::zeroValuesInSeries()
     QTest::qWaitForWindowShown(&view);
 }
 
+
+void tst_QHorizontalPercentBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+            xPos += rectWidth;
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalPercentBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+            xPos += rectWidth;
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalPercentBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalPercentBarSeries* series = new QHorizontalPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeX = 100;  // From 0 to 100 because of scaling to 100%
+    qreal rangeY = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal xPos = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * percentage * scaleX;
+            QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
+            layout.append(rect);
+            xPos += rectWidth;
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
+
 QTEST_MAIN(tst_QHorizontalPercentBarSeries)
 
 #include "tst_qhorizontalpercentbarseries.moc"
diff --git a/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp b/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp
index ac6b9b1b..cbf64efc 100644
--- a/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp
+++ b/tests/auto/qhorizontalstackedbarseries/tst_qhorizontalstackedbarseries.cpp
@@ -51,6 +51,9 @@ private slots:
     void mouseclicked();
     void mousehovered_data();
     void mousehovered();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QHorizontalStackedBarSeries* m_barseries;
@@ -594,6 +597,424 @@ void tst_QHorizontalStackedBarSeries::mousehovered()
     QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
 }
 
+void tst_QHorizontalStackedBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 3; // 3 values per set
+    qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xMax = -scaleX * domainMinX + plotArea.left();
+        qreal xMin = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            if (rectWidth > 0) {
+                QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMax += rectWidth;
+            } else {
+                QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMin += rectWidth;
+            }
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalStackedBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 3; // 3 values per set
+    qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xMax = -scaleX * domainMinX + plotArea.left();
+        qreal xMin = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            if (rectWidth > 0) {
+                QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMax += rectWidth;
+            } else {
+                QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMin += rectWidth;
+            }
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QHorizontalStackedBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QHorizontalStackedBarSeries* series = new QHorizontalStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 3; // 3 values per set
+    qreal rangeX = 20;  // From 0 to 20 because bars are stacked (this should be height of highest stack)
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = -0.5;    // These come from internal domain used by barseries.
+    qreal domainMinX = 0;       // No access to domain from outside, so use hard coded values.
+    qreal rectHeight = scaleY * series->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal xMax = -scaleX * domainMinX + plotArea.left();
+        qreal xMin = -scaleX * domainMinX + plotArea.left();
+        for (int set = 0; set < setCount; set++) {
+            qreal yPos = (domainMinY +0.5 -i) * scaleY + plotArea.bottom() - rectHeight/2;
+            qreal rectWidth = barSets.at(set)->at(i) * scaleX;
+            if (rectWidth > 0) {
+                QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMax += rectWidth;
+            } else {
+                QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                xMin += rectWidth;
+            }
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
 QTEST_MAIN(tst_QHorizontalStackedBarSeries)
 
 #include "tst_qhorizontalstackedbarseries.moc"
diff --git a/tests/auto/qlineseries/tst_qlineseries.cpp b/tests/auto/qlineseries/tst_qlineseries.cpp
index aea9ccc9..13f29a14 100644
--- a/tests/auto/qlineseries/tst_qlineseries.cpp
+++ b/tests/auto/qlineseries/tst_qlineseries.cpp
@@ -36,6 +36,9 @@ public slots:
 private slots:
     void qlineseries_data();
     void qlineseries();
+    void pressedSignal();
+    void releasedSignal();
+    void doubleClickedSignal();
 protected:
     void pointsVisible_data();
 };
@@ -102,6 +105,99 @@ void tst_QLineSeries::qlineseries()
     QTest::qWaitForWindowShown(m_view);
 }
 
+void tst_QLineSeries::pressedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF linePoint(4, 12);
+    QLineSeries *lineSeries = new QLineSeries();
+    lineSeries->append(QPointF(2, 1));
+    lineSeries->append(linePoint);
+    lineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(lineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(lineSeries, SIGNAL(pressed(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(linePoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
+}
+
+void tst_QLineSeries::releasedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF linePoint(4, 12);
+    QLineSeries *lineSeries = new QLineSeries();
+    lineSeries->append(QPointF(2, 20));
+    lineSeries->append(linePoint);
+    lineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(lineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(lineSeries, SIGNAL(released(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(linePoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
+}
+
+void tst_QLineSeries::doubleClickedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF linePoint(4, 12);
+    QLineSeries *lineSeries = new QLineSeries();
+    lineSeries->append(QPointF(2, 20));
+    lineSeries->append(linePoint);
+    lineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(lineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(lineSeries, SIGNAL(doubleClicked(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(linePoint);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
+}
+
 QTEST_MAIN(tst_QLineSeries)
 
 #include "tst_qlineseries.moc"
diff --git a/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp b/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp
index e4bab706..a74c6511 100644
--- a/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp
+++ b/tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp
@@ -52,6 +52,9 @@ private slots:
     void mousehovered_data();
     void mousehovered();
     void zeroValuesInSeries();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QPercentBarSeries* m_barseries;
@@ -608,6 +611,416 @@ void tst_QPercentBarSeries::zeroValuesInSeries()
     QTest::qWaitForWindowShown(&view);
 }
 
+void tst_QPercentBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPercentBarSeries* series = new QPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
+
+            QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
+            layout.append(rect);
+            yPos -= rectHeigth;
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QPercentBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPercentBarSeries* series = new QPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
+
+            QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
+            layout.append(rect);
+            yPos -= rectHeigth;
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QPercentBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPercentBarSeries* series = new QPercentBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 100; // From 0 to 100 because range is scaled to 100%
+    qreal rangeX = 3; // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal colSum = 20; // Sum of values in column (10 + 10 in our test case)
+        qreal percentage = (100 / colSum);
+        qreal yPos = height + scaleY * domainMinY + plotArea.top();
+
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeigth = barSets.at(set)->at(i) * percentage * scaleY;
+
+            QRectF rect(xPos, yPos-rectHeigth, rectWidth, rectHeigth);
+            layout.append(rect);
+            yPos -= rectHeigth;
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
+
 QTEST_MAIN(tst_QPercentBarSeries)
 
 #include "tst_qpercentbarseries.moc"
diff --git a/tests/auto/qpieseries/tst_qpieseries.cpp b/tests/auto/qpieseries/tst_qpieseries.cpp
index ce7e8d54..9d975c5a 100644
--- a/tests/auto/qpieseries/tst_qpieseries.cpp
+++ b/tests/auto/qpieseries/tst_qpieseries.cpp
@@ -57,6 +57,9 @@ private slots:
     void hoverSignal();
     void sliceSeries();
     void destruction();
+    void pressedSignal();
+    void releasedSignal();
+    void doubleClickedSignal();
 
 private:
     void verifyCalculatedData(const QPieSeries &series, bool *ok);
@@ -652,6 +655,139 @@ QList<QPoint> tst_qpieseries::slicePoints(QRectF rect)
     return points;
 }
 
+void tst_qpieseries::pressedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieslice::pressedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // add some slices
+    QPieSlice *s1 = m_series->append("slice 1", 1);
+    QPieSlice *s2 = m_series->append("slice 2", 1);
+    QPieSlice *s3 = m_series->append("slice 3", 1);
+    QPieSlice *s4 = m_series->append("slice 4", 1);
+    QSignalSpy clickSpy(m_series, SIGNAL(pressed(QPieSlice*)));
+
+    // add series to the chart
+    m_view->chart()->legend()->setVisible(false);
+    m_view->chart()->addSeries(m_series);
+    m_view->show();
+    QTest::qWaitForWindowShown(m_view);
+
+    // test maximum size
+    m_series->setPieSize(1.0);
+    QRectF pieRect = m_view->chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
+    TRY_COMPARE(clickSpy.count(), 4);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
+    clickSpy.clear();
+
+    // test half size
+    m_series->setPieSize(0.5);
+    m_series->setVerticalPosition(0.25);
+    m_series->setHorizontalPosition(0.25);
+    pieRect = QRectF(m_view->chart()->plotArea().topLeft(), m_view->chart()->plotArea().center());
+    points = slicePoints(pieRect);
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
+    TRY_COMPARE(clickSpy.count(), 4);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
+}
+
+void tst_qpieseries::releasedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieslice::pressedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // add some slices
+    QPieSlice *s1 = m_series->append("slice 1", 1);
+    QPieSlice *s2 = m_series->append("slice 2", 1);
+    QPieSlice *s3 = m_series->append("slice 3", 1);
+    QPieSlice *s4 = m_series->append("slice 4", 1);
+    QSignalSpy clickSpy(m_series, SIGNAL(released(QPieSlice*)));
+
+    // add series to the chart
+    m_view->chart()->legend()->setVisible(false);
+    m_view->chart()->addSeries(m_series);
+    m_view->show();
+    QTest::qWaitForWindowShown(m_view);
+
+    // test maximum size
+    m_series->setPieSize(1.0);
+    QRectF pieRect = m_view->chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
+    TRY_COMPARE(clickSpy.count(), 4);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
+    clickSpy.clear();
+
+    // test half size
+    m_series->setPieSize(0.5);
+    m_series->setVerticalPosition(0.25);
+    m_series->setHorizontalPosition(0.25);
+    pieRect = QRectF(m_view->chart()->plotArea().topLeft(), m_view->chart()->plotArea().center());
+    points = slicePoints(pieRect);
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, points.at(3));
+    TRY_COMPARE(clickSpy.count(), 4);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s2);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s4);
+}
+
+void tst_qpieseries::doubleClickedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieslice::pressedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // add some slices
+    QPieSlice *s1 = m_series->append("slice 1", 1);
+    QSignalSpy clickSpy(m_series, SIGNAL(doubleClicked(QPieSlice*)));
+
+    // add series to the chart
+    m_view->chart()->legend()->setVisible(false);
+    m_view->chart()->addSeries(m_series);
+    m_view->show();
+    QTest::qWaitForWindowShown(m_view);
+
+    // test maximum size
+    m_series->setPieSize(1.0);
+    QRectF pieRect = m_view->chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseDClick(m_view->viewport(), Qt::LeftButton, 0, points.at(0));
+    TRY_COMPARE(clickSpy.count(), 1);
+    QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s1);
+}
+
 QTEST_MAIN(tst_qpieseries)
 
 #include "tst_qpieseries.moc"
diff --git a/tests/auto/qpieslice/tst_qpieslice.cpp b/tests/auto/qpieslice/tst_qpieslice.cpp
index 16099cfd..9887d36b 100644
--- a/tests/auto/qpieslice/tst_qpieslice.cpp
+++ b/tests/auto/qpieslice/tst_qpieslice.cpp
@@ -43,6 +43,9 @@ private slots:
     void customize();
     void clickedSignal();
     void hoverSignal();
+    void pressedSignal();
+    void releasedSignal();
+    void doubleClickedSignal();
 
 private:
     QList<QPoint> slicePoints(QRectF rect);
@@ -335,6 +338,114 @@ QList<QPoint> tst_qpieslice::slicePoints(QRectF rect)
     return points;
 }
 
+void tst_qpieslice::pressedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieseries::pressedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // create a pie series
+    QPieSeries *series = new QPieSeries();
+    QPieSlice *s1 = series->append("slice 1", 1);
+    QPieSlice *s2 = series->append("slice 2", 1);
+    QPieSlice *s3 = series->append("slice 3", 1);
+    QPieSlice *s4 = series->append("slice 4", 1);
+    QSignalSpy clickSpy1(s1, SIGNAL(pressed()));
+    QSignalSpy clickSpy2(s2, SIGNAL(pressed()));
+    QSignalSpy clickSpy3(s3, SIGNAL(pressed()));
+    QSignalSpy clickSpy4(s4, SIGNAL(pressed()));
+
+    // add series to the chart
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // simulate clicks
+    series->setPieSize(1.0);
+    QRectF pieRect = view.chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(3));
+    QCOMPARE(clickSpy1.count(), 1);
+    QCOMPARE(clickSpy2.count(), 1);
+    QCOMPARE(clickSpy3.count(), 1);
+    QCOMPARE(clickSpy4.count(), 1);
+}
+
+void tst_qpieslice::releasedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieseries::releasedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // create a pie series
+    QPieSeries *series = new QPieSeries();
+    QPieSlice *s1 = series->append("slice 1", 1);
+    QPieSlice *s2 = series->append("slice 2", 1);
+    QPieSlice *s3 = series->append("slice 3", 1);
+    QPieSlice *s4 = series->append("slice 4", 1);
+    QSignalSpy clickSpy1(s1, SIGNAL(released()));
+    QSignalSpy clickSpy2(s2, SIGNAL(released()));
+    QSignalSpy clickSpy3(s3, SIGNAL(released()));
+    QSignalSpy clickSpy4(s4, SIGNAL(released()));
+
+    // add series to the chart
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // simulate clicks
+    series->setPieSize(1.0);
+    QRectF pieRect = view.chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(0));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(1));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(2));
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, points.at(3));
+    QCOMPARE(clickSpy1.count(), 1);
+    QCOMPARE(clickSpy2.count(), 1);
+    QCOMPARE(clickSpy3.count(), 1);
+    QCOMPARE(clickSpy4.count(), 1);
+}
+
+void tst_qpieslice::doubleClickedSignal()
+{
+    // NOTE:
+    // This test is the same as tst_qpieseries::doubleClickedSignal()
+    // Just for different signals.
+
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    // create a pie series
+    QPieSeries *series = new QPieSeries();
+    QPieSlice *s1 = series->append("slice 1", 1);
+    QSignalSpy clickSpy1(s1, SIGNAL(doubleClicked()));
+
+    // add series to the chart
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // simulate clicks
+    series->setPieSize(1.0);
+    QRectF pieRect = view.chart()->plotArea();
+    QList<QPoint> points = slicePoints(pieRect);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, points.at(0));
+    QCOMPARE(clickSpy1.count(), 1);
+}
+
 QTEST_MAIN(tst_qpieslice)
 
 #include "tst_qpieslice.moc"
diff --git a/tests/auto/qscatterseries/tst_qscatterseries.cpp b/tests/auto/qscatterseries/tst_qscatterseries.cpp
index c68d9999..3872c7bf 100644
--- a/tests/auto/qscatterseries/tst_qscatterseries.cpp
+++ b/tests/auto/qscatterseries/tst_qscatterseries.cpp
@@ -36,6 +36,9 @@ private slots:
     void qscatterseries_data();
     void qscatterseries();
     void scatterChangedSignals();
+    void pressedSignal();
+    void releasedSignal();
+    void doubleClickedSignal();
 
 protected:
     void pointsVisible_data();
@@ -126,6 +129,99 @@ void tst_QScatterSeries::scatterChangedSignals()
     TRY_COMPARE(colorSpy.count(), 2);
 }
 
+void tst_QScatterSeries::pressedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF scatterPoint(4, 12);
+    QScatterSeries *scatterSeries = new QScatterSeries();
+    scatterSeries->append(QPointF(2, 1));
+    scatterSeries->append(scatterPoint);
+    scatterSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(scatterSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(scatterSeries, SIGNAL(pressed(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
+}
+
+void tst_QScatterSeries::releasedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF scatterPoint(4, 12);
+    QScatterSeries *scatterSeries = new QScatterSeries();
+    scatterSeries->append(QPointF(2, 1));
+    scatterSeries->append(scatterPoint);
+    scatterSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(scatterSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(scatterSeries, SIGNAL(released(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
+}
+
+void tst_QScatterSeries::doubleClickedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF scatterPoint(4, 12);
+    QScatterSeries *scatterSeries = new QScatterSeries();
+    scatterSeries->append(QPointF(2, 1));
+    scatterSeries->append(scatterPoint);
+    scatterSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(scatterSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(scatterSeries, SIGNAL(doubleClicked(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
+}
+
 QTEST_MAIN(tst_QScatterSeries)
 
 #include "tst_qscatterseries.moc"
diff --git a/tests/auto/qsplineseries/tst_qsplineseries.cpp b/tests/auto/qsplineseries/tst_qsplineseries.cpp
index b72ac81d..8041d28b 100644
--- a/tests/auto/qsplineseries/tst_qsplineseries.cpp
+++ b/tests/auto/qsplineseries/tst_qsplineseries.cpp
@@ -35,6 +35,9 @@ public slots:
 private slots:
     void qsplineseries_data();
     void qsplineseries();
+    void pressedSignal();
+    void releasedSignal();
+    void doubleClickedSignal();
 protected:
     void pointsVisible_data();
 };
@@ -95,6 +98,98 @@ void tst_QSplineSeries::qsplineseries()
     QTest::qWaitForWindowShown(m_view);
 }
 
+void tst_QSplineSeries::pressedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF splinePoint(4, 12);
+    QSplineSeries *splineSeries = new QSplineSeries();
+    splineSeries->append(QPointF(2, 1));
+    splineSeries->append(splinePoint);
+    splineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(splineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(splineSeries, SIGNAL(pressed(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
+}
+
+void tst_QSplineSeries::releasedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF splinePoint(4, 12);
+    QSplineSeries *splineSeries = new QSplineSeries();
+    splineSeries->append(QPointF(2, 20));
+    splineSeries->append(splinePoint);
+    splineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(splineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(splineSeries, SIGNAL(released(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
+}
+
+void tst_QSplineSeries::doubleClickedSignal()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QPointF splinePoint(4, 12);
+    QSplineSeries *splineSeries = new QSplineSeries();
+    splineSeries->append(QPointF(2, 20));
+    splineSeries->append(splinePoint);
+    splineSeries->append(QPointF(6, 12));
+
+    QChartView view;
+    view.chart()->legend()->setVisible(false);
+    view.chart()->addSeries(splineSeries);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    QSignalSpy seriesSpy(splineSeries, SIGNAL(doubleClicked(QPointF)));
+
+    QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
+    // this causes small distinction in decimals so we round it before comparing
+    QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
+    QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
+    QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
+}
 QTEST_MAIN(tst_QSplineSeries)
 
 #include "tst_qsplineseries.moc"
diff --git a/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp b/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp
index a5df87d2..bda94704 100644
--- a/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp
+++ b/tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp
@@ -51,6 +51,9 @@ private slots:
     void mouseclicked();
     void mousehovered_data();
     void mousehovered();
+    void mousePressed();
+    void mouseReleased();
+    void mouseDoubleClicked();
 
 private:
     QStackedBarSeries* m_barseries;
@@ -595,6 +598,424 @@ void tst_QStackedBarSeries::mousehovered()
     QVERIFY(setIndexSpyArg.at(1).toInt() == 1);
 }
 
+void tst_QStackedBarSeries::mousePressed()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QStackedBarSeries* series = new QStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(pressed(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(pressed(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(pressed(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
+    qreal rangeX = 3;   // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yMax = height + scaleY * domainMinY + plotArea.top();
+        qreal yMin = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            if (rectHeight < 0) {
+                QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMax -= rectHeight;
+            } else {
+                QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMin -= rectHeight;
+            }
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QStackedBarSeries::mouseReleased()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QStackedBarSeries* series = new QStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(released(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(released(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(released(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
+    qreal rangeX = 3;   // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yMax = height + scaleY * domainMinY + plotArea.top();
+        qreal yMin = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            if (rectHeight < 0) {
+                QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMax -= rectHeight;
+            } else {
+                QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMin -= rectHeight;
+            }
+        }
+    }
+
+//====================================================================================
+// barset 1, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 1, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(2).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 1, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(4).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+
+//====================================================================================
+// barset 2, bar 0
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(1).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+
+//====================================================================================
+// barset 2, bar 1
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(3).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 1);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 1);
+
+//====================================================================================
+// barset 2, bar 2
+    QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.at(5).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 0);
+    QCOMPARE(setSpy2.count(), 1);
+
+    seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 2);
+
+    setSpyArg = setSpy2.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 2);
+}
+
+void tst_QStackedBarSeries::mouseDoubleClicked()
+{
+    SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
+
+    QStackedBarSeries* series = new QStackedBarSeries();
+
+    QBarSet* set1 = new QBarSet(QString("set 1"));
+    *set1 << 10 << 10 << 10;
+    series->append(set1);
+
+    QBarSet* set2 = new QBarSet(QString("set 2"));
+    *set2 << 10 << 10 << 10;
+    series->append(set2);
+    QList<QBarSet*> barSets = series->barSets();
+
+    QSignalSpy seriesSpy(series,SIGNAL(doubleClicked(int,QBarSet*)));
+    QSignalSpy setSpy1(set1, SIGNAL(doubleClicked(int)));
+    QSignalSpy setSpy2(set2, SIGNAL(doubleClicked(int)));
+
+    QChartView view(new QChart());
+    view.resize(400,300);
+    view.chart()->addSeries(series);
+    view.show();
+    QTest::qWaitForWindowShown(&view);
+
+    // Calculate expected layout for bars
+    QRectF plotArea = view.chart()->plotArea();
+    qreal width = plotArea.width();
+    qreal height = plotArea.height();
+    qreal rangeY = 20;  // From 0 to 20 because sets are stacked (this should be height of highest stack)
+    qreal rangeX = 3;   // 3 values per set
+    qreal scaleY = (height / rangeY);
+    qreal scaleX = (width / rangeX);
+
+    qreal setCount = series->count();
+    qreal domainMinY = 0;       // These come from internal domain used by barseries.
+    qreal domainMinX = -0.5;    // No access to domain from outside, so use hard coded values.
+    qreal rectWidth = scaleX * series->barWidth();
+
+    QVector<QRectF> layout;
+
+    // 3 = count of values in set
+    // Note that rects in this vector will be interleaved (set1 bar0, set2 bar0, set1 bar1, set2 bar1, etc.)
+    for (int i = 0; i < 3; i++) {
+        qreal yMax = height + scaleY * domainMinY + plotArea.top();
+        qreal yMin = height + scaleY * domainMinY + plotArea.top();
+        for (int set = 0; set < setCount; set++) {
+            qreal xPos = (i - domainMinX) * scaleX + plotArea.left() - rectWidth/2;
+            qreal rectHeight = barSets.at(set)->at(i) * scaleY;
+            if (rectHeight < 0) {
+                QRectF rect(xPos, yMax-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMax -= rectHeight;
+            } else {
+                QRectF rect(xPos, yMin-rectHeight, rectWidth, rectHeight);
+                layout.append(rect);
+                yMin -= rectHeight;
+            }
+        }
+    }
+
+    // barset 1, bar 0
+    QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.at(0).center().toPoint());
+    QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
+
+    QCOMPARE(seriesSpy.count(), 1);
+    QCOMPARE(setSpy1.count(), 1);
+    QCOMPARE(setSpy2.count(), 0);
+
+    QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
+    QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
+    QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(seriesSpyArg.at(0).toInt() == 0);
+
+    QList<QVariant> setSpyArg = setSpy1.takeFirst();
+    QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
+    QVERIFY(setSpyArg.at(0).toInt() == 0);
+}
 QTEST_MAIN(tst_QStackedBarSeries)
 
 #include "tst_qstackedbarseries.moc"
diff --git a/tests/manual/boxplottester/mainwidget.cpp b/tests/manual/boxplottester/mainwidget.cpp
index 784512d3..81a05f67 100644
--- a/tests/manual/boxplottester/mainwidget.cpp
+++ b/tests/manual/boxplottester/mainwidget.cpp
@@ -250,8 +250,15 @@ void MainWidget::addSeries()
     m_series[m_seriesCount]->setName("Box & Whiskers");
 
     connect(m_series[m_seriesCount], SIGNAL(clicked(QBoxSet*)), this, SLOT(boxClicked(QBoxSet*)));
+    connect(m_series[m_seriesCount], SIGNAL(pressed(QBoxSet*)), this, SLOT(boxPressed(QBoxSet*)));
+    connect(m_series[m_seriesCount], SIGNAL(released(QBoxSet*)), this, SLOT(boxReleased(QBoxSet*)));
+    connect(m_series[m_seriesCount], SIGNAL(doubleClicked(QBoxSet*)),
+            this, SLOT(boxDoubleClicked(QBoxSet*)));
     connect(m_series[m_seriesCount], SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(boxHovered(bool, QBoxSet*)));
     connect(set1, SIGNAL(clicked()), this, SLOT(singleBoxClicked()));
+    connect(set1, SIGNAL(pressed()), this, SLOT(singleBoxPressed()));
+    connect(set1, SIGNAL(released()), this, SLOT(singleBoxReleased()));
+    connect(set1, SIGNAL(doubleClicked()), this, SLOT(singleBoxDoubleClicked()));
     connect(set2, SIGNAL(hovered(bool)), this, SLOT(singleBoxHovered(bool)));
 
     m_series[m_seriesCount]->setBoxOutlineVisible(m_boxOutlined->checkState());
@@ -453,11 +460,41 @@ void MainWidget::boxHovered(bool state, QBoxSet *set)
         qDebug() << "box median " << set->at(QBoxSet::Median) << " hover ended";
 }
 
+void MainWidget::boxPressed(QBoxSet *set)
+{
+    qDebug() << "boxPressed, median = " << set->at(QBoxSet::Median);
+}
+
+void MainWidget::boxReleased(QBoxSet *set)
+{
+    qDebug() << "boxReleased, median = " << set->at(QBoxSet::Median);
+}
+
+void MainWidget::boxDoubleClicked(QBoxSet *set)
+{
+    qDebug() << "boxDoubleClicked, median = " << set->at(QBoxSet::Median);
+}
+
 void MainWidget::singleBoxClicked()
 {
     qDebug() << "singleBoxClicked";
 }
 
+void MainWidget::singleBoxPressed()
+{
+    qDebug() << "singleBoxPressed";
+}
+
+void MainWidget::singleBoxReleased()
+{
+    qDebug() << "singleBoxReleased";
+}
+
+void MainWidget::singleBoxDoubleClicked()
+{
+    qDebug() << "singleBoxDoubleClicked";
+}
+
 void MainWidget::singleBoxHovered(bool state)
 {
     if (state)
diff --git a/tests/manual/boxplottester/mainwidget.h b/tests/manual/boxplottester/mainwidget.h
index cbb2cd38..00f835bf 100644
--- a/tests/manual/boxplottester/mainwidget.h
+++ b/tests/manual/boxplottester/mainwidget.h
@@ -66,8 +66,14 @@ private slots:
     void changeChartTheme(int themeIndex);
     void boxClicked(QBoxSet *set);
     void boxHovered(bool state, QBoxSet *set);
+    void boxPressed(QBoxSet *set);
+    void boxReleased(QBoxSet *set);
+    void boxDoubleClicked(QBoxSet *set);
     void singleBoxClicked();
     void singleBoxHovered(bool state);
+    void singleBoxPressed();
+    void singleBoxReleased();
+    void singleBoxDoubleClicked();
     void changePen();
     void antialiasingToggled(bool);
     void boxOutlineToggled(bool);
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml
index 069e17de..d94f8a2e 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml
@@ -81,6 +81,9 @@ ChartView {
                                                      + font.family);
         onPointLabelsColorChanged:       console.log(name + ".onPointLabelsColorChanged: "
                                                      + color);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 
     AreaSeries {
@@ -107,5 +110,8 @@ ChartView {
         onSelected:                 console.log(name + ".onSelected");
         onColorChanged:             console.log(name + ".onColorChanged: " + color);
         onBorderColorChanged:       console.log(name + ".onBorderColorChanged: " + borderColor);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 }
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml
index ad088646..45bd494a 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/BarChart.qml
@@ -51,6 +51,10 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
+
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -65,6 +69,9 @@ ChartView {
         onCountChanged:             console.log("barSeries.onCountChanged: " + count);
         onLabelsFormatChanged:      console.log("barSeries.onLabelsFormatChanged: " + format);
         onLabelsPositionChanged:    console.log("barSeries.onLabelsPositionChanged: " + series.labelsPosition);
+        onPressed:              console.log("barSeries.onPressed: " + barset + " " + index);
+        onReleased:             console.log("barSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked:        console.log("barSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml
index aedb26cb..278d2964 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalBarChart.qml
@@ -50,6 +50,9 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -66,6 +69,9 @@ ChartView {
                                                 + format);
         onLabelsPositionChanged:    console.log("horizontalBarSeries.onLabelsPositionChanged: "
                                                 + series.labelsPosition);
+        onPressed:          console.log("horizontalBarSeries.onPressed: " + barset + " " + index);
+        onReleased:         console.log("horizontalBarSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked:    console.log("horizontalBarSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml
index c0d1b443..eab84f71 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalPercentBarChart.qml
@@ -50,6 +50,9 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -68,6 +71,9 @@ ChartView {
         onLabelsPositionChanged:    console.log(
                                         "horizontalPercentBarSeries.onLabelsPositionChanged: "
                                         + series.labelsPosition);
+        onPressed:          console.log("horizontalPercentBarSeries.onPressed: " + barset + " " + index);
+        onReleased:         console.log("horizontalPercentBarSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked:    console.log("horizontalPercentBarSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml
index 3b94e89d..ab79dc5a 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/HorizontalStackedBarChart.qml
@@ -50,6 +50,9 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -68,6 +71,9 @@ ChartView {
         onLabelsPositionChanged:    console.log(
                                         "horizontalStackedBarSeries.onLabelsPositionChanged: "
                                         + series.labelsPosition);
+        onPressed:          console.log("horizontalStackedBarSeries.onPressed: " + barset + " " + index);
+        onReleased:         console.log("horizontalStackedBarSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked:    console.log("horizontalStackedBarSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml
index de3134a8..6e16918a 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/LineChart.qml
@@ -62,6 +62,9 @@ ChartView {
                                                      + font.family);
         onPointLabelsColorChanged:       console.log("lineSeries.onPointLabelsColorChanged: "
                                                      + color);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 
     LineSeries {
@@ -74,5 +77,8 @@ ChartView {
         XYPoint { x: 4.1; y: 2.3 }
         onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
         onHovered:                  console.log(name + ".onHovered: " + point.x + ", " + point.y);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 }
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml
index 74c9b88f..c595873f 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml
@@ -51,6 +51,9 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -67,6 +70,9 @@ ChartView {
                                                 + format);
         onLabelsPositionChanged:    console.log("percentBarSeries.onLabelsPositionChanged: "
                                                 + series.labelsPosition);
+        onPressed:       console.log("percentBarSeries.onPressed: " + barset + " " + index);
+        onReleased:      console.log("percentBarSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked: console.log("percentBarSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml
index 37a321ae..675ae3ee 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/PieChart.qml
@@ -47,6 +47,9 @@ ChartView {
             onAngleSpanChanged:     console.log("slice.onAngleSpanChanged: " + angleSpan);
             onClicked:              console.log("slice.onClicked: " + label);
             onHovered:              console.log("slice.onHovered: " + state);
+            onPressed:              console.log("slice.onPressed: " + label);
+            onReleased:             console.log("slice.onReleased: " + label);
+            onDoubleClicked:        console.log("slice.onDoubleClicked: " + label);
         }
         PieSlice { label: "slice2"; value: 22 }
         PieSlice { label: "slice3"; value: 33 }
@@ -63,5 +66,8 @@ ChartView {
         onSliceRemoved:             console.log("pieSeries.onSliceRemoved: " + slice.label);
         onCountChanged:             console.log("pieSeries.onCountChanged: " + count);
         onSumChanged:               console.log("pieSeries.onSumChanged: " + sum);
+        onPressed:                  console.log("pieSeries.onPressed: " + slice.label);
+        onReleased:                 console.log("pieSeries.onReleased: " + slice.label);
+        onDoubleClicked:            console.log("pieSeries.onDoubleClicked: " + slice.label);
     }
 }
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml
index d531ac32..2b815530 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/ScatterChart.qml
@@ -59,6 +59,9 @@ ChartView {
                                                      + font.family);
         onPointLabelsColorChanged:       console.log("lineSeries.onPointLabelsColorChanged: "
                                                      + color);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 
     ScatterSeries {
@@ -71,5 +74,8 @@ ChartView {
         XYPoint { x: 2.67; y: 2.65 }
         onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
         onHovered:                  console.log(name + ".onHovered: " + point.x + ", " + point.y);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 }
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml
index 3a182d19..fd78a449 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/SplineChart.qml
@@ -61,6 +61,9 @@ ChartView {
                                                      + font.family);
         onPointLabelsColorChanged:       console.log("splineSeries.onPointLabelsColorChanged: "
                                                      + color);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 
     SplineSeries {
@@ -73,5 +76,8 @@ ChartView {
         XYPoint { x: 4.1; y: 2.3 }
         onClicked:                  console.log(name + ".onClicked: " + point.x + ", " + point.y);
         onHovered:                  console.log(name + ".onHovered: " + point.x + ", " + point.y);
+        onPressed:          console.log(name + ".onPressed: " + point.x + ", " + point.y);
+        onReleased:         console.log(name + ".onReleased: " + point.x + ", " + point.y);
+        onDoubleClicked:    console.log(name + ".onDoubleClicked: " + point.x + ", " + point.y);
     }
 }
diff --git a/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml b/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml
index a59f0e12..aff78367 100644
--- a/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml
+++ b/tests/manual/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml
@@ -50,6 +50,9 @@ ChartView {
             onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
             onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
             onValueChanged:             console.log("barset.onValuesChanged: " + index);
+            onPressed:                  console.log("barset.onPressed: " + index);
+            onReleased:                 console.log("barset.onReleased: " + index);
+            onDoubleClicked:            console.log("barset.onDoubleClicked: " + index);
         }
         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
@@ -66,6 +69,9 @@ ChartView {
                                                 + format);
         onLabelsPositionChanged:    console.log("stackedBarSeries.onLabelsPositionChanged: "
                                                 + series.labelsPosition);
+        onPressed:       console.log("stackedBarSeries.onPressed: " + barset + " " + index);
+        onReleased:      console.log("stackedBarSeries.onReleased: " + barset + " " + index);
+        onDoubleClicked: console.log("stackedBarSeries.onDoubleClicked: " + barset + " " + index);
 
         function changeLabelsPosition() {
             if (labelsPosition === BarSeries.LabelsCenter)