Merge remote-tracking branch 'origin/5.14' into 5.15

 Conflicts:
	.qmake.conf
	src/qml/types/qqmlbind.cpp
	src/quick/items/qquicklistview.cpp
	tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp

Change-Id: Id6805c13256ad13d5651011e5dd09bba0ec02987

9 files changed, 760 insertions, 6 deletions

diff --git a/tests/auto/qml/qqmlecmascript/data/sequenceConversion.write.error.qml b/tests/auto/qml/qqmlecmascript/data/sequenceConversion.write.error.qml
index 75beafd1ee..c2c8c1b52b 100644
--- a/tests/auto/qml/qqmlecmascript/data/sequenceConversion.write.error.qml
+++ b/tests/auto/qml/qqmlecmascript/data/sequenceConversion.write.error.qml
@@ -12,7 +12,7 @@ Item {
 
     function performTest() {
         // we have NOT registered QList<QPoint> as a type
-        var pointList = [ Qt.point(7,7), Qt.point(8,8), Qt.point(9,9) ];
+        var pointList = [ Qt.point(7,7), "hello world", Qt.point(8,8), Qt.point(9,9) ];
         msco.pointListProperty = pointList; // error.
     }
 }
diff --git a/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp b/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
index 558647e17a..2a1457d818 100644
--- a/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
+++ b/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
@@ -5823,13 +5823,12 @@ void tst_qqmlecmascript::sequenceConversionWrite()
         MySequenceConversionObject *seq = object->findChild<MySequenceConversionObject*>("msco");
         QVERIFY(seq != nullptr);
 
-        // we haven't registered QList<QPoint> as a sequence type, so writing shouldn't work.
-        QString warningOne = qmlFile.toString() + QLatin1String(":16: Error: Cannot assign QJSValue to QList<QPoint>");
-        QTest::ignoreMessage(QtWarningMsg, warningOne.toLatin1().constData());
-
+        // Behavior change in 5.14: due to added auto-magical conversions, it is possible to assign to
+        // QList<QPoint>, even though it is not a registered sequence type
+        QTest::ignoreMessage(QtMsgType::QtWarningMsg, QRegularExpression("Could not convert array value at position 1 from QString to QPoint"));
         QMetaObject::invokeMethod(object, "performTest");
 
-        QList<QPoint> pointList; pointList << QPoint(1, 2) << QPoint(3, 4) << QPoint(5, 6); // original values, shouldn't have changed
+        QList<QPoint> pointList; pointList << QPoint(7, 7) << QPoint(0,0) << QPoint(8, 8) << QPoint(9, 9); // original values, shouldn't have changed
         QCOMPARE(seq->pointListProperty(), pointList);
 
         delete object;
diff --git a/tests/auto/qml/qqmllanguage/data/arrayToContainer.qml b/tests/auto/qml/qqmllanguage/data/arrayToContainer.qml
new file mode 100644
index 0000000000..ee400eb41f
--- /dev/null
+++ b/tests/auto/qml/qqmllanguage/data/arrayToContainer.qml
@@ -0,0 +1,7 @@
+import QtQml 2.14
+import qt.test 1.0
+
+TestItem {
+    property var vector
+    positions: vector
+}
diff --git a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
index 5966831183..4f2e203ec2 100644
--- a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
+++ b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
@@ -324,6 +324,8 @@ private slots:
     void listContainingDeletedObject();
     void overrideSingleton();
 
+    void arrayToContainer();
+
 private:
     QQmlEngine engine;
     QStringList defaultImportPathList;
@@ -5640,6 +5642,31 @@ void tst_qqmllanguage::nonExistingInlineComponent()
     QCOMPARE(error.column(), column);
 }
 
+class TestItem : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY( QVector<QPointF> positions MEMBER m_points  )
+
+public:
+    TestItem() = default;
+    QVector< QPointF > m_points;
+};
+
+
+Q_DECLARE_METATYPE(QVector<QPointF>);
+void tst_qqmllanguage::arrayToContainer()
+{
+    QQmlEngine engine;
+    qmlRegisterType<TestItem>("qt.test", 1, 0, "TestItem");
+    QVector<QPointF> points { QPointF (2.0, 3.0) };
+    engine.rootContext()->setContextProperty("test", QVariant::fromValue(points));
+    QQmlComponent component(&engine, testFileUrl("arrayToContainer.qml"));
+    VERIFY_ERRORS(0);
+    QScopedPointer<TestItem> root(qobject_cast<TestItem *>(component.createWithInitialProperties( {{"vector", QVariant::fromValue(points)}} )));
+    QVERIFY(root);
+    QCOMPARE(root->m_points.at(0), QPointF (2.0, 3.0) );
+}
+
 QTEST_MAIN(tst_qqmllanguage)
 
 #include "tst_qqmllanguage.moc"
diff --git a/tests/auto/quick/qquickflickable/data/visibleAreaBinding.qml b/tests/auto/quick/qquickflickable/data/visibleAreaBinding.qml
new file mode 100644
index 0000000000..6f7bc89793
--- /dev/null
+++ b/tests/auto/quick/qquickflickable/data/visibleAreaBinding.qml
@@ -0,0 +1,38 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.14
+
+Flickable {
+    id: flickable
+    // Deliberately has no size set.
+
+    Text {
+        text: flickable.visibleArea.xPosition
+    }
+}
diff --git a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
index 5364530ca8..f3659290eb 100644
--- a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
+++ b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
@@ -205,6 +205,7 @@ private slots:
     void overshoot_reentrant();
     void synchronousDrag_data();
     void synchronousDrag();
+    void visibleAreaBinding();
 
 private:
     void flickWithTouch(QQuickWindow *window, const QPoint &from, const QPoint &to);
@@ -2540,6 +2541,16 @@ void tst_qquickflickable::synchronousDrag()
     QTest::touchEvent(window, touchDevice).release(0, p5, window);
 }
 
+// QTBUG-81098: tests that a binding to visibleArea doesn't result
+// in a division-by-zero exception (when exceptions are enabled).
+void tst_qquickflickable::visibleAreaBinding()
+{
+    QScopedPointer<QQuickView> window(new QQuickView);
+    window->setSource(testFileUrl("visibleAreaBinding.qml"));
+    QTRY_COMPARE(window->status(), QQuickView::Ready);
+    // Shouldn't crash.
+}
+
 QTEST_MAIN(tst_qquickflickable)
 
 #include "tst_qquickflickable.moc"
diff --git a/tests/auto/quick/qquicklistview/data/headerSnapToItem.qml b/tests/auto/quick/qquicklistview/data/headerSnapToItem.qml
new file mode 100644
index 0000000000..1e5a811630
--- /dev/null
+++ b/tests/auto/quick/qquicklistview/data/headerSnapToItem.qml
@@ -0,0 +1,67 @@
+import QtQuick 2.12
+
+Rectangle {
+
+    width: 240
+    height: 320
+    color: "#ffffff"
+
+    Component {
+        id: myDelegate
+        Rectangle {
+            id: wrapper
+            objectName: "wrapper"
+            width: list.orientation == ListView.Vertical ? 240 : 20
+            height: list.orientation == ListView.Vertical ? 20 : 240
+            border.width: 1
+            border.color: "black"
+            Text {
+                text: index + ":" + (list.orientation == ListView.Vertical ? parent.y : parent.x).toFixed(0)
+            }
+            color: ListView.isCurrentItem ? "lightsteelblue" : "white"
+        }
+    }
+
+    ListView {
+        id: list
+        objectName: "list"
+        focus: true
+        width: 240
+        height: 200
+        clip: true
+        snapMode: ListView.SnapToItem
+        headerPositioning: ListView.OverlayHeader
+        model: 30
+        delegate: myDelegate
+        orientation: ListView.Vertical
+        verticalLayoutDirection: ListView.BottomToTop
+
+        header: Rectangle {
+            width: list.orientation == Qt.Vertical ? 240 : 30
+            height: list.orientation == Qt.Vertical ? 30 : 240
+            objectName: "header";
+            color: "green"
+            z: 11
+            Text {
+                anchors.centerIn: parent
+                text: "header " + (list.orientation == ListView.Vertical ? parent.y : parent.x).toFixed(1)
+            }
+        }
+    }
+
+    Rectangle {
+        color: "red"
+        opacity: 0.5
+        width: txt.implicitWidth + 50
+        height: txt.implicitHeight
+        anchors.bottom: parent.bottom
+        anchors.right: parent.right
+
+        Text {
+            id: txt
+            anchors.centerIn: parent
+            text:  "header position: " + (list.orientation == ListView.Vertical ? list.headerItem.y : list.headerItem.x).toFixed(1)
+              + "\ncontent position: " + (list.orientation == ListView.Vertical ? list.contentY : list.contentX).toFixed(1)
+        }
+    }
+}
diff --git a/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp b/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
index 9a8dfee9d2..45d16cc415 100644
--- a/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
+++ b/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
@@ -30,6 +30,7 @@
 #include <QtCore/QStringListModel>
 #include <QtCore/QSortFilterProxyModel>
 #include <QtGui/QStandardItemModel>
+#include <QtGui/QStyleHints>
 #include <QtQuick/qquickview.h>
 #include <QtQuickTest/QtQuickTest>
 #include <QtQml/qqmlengine.h>
@@ -185,6 +186,8 @@ private slots:
     void creationContext();
     void snapToItem_data();
     void snapToItem();
+    void headerSnapToItem_data();
+    void headerSnapToItem();
     void snapToItemWithSpacing_QTBUG_59852();
     void snapOneItemResize_QTBUG_43555();
     void snapOneItem_data();
@@ -5412,6 +5415,604 @@ void tst_QQuickListView::snapToItemWithSpacing_QTBUG_59852()
     releaseView(window);
 }
 
+static void drag_helper(QWindow *window, QPoint *startPos, const QPoint &delta)
+{
+    QPoint pos = *startPos;
+    int dragDistance = delta.manhattanLength();
+    Q_ASSERT(qAbs(delta.x()) >= 1 || qAbs(delta.y()) >= 1);
+
+    const int stepSize = 8;
+    QPoint unitVector(0, 0);
+    if (delta.x())
+        unitVector.setX(qBound(-1, delta.x(), 1));
+    if (delta.y())
+        unitVector.setY(qBound(-1, delta.y(), 1));
+    QPoint dragStepSize = unitVector * stepSize;
+    int nDragSteps = qAbs(dragDistance/stepSize);
+
+    for (int i = 0 ; i < nDragSteps; ++i) {
+        QTest::mouseMove(window, pos);
+        pos += dragStepSize;
+    }
+    // Move to the final position
+    pos = *startPos + delta;
+    QTest::mouseMove(window, pos);
+    *startPos = pos;
+}
+
+static void dragtwice(QWindow *window, QPoint *startPos, const QPoint &delta1, const QPoint &delta2)
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QPoint &pos = *startPos;
+    QPoint unitVector(0, 0);
+    if (delta1.x())
+        unitVector.setX(qBound(-1, delta1.x(), 1));
+    if (delta1.y())
+        unitVector.setY(qBound(-1, delta1.y(), 1));
+
+    // go just beyond the drag theshold
+    drag_helper(window, &pos, unitVector * (dragThreshold + 1));
+    drag_helper(window, &pos, unitVector);
+
+    // next drag will actually scroll the listview
+    if (delta1.manhattanLength() >= 1)
+        drag_helper(window, &pos, delta1);
+    if (delta2.manhattanLength() >= 1)
+        drag_helper(window, &pos, delta2);
+}
+
+struct MyListView : public QQuickListView{
+    qreal contentPosition() const
+    {
+        return (orientation() == QQuickListView::Horizontal ? contentX(): contentY());
+    }
+
+    qreal headerPosition() const
+    {
+        return (orientation() == QQuickListView::Horizontal ? headerItem()->x() : headerItem()->y());
+    }
+};
+
+void tst_QQuickListView::headerSnapToItem()
+{
+    QFETCH(QQuickItemView::LayoutDirection, layoutDirection);
+    QFETCH(QQuickListView::HeaderPositioning, headerPositioning);
+    QFETCH(int, firstDragDistance);
+    QFETCH(int, secondDragDistance);
+    QFETCH(int, expectedContentPosition);
+    QFETCH(int, expectedHeaderPosition);
+
+    QQuickView *window = getView();
+    window->setSource(testFileUrl("headerSnapToItem.qml"));
+    window->show();
+    QVERIFY(QTest::qWaitForWindowExposed(window));
+
+    MyListView *listview = static_cast<MyListView *>(findItem<QQuickListView>(window->rootObject(), "list"));
+    QVERIFY(listview != nullptr);
+
+    const bool horizontal = layoutDirection < QQuickItemView::VerticalTopToBottom;
+    listview->setOrientation(horizontal ? QQuickListView::Horizontal : QQuickListView::Vertical);
+
+    if (horizontal)
+        listview->setLayoutDirection(static_cast<Qt::LayoutDirection>(layoutDirection));
+    else
+        listview->setVerticalLayoutDirection(static_cast<QQuickItemView::VerticalLayoutDirection>(layoutDirection));
+
+    listview->setHeaderPositioning(headerPositioning);
+    QVERIFY(QQuickTest::qWaitForItemPolished(listview));
+
+    QQuickItem *contentItem = listview->contentItem();
+    QVERIFY(contentItem != nullptr);
+    QQuickItem *header = findItem<QQuickItem>(contentItem, "header");
+    QVERIFY(header != nullptr);
+    QCOMPARE(header, listview->headerItem());
+
+    QPoint startPos = (QPointF(listview->width(), listview->height())/2).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, startPos, 200);
+
+    QPoint firstDragDelta(0, firstDragDistance);
+    QPoint secondDragDelta = QPoint(0, secondDragDistance);
+    if (horizontal) {
+        firstDragDelta = firstDragDelta.transposed();
+        secondDragDelta = secondDragDelta.transposed();
+    }
+
+    dragtwice(window, &startPos, firstDragDelta, secondDragDelta);
+
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, startPos, 200);     // Wait 200 ms before we release to avoid trigger a flick
+
+    // wait for the "fixup" animation to finish
+    QTest::qWaitFor([&]()
+        { return !listview->isMoving();}
+    );
+
+    QCOMPARE(listview->contentPosition(), expectedContentPosition);
+    QCOMPARE(listview->headerPosition(),  expectedHeaderPosition);
+}
+
+void tst_QQuickListView::headerSnapToItem_data()
+{
+    QTest::addColumn<QQuickItemView::LayoutDirection>("layoutDirection");
+    QTest::addColumn<QQuickListView::HeaderPositioning>("headerPositioning");
+    QTest::addColumn<int>("firstDragDistance");
+    QTest::addColumn<int>("secondDragDistance");
+    QTest::addColumn<int>("expectedContentPosition");
+    QTest::addColumn<int>("expectedHeaderPosition");
+
+    // --------------------
+    // InlineHeader TopToBottom
+    QTest::newRow("InlineHeader TopToBottom -10") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::InlineHeader
+                                                  << -10 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -14") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::InlineHeader
+                                                  << -14 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -16") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::InlineHeader
+                                                  << -16 << 0
+                                                  << 0 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -30") << QQuickItemView::VerticalTopToBottom
+                                              << QQuickListView::InlineHeader
+                                              << -30 << 0
+                                              << 0 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -39") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::InlineHeader
+                                                  << -39 << 0
+                                                  << 0 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -41") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::InlineHeader
+                                                  << -41 << 0
+                                                  << 20 << -30;
+
+    QTest::newRow("InlineHeader TopToBottom -65+10") << QQuickItemView::VerticalTopToBottom
+                                              << QQuickListView::InlineHeader
+                                              << -65 << 10
+                                              << 20 << -30;
+
+    // --------------------
+    // InlineHeader BottomToTop
+    QTest::newRow("InlineHeader BottomToTop +10") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 10 << 0
+                                                  << -170 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +14") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 14 << 0
+                                                  << -170 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +16") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 16 << 0
+                                                  << -200 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +30") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 30 << 0
+                                                  << -200 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +39") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 39 << 0
+                                                  << -200 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +41") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::InlineHeader
+                                                  << 41 << 0
+                                                  << -220 << 0;
+
+    QTest::newRow("InlineHeader BottomToTop +65-10") << QQuickItemView::VerticalBottomToTop
+                                                     << QQuickListView::InlineHeader
+                                                     << 65 << -10
+                                                     << -220 << 0;
+
+    // --------------------
+    // InlineHeader LeftToRight
+    QTest::newRow("InlineHeader LeftToRight -10") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -10 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -14") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -14 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -16") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -16 << 0
+                                                  << 0 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -30") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -30 << 0
+                                                  << 0 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -39") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -39 << 0
+                                                  << 0 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -41") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::InlineHeader
+                                                  << -41 << 0
+                                                  << 20 << -30;
+
+    QTest::newRow("InlineHeader LeftToRight -65+10") << QQuickItemView::LeftToRight
+                                                     << QQuickListView::InlineHeader
+                                                     << -65 << 10
+                                                     << 20 << -30;
+
+    // --------------------
+    // InlineHeader RightToLeft
+    QTest::newRow("InlineHeader RightToLeft +10") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 10 << 0
+                                                  << -210 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +14") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 14 << 0
+                                                  << -210 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +16") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 16 << 0
+                                                  << -240 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +30") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 30 << 0
+                                                  << -240 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +39") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 39 << 0
+                                                  << -240 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +41") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::InlineHeader
+                                                  << 41 << 0
+                                                  << -260 << 0;
+
+    QTest::newRow("InlineHeader RightToLeft +65-10") << QQuickItemView::RightToLeft
+                                                     << QQuickListView::InlineHeader
+                                                     << 65 << -10
+                                                     << -260 << 0;
+
+    // --------------------
+    // OverlayHeader TopToBottom
+    QTest::newRow("OverlayHeader TopToBottom +9") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::OverlayHeader
+                                                  << 9 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("OverlayHeader TopToBottom -9") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::OverlayHeader
+                                                  << -9 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("OverlayHeader TopToBottom -11") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::OverlayHeader
+                                                  << -11 << 0
+                                                  << -10 << -10;
+
+    QTest::newRow("OverlayHeader TopToBottom -29") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::OverlayHeader
+                                                  << -29 << 0
+                                                  << -10 << -10;
+
+    QTest::newRow("OverlayHeader TopToBottom -31") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::OverlayHeader
+                                                  << -31 << 0
+                                                  << 10 << 10;
+
+    // --------------------
+    // OverlayHeader BottomToTop
+    QTest::newRow("OverlayHeader BottomToTop -9") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::OverlayHeader
+                                                  << -9 << 0
+                                                  << -170 << 0;
+
+    QTest::newRow("OverlayHeader BottomToTop +9") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::OverlayHeader
+                                                  << 9 << 0
+                                                  << -170 << 0;
+
+    QTest::newRow("OverlayHeader BottomToTop +11") << QQuickItemView::VerticalBottomToTop
+                                                   << QQuickListView::OverlayHeader
+                                                   << 11 << 0
+                                                   << -190 << -20;
+
+    QTest::newRow("OverlayHeader BottomToTop +29") << QQuickItemView::VerticalBottomToTop
+                                                   << QQuickListView::OverlayHeader
+                                                   << 29 << 0
+                                                   << -190 << -20;
+
+    QTest::newRow("OverlayHeader BottomToTop +31") << QQuickItemView::VerticalBottomToTop
+                                                   << QQuickListView::OverlayHeader
+                                                   << 31 << 0
+                                                   << -210 << -40;
+
+    // --------------------
+    // OverlayHeader LeftToRight
+    QTest::newRow("OverlayHeader LeftToRight +9") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::OverlayHeader
+                                                  << 9 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("OverlayHeader LeftToRight -9") << QQuickItemView::LeftToRight
+                                                  << QQuickListView::OverlayHeader
+                                                  << -9 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("OverlayHeader LeftToRight -11") << QQuickItemView::LeftToRight
+                                                   << QQuickListView::OverlayHeader
+                                                   << -11 << 0
+                                                   << -10 << -10;
+
+    QTest::newRow("OverlayHeader LeftToRight -29") << QQuickItemView::LeftToRight
+                                                   << QQuickListView::OverlayHeader
+                                                   << -29 << 0
+                                                   << -10 << -10;
+
+    QTest::newRow("OverlayHeader LeftToRight -31") << QQuickItemView::LeftToRight
+                                                   << QQuickListView::OverlayHeader
+                                                   << -31 << 0
+                                                   << 10 << 10;
+
+    // --------------------
+    // OverlayHeader RightToLeft
+    QTest::newRow("OverlayHeader RightToLeft -9") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::OverlayHeader
+                                                  << -9 << 0
+                                                  << -210 << 0;
+
+    QTest::newRow("OverlayHeader RightToLeft +9") << QQuickItemView::RightToLeft
+                                                  << QQuickListView::OverlayHeader
+                                                  << 9 << 0
+                                                  << -210 << 0;
+
+    QTest::newRow("OverlayHeader RightToLeft +11") << QQuickItemView::RightToLeft
+                                                   << QQuickListView::OverlayHeader
+                                                   << 11 << 0
+                                                   << -230 << -20;
+
+    QTest::newRow("OverlayHeader RightToLeft +29") << QQuickItemView::RightToLeft
+                                                   << QQuickListView::OverlayHeader
+                                                   << 29 << 0
+                                                   << -230 << -20;
+
+    QTest::newRow("OverlayHeader RightToLeft +31") << QQuickItemView::RightToLeft
+                                                   << QQuickListView::OverlayHeader
+                                                   << 31 << 0
+                                                   << -250 << -40;
+
+    // --------------------
+    // PullbackHeader TopToBottom
+    QTest::newRow("PullbackHeader TopToBottom -2") << QQuickItemView::VerticalTopToBottom
+                                                    << QQuickListView::PullBackHeader
+                                                    << -2 << 0
+                                                    << -30 << -30;
+
+    QTest::newRow("PullbackHeader TopToBottom -10") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::PullBackHeader
+                                                  << -10 << 0
+                                                  << -30 << -30;
+
+    QTest::newRow("PullbackHeader TopToBottom -11") << QQuickItemView::VerticalTopToBottom
+                                                    << QQuickListView::PullBackHeader
+                                                    << -11 << 0
+                                                    << -10 << -10;
+
+    QTest::newRow("PullbackHeader TopToBottom -14") << QQuickItemView::VerticalTopToBottom
+                                                  << QQuickListView::PullBackHeader
+                                                  << -14 << 0
+                                                  << -10 << -10;
+
+    QTest::newRow("PullbackHeader TopToBottom -16") << QQuickItemView::VerticalTopToBottom
+                                                    << QQuickListView::PullBackHeader
+                                                    << -16 << 0
+                                                    << 0 << -30;
+
+    QTest::newRow("PullbackHeader TopToBottom -20") << QQuickItemView::VerticalTopToBottom
+                                                    << QQuickListView::PullBackHeader
+                                                    << -20 << 0
+                                                    << 0 << -30;
+
+    QTest::newRow("PullbackHeader TopToBottom -65+10") << QQuickItemView::VerticalTopToBottom
+                                                << QQuickListView::PullBackHeader
+                                              << -65 << 10
+                                              << 20 << -10;
+
+    QTest::newRow("PullbackHeader TopToBottom -65+20") << QQuickItemView::VerticalTopToBottom
+                                                << QQuickListView::PullBackHeader
+                                                << -65 << 20
+                                                << 10 << 10;
+
+    // Should move header even if contentY doesn't move (its aligned with top)
+    QTest::newRow("PullbackHeader TopToBottom -55+5") << QQuickItemView::VerticalTopToBottom
+                                                << QQuickListView::PullBackHeader
+                                                << -55 << 5
+                                                << 20 << -10;
+
+    // Should move header even if contentY doesn't move (it's aligned with header)
+    QTest::newRow("PullbackHeader TopToBottom -76+16") << QQuickItemView::VerticalTopToBottom
+                                                    << QQuickListView::PullBackHeader
+                                                    << -76 << 16
+                                                    << 30 << 30;
+
+    // --------------------
+    // PullbackHeader BottomToTop
+    QTest::newRow("PullbackHeader BottomToTop +2") << QQuickItemView::VerticalBottomToTop
+                                                    << QQuickListView::PullBackHeader
+                                                    << +2 << 0
+                                                    << -170 << 0;
+
+    QTest::newRow("PullbackHeader BottomToTop +9") << QQuickItemView::VerticalBottomToTop
+                                                  << QQuickListView::PullBackHeader
+                                                  << +9 << 0
+                                                  << -170 << 0;
+
+    QTest::newRow("PullbackHeader BottomToTop +11") << QQuickItemView::VerticalBottomToTop
+                                                   << QQuickListView::PullBackHeader
+                                                   << +11 << 0
+                                                   << -190 << -20;
+
+    QTest::newRow("PullbackHeader BottomToTop +14") << QQuickItemView::VerticalBottomToTop
+                                                    << QQuickListView::PullBackHeader
+                                                    << +14 << 0
+                                                    << -190 << -20;
+
+    QTest::newRow("PullbackHeader BottomToTop +16") << QQuickItemView::VerticalBottomToTop
+                                                    << QQuickListView::PullBackHeader
+                                                    << +16 << 0
+                                                    << -200 << 0;
+
+    QTest::newRow("PullbackHeader BottomToTop +20") << QQuickItemView::VerticalBottomToTop
+                                                    << QQuickListView::PullBackHeader
+                                                    << +20 << 0
+                                                    << -200 << 0;
+
+    QTest::newRow("PullbackHeader BottomToTop +65-10") << QQuickItemView::VerticalBottomToTop
+                                                    << QQuickListView::PullBackHeader
+                                                    << +65 << -10
+                                                    << -220 << -20;
+
+    QTest::newRow("PullbackHeader BottomToTop +65-20") << QQuickItemView::VerticalBottomToTop
+                                                       << QQuickListView::PullBackHeader
+                                                       << +65 << -20
+                                                       << -210 << -40;
+
+    // Should move header even if contentY doesn't move (it's aligned with top)
+    QTest::newRow("PullbackHeader BottomToTop +55-5") << QQuickItemView::VerticalBottomToTop
+                                                      << QQuickListView::PullBackHeader
+                                                      << 55 << -5
+                                                      << -220 << -20;
+
+    // Should move header even if contentY doesn't move (it's aligned with header)
+    QTest::newRow("PullbackHeader BottomToTop +76-16") << QQuickItemView::VerticalBottomToTop
+                                                       << QQuickListView::PullBackHeader
+                                                       << 76 << -16
+                                                       << -230 << -60;
+
+    // --------------------
+    // PullbackHeader LeftToRight
+    QTest::newRow("PullbackHeader LeftToRight -2") << QQuickItemView::LeftToRight
+                                                   << QQuickListView::PullBackHeader
+                                                   << -2 << 0
+                                                   << -30 << -30;
+
+    QTest::newRow("PullbackHeader LeftToRight -10") << QQuickItemView::LeftToRight
+                                                    << QQuickListView::PullBackHeader
+                                                    << -10 << 0
+                                                    << -30 << -30;
+
+    QTest::newRow("PullbackHeader LeftToRight -11") << QQuickItemView::LeftToRight
+                                                    << QQuickListView::PullBackHeader
+                                                    << -11 << 0
+                                                    << -10 << -10;
+
+    QTest::newRow("PullbackHeader LeftToRight -14") << QQuickItemView::LeftToRight
+                                                    << QQuickListView::PullBackHeader
+                                                    << -14 << 0
+                                                    << -10 << -10;
+
+    QTest::newRow("PullbackHeader LeftToRight -16") << QQuickItemView::LeftToRight
+                                                    << QQuickListView::PullBackHeader
+                                                    << -16 << 0
+                                                    << 0 << -30;
+
+    QTest::newRow("PullbackHeader LeftToRight -20") << QQuickItemView::LeftToRight
+                                                    << QQuickListView::PullBackHeader
+                                                    << -20 << 0
+                                                    << 0 << -30;
+
+    QTest::newRow("PullbackHeader LeftToRight -65+10") << QQuickItemView::LeftToRight
+                                                       << QQuickListView::PullBackHeader
+                                                       << -65 << 10
+                                                       << 20 << -10;
+
+    QTest::newRow("PullbackHeader LeftToRight -65+20") << QQuickItemView::LeftToRight
+                                                       << QQuickListView::PullBackHeader
+                                                       << -65 << 20
+                                                       << 10 << 10;
+
+    // Should move header even if contentX doesn't move (its aligned with top)
+    QTest::newRow("PullbackHeader LeftToRight -55+5") << QQuickItemView::LeftToRight
+                                                      << QQuickListView::PullBackHeader
+                                                      << -55 << 5
+                                                      << 20 << -10;
+
+    // Should move header even if contentX doesn't move (it's aligned with header)
+    QTest::newRow("PullbackHeader LeftToRight -76+16") << QQuickItemView::LeftToRight
+                                                       << QQuickListView::PullBackHeader
+                                                       << -76 << 16
+                                                       << 30 << 30;
+
+    // --------------------
+    // PullbackHeader RightToLeft
+    QTest::newRow("PullbackHeader RightToLeft +2") << QQuickItemView::RightToLeft
+                                                   << QQuickListView::PullBackHeader
+                                                   << +2 << 0
+                                                   << -210 << 0;
+
+    QTest::newRow("PullbackHeader RightToLeft +9") << QQuickItemView::RightToLeft
+                                                   << QQuickListView::PullBackHeader
+                                                   << +9 << 0
+                                                   << -210 << 0;
+
+    QTest::newRow("PullbackHeader RightToLeft +11") << QQuickItemView::RightToLeft
+                                                    << QQuickListView::PullBackHeader
+                                                    << +11 << 0
+                                                    << -230 << -20;
+
+    QTest::newRow("PullbackHeader RightToLeft +14") << QQuickItemView::RightToLeft
+                                                    << QQuickListView::PullBackHeader
+                                                    << +14 << 0
+                                                    << -230 << -20;
+
+    QTest::newRow("PullbackHeader RightToLeft +16") << QQuickItemView::RightToLeft
+                                                    << QQuickListView::PullBackHeader
+                                                    << +16 << 0
+                                                    << -240 << 0;
+
+    QTest::newRow("PullbackHeader RightToLeft +20") << QQuickItemView::RightToLeft
+                                                    << QQuickListView::PullBackHeader
+                                                    << +20 << 0
+                                                    << -240 << 0;
+
+    QTest::newRow("PullbackHeader RightToLeft +65-10") << QQuickItemView::RightToLeft
+                                                       << QQuickListView::PullBackHeader
+                                                       << +65 << -10
+                                                       << -260 << -20;
+
+    QTest::newRow("PullbackHeader RightToLeft +65-20") << QQuickItemView::RightToLeft
+                                                       << QQuickListView::PullBackHeader
+                                                       << +65 << -20
+                                                       << -250 << -40;
+
+    // Should move header even if contentX doesn't move (it's aligned with top)
+    QTest::newRow("PullbackHeader RightToLeft +55-5") << QQuickItemView::RightToLeft
+                                                      << QQuickListView::PullBackHeader
+                                                      << 55 << -5
+                                                      << -260 << -20;
+
+    // Should move header even if contentX doesn't move (it's aligned with header)
+    QTest::newRow("PullbackHeader RightToLeft +76-16") << QQuickItemView::RightToLeft
+                                                       << QQuickListView::PullBackHeader
+                                                       << 76 << -16
+                                                       << -270 << -60;
+
+}
+
 void tst_QQuickListView::snapOneItemResize_QTBUG_43555()
 {
     QScopedPointer<QQuickView> window(createView());
diff --git a/tests/auto/quick/qquickmousearea/BLACKLIST b/tests/auto/quick/qquickmousearea/BLACKLIST
new file mode 100644
index 0000000000..f2cb00225b
--- /dev/null
+++ b/tests/auto/quick/qquickmousearea/BLACKLIST
@@ -0,0 +1,4 @@
+# QTBUG-78153
+[nestedStopAtBounds]
+opensuse-leap
+