diff --git a/0001-Document-that-StyledText-also-supports-nbsp-and-quot.patch b/0001-Document-that-StyledText-also-supports-nbsp-and-quot.patch new file mode 100644 index 0000000000000000000000000000000000000000..867d1075c5e2600bd3c122bab3cda5cf004c8e6f --- /dev/null +++ b/0001-Document-that-StyledText-also-supports-nbsp-and-quot.patch @@ -0,0 +1,29 @@ +From 48fc7f164a347f88c221c6a86614008b63b7767f Mon Sep 17 00:00:00 2001 +From: Albert Astals Cid +Date: Fri, 21 May 2021 13:17:15 +0200 +Subject: [PATCH 01/19] Document that StyledText also supports   and + " + +Change-Id: I1715f8ae8ec8d0fbaf6dbe2b8663cc169da663cd +Reviewed-by: Fabian Kosmale +(cherry picked from commit 5848c081c094a66e024493fc1e5c2569e06f73b6) +--- + src/quick/items/qquicktext.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/quick/items/qquicktext.cpp b/src/quick/items/qquicktext.cpp +index 6230186933..c1571fc6f5 100644 +--- a/src/quick/items/qquicktext.cpp ++++ b/src/quick/items/qquicktext.cpp +@@ -2168,7 +2168,7 @@ void QQuickText::resetMaximumLineCount() + - inline images +
    ,
      and
    • - ordered and unordered lists + 
       - preformatted
+-    > < &
++    > < & "  
+     \endcode
+ 
+     \c Text.StyledText parser is strict, requiring tags to be correctly nested.
+-- 
+2.36.1
+
diff --git a/0002-Support-apos-in-styled-text.patch b/0002-Support-apos-in-styled-text.patch
new file mode 100644
index 0000000000000000000000000000000000000000..ae0d3e6b9faaee4710fd77404c2e424d20b8c3fe
--- /dev/null
+++ b/0002-Support-apos-in-styled-text.patch
@@ -0,0 +1,44 @@
+From 65394fd28a8acaf26039418c21718894891295c6 Mon Sep 17 00:00:00 2001
+From: Albert Astals Cid 
+Date: Fri, 21 May 2021 13:42:35 +0200
+Subject: [PATCH 02/19] Support ' in styled text
+
+Pick-to: 6.1 5.15
+Change-Id: I4a8db963e52a7899ab1796f9a560e8029cc1c929
+Reviewed-by: Fabian Kosmale 
+Reviewed-by: Eskil Abrahamsen Blomfeldt 
+(cherry picked from commit 96b528efcba1226d2980828d1255160bdceae4cf)
+---
+ src/quick/items/qquicktext.cpp      | 2 +-
+ src/quick/util/qquickstyledtext.cpp | 2 ++
+ 2 files changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/src/quick/items/qquicktext.cpp b/src/quick/items/qquicktext.cpp
+index c1571fc6f5..e823ca1095 100644
+--- a/src/quick/items/qquicktext.cpp
++++ b/src/quick/items/qquicktext.cpp
+@@ -2168,7 +2168,7 @@ void QQuickText::resetMaximumLineCount()
+      - inline images
+     
        , 
           and 
        •  - ordered and unordered lists
+     
           - preformatted
+-    > < & "  
++    > < & "   '
+     \endcode
+ 
+     \c Text.StyledText parser is strict, requiring tags to be correctly nested.
+diff --git a/src/quick/util/qquickstyledtext.cpp b/src/quick/util/qquickstyledtext.cpp
+index d531fc9205..a25af90414 100644
+--- a/src/quick/util/qquickstyledtext.cpp
++++ b/src/quick/util/qquickstyledtext.cpp
+@@ -564,6 +564,8 @@ void QQuickStyledTextPrivate::parseEntity(const QChar *&ch, const QString &textI
+                 textOut += QChar(60);
+             else if (entity == QLatin1String("amp"))
+                 textOut += QChar(38);
++            else if (entity == QLatin1String("apos"))
++                textOut += QChar(39);
+             else if (entity == QLatin1String("quot"))
+                 textOut += QChar(34);
+             else if (entity == QLatin1String("nbsp"))
+-- 
+2.36.1
+
diff --git a/0003-Remove-unused-QPointer-QQuickPointerMask.patch b/0003-Remove-unused-QPointer-QQuickPointerMask.patch
new file mode 100644
index 0000000000000000000000000000000000000000..5fe3639369354fc17d6bfa0747cd26e00de3ea09
--- /dev/null
+++ b/0003-Remove-unused-QPointer-QQuickPointerMask.patch
@@ -0,0 +1,35 @@
+From 9828b34ccf14d33bc9a61a4bd37e9e8d7877168a Mon Sep 17 00:00:00 2001
+From: Albert Astals Cid 
+Date: Thu, 17 Jun 2021 16:32:28 +0200
+Subject: [PATCH 03/19] Remove unused QPointer
+
+Change-Id: I009fa6bbd8599dc3bb2e810176fe20e70ed50851
+Reviewed-by: Shawn Rutledge 
+(cherry picked from commit ac03b4b8ee9cc8d4522e0c8cf1018ff086f80c1b)
+---
+ src/quick/items/qquickmousearea_p_p.h | 2 --
+ 1 file changed, 2 deletions(-)
+
+diff --git a/src/quick/items/qquickmousearea_p_p.h b/src/quick/items/qquickmousearea_p_p.h
+index fba383e268..0d63618622 100644
+--- a/src/quick/items/qquickmousearea_p_p.h
++++ b/src/quick/items/qquickmousearea_p_p.h
+@@ -61,7 +61,6 @@ QT_BEGIN_NAMESPACE
+ 
+ class QQuickMouseEvent;
+ class QQuickMouseArea;
+-class QQuickPointerMask;
+ class QQuickMouseAreaPrivate : public QQuickItemPrivate
+ {
+     Q_DECLARE_PUBLIC(QQuickMouseArea)
+@@ -100,7 +99,6 @@ public:
+ #if QT_CONFIG(quick_draganddrop)
+     QQuickDrag *drag;
+ #endif
+-    QPointer mask;
+     QPointF startScene;
+     QPointF targetStartPos;
+     QPointF lastPos;
+-- 
+2.36.1
+
diff --git a/0004-Include-limits-in-Yarr.h-to-fix-build-with-GCC-11.patch b/0004-Include-limits-in-Yarr.h-to-fix-build-with-GCC-11.patch
new file mode 100644
index 0000000000000000000000000000000000000000..f48159287058069f0596da5891e43f1f391637d0
--- /dev/null
+++ b/0004-Include-limits-in-Yarr.h-to-fix-build-with-GCC-11.patch
@@ -0,0 +1,43 @@
+From 814f570d51323630ff84038ca04b5c02639e0ee5 Mon Sep 17 00:00:00 2001
+From: Dmitry Shachnev 
+Date: Wed, 18 Aug 2021 22:50:29 +0300
+Subject: [PATCH 04/19] Include  in Yarr.h to fix build with GCC 11
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+-  (aka ) is needed for UINT_MAX macro constant.
+-  is needed for std::numeric_limits.
+
+Without this fix, qtdeclarative failed to build on some platforms:
+
+ In file included from jsruntime/qv4regexp_p.h:62,
+                  from jsruntime/qv4regexp.cpp:40:
+ ../3rdparty/masm/yarr/Yarr.h:46:44: error: ‘numeric_limits’ is not a member of ‘std’
+    46 | static const unsigned offsetNoMatch = std::numeric_limits::max();
+       |                                            ^~~~~~~~~~~~~~
+
+Pick-to: 5.15 6.2
+Change-Id: I7cc9f7bc6624a52c8659f09034ab16064da5fd2f
+Reviewed-by: Albert Astals Cid 
+Reviewed-by: Ulf Hermann 
+(cherry picked from commit db58b8518e157b765bf2e01e6382a9eed4751f27)
+---
+ src/3rdparty/masm/yarr/Yarr.h | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/src/3rdparty/masm/yarr/Yarr.h b/src/3rdparty/masm/yarr/Yarr.h
+index ccf78f9880..2955ea7e72 100644
+--- a/src/3rdparty/masm/yarr/Yarr.h
++++ b/src/3rdparty/masm/yarr/Yarr.h
+@@ -28,6 +28,7 @@
+ #pragma once
+ 
+ #include 
++#include 
+ #include "YarrErrorCode.h"
+ 
+ namespace JSC { namespace Yarr {
+-- 
+2.36.1
+
diff --git a/0005-QQuickLoader-Do-not-incubate-if-the-source-arrives-a.patch b/0005-QQuickLoader-Do-not-incubate-if-the-source-arrives-a.patch
new file mode 100644
index 0000000000000000000000000000000000000000..fcfffd824d41a57bb8b6acc05c6e605a2a305590
--- /dev/null
+++ b/0005-QQuickLoader-Do-not-incubate-if-the-source-arrives-a.patch
@@ -0,0 +1,112 @@
+From adf0f345f6fb823679e1c6424d106fd1413c1edc Mon Sep 17 00:00:00 2001
+From: Aleix Pol 
+Date: Tue, 21 Sep 2021 00:10:26 +0200
+Subject: [PATCH 05/19] QQuickLoader: Do not incubate if the source arrives
+ after setActive(false)
+
+Otherwise we end up in the crazy place of active being false but item
+being non-null and forces us to workaround within the apps.
+
+Change-Id: I88c27c4b00ccec8b8e0c05a8e10b44fcabfc2e30
+Reviewed-by: Ulf Hermann 
+(cherry picked from commit e78c068700fa74ab3aca6a23ab2450563b1c3a5c)
+Reviewed-by: Qt Cherry-pick Bot 
+---
+ src/quick/items/qquickloader.cpp              |  3 +++
+ .../data/loader-async-race-rect.qml           | 10 ++++++++++
+ .../qquickloader/data/loader-async-race.qml   | 14 ++++++++++++++
+ .../quick/qquickloader/tst_qquickloader.cpp   | 19 +++++++++++++++++++
+ 4 files changed, 46 insertions(+)
+ create mode 100644 tests/auto/quick/qquickloader/data/loader-async-race-rect.qml
+ create mode 100644 tests/auto/quick/qquickloader/data/loader-async-race.qml
+
+diff --git a/src/quick/items/qquickloader.cpp b/src/quick/items/qquickloader.cpp
+index cb4f79a3c2..7fbe66fdda 100644
+--- a/src/quick/items/qquickloader.cpp
++++ b/src/quick/items/qquickloader.cpp
+@@ -737,6 +737,9 @@ void QQuickLoaderPrivate::_q_sourceLoaded()
+         return;
+     }
+ 
++    if (!active)
++        return;
++
+     QQmlContext *creationContext = component->creationContext();
+     if (!creationContext) creationContext = qmlContext(q);
+     itemContext = new QQmlContext(creationContext);
+diff --git a/tests/auto/quick/qquickloader/data/loader-async-race-rect.qml b/tests/auto/quick/qquickloader/data/loader-async-race-rect.qml
+new file mode 100644
+index 0000000000..a56dcea5ad
+--- /dev/null
++++ b/tests/auto/quick/qquickloader/data/loader-async-race-rect.qml
+@@ -0,0 +1,10 @@
++import QtQuick 2.15
++
++Rectangle {
++    anchors.fill: parent
++    color: "blue"
++    Item {
++        Item {
++        }
++    }
++}
+diff --git a/tests/auto/quick/qquickloader/data/loader-async-race.qml b/tests/auto/quick/qquickloader/data/loader-async-race.qml
+new file mode 100644
+index 0000000000..8ba625c5c1
+--- /dev/null
++++ b/tests/auto/quick/qquickloader/data/loader-async-race.qml
+@@ -0,0 +1,14 @@
++import QtQuick 2.15
++
++Item {
++    id: root
++    Component.onCompleted: {
++        myloader.active = false
++    }
++    Loader {
++        id: myloader
++        anchors.fill: parent
++        asynchronous: true
++        source: "loader-async-race-rect.qml"
++    }
++}
+diff --git a/tests/auto/quick/qquickloader/tst_qquickloader.cpp b/tests/auto/quick/qquickloader/tst_qquickloader.cpp
+index 0f6c811adb..dddacbaa0b 100644
+--- a/tests/auto/quick/qquickloader/tst_qquickloader.cpp
++++ b/tests/auto/quick/qquickloader/tst_qquickloader.cpp
+@@ -132,6 +132,7 @@ private slots:
+     void statusChangeOnlyEmittedOnce();
+ 
+     void setSourceAndCheckStatus();
++    void asyncLoaderRace();
+ };
+ 
+ Q_DECLARE_METATYPE(QList)
+@@ -1496,6 +1497,24 @@ void tst_QQuickLoader::setSourceAndCheckStatus()
+     QCOMPARE(loader->status(), QQuickLoader::Null);
+ }
+ 
++void tst_QQuickLoader::asyncLoaderRace()
++{
++    QQmlApplicationEngine engine;
++    auto url = testFileUrl("loader-async-race.qml");
++    engine.load(url);
++    auto root = engine.rootObjects().at(0);
++    QVERIFY(root);
++
++    QQuickLoader *loader = root->findChild();
++    QCOMPARE(loader->active(), false);
++    QCOMPARE(loader->status(), QQuickLoader::Null);
++    QCOMPARE(loader->item(), nullptr);
++
++    QSignalSpy spy(loader, &QQuickLoader::itemChanged);
++    QVERIFY(!spy.wait(100));
++    QCOMPARE(loader->item(), nullptr);
++}
++
+ QTEST_MAIN(tst_QQuickLoader)
+ 
+ #include "tst_qquickloader.moc"
+-- 
+2.36.1
+
diff --git a/0006-QQmlDelegateModel-Refresh-the-view-when-a-column-is-.patch b/0006-QQmlDelegateModel-Refresh-the-view-when-a-column-is-.patch
new file mode 100644
index 0000000000000000000000000000000000000000..01f472b379a51604829415a9f313f269369e71d7
--- /dev/null
+++ b/0006-QQmlDelegateModel-Refresh-the-view-when-a-column-is-.patch
@@ -0,0 +1,178 @@
+From 95064bee0366ed3aa9cc823ed73fba55093ced01 Mon Sep 17 00:00:00 2001
+From: Aleix Pol 
+Date: Thu, 23 Sep 2021 03:43:04 +0200
+Subject: [PATCH 06/19] QQmlDelegateModel: Refresh the view when a column is
+ added at 0
+
+It can happen that a model reports n>0 rows but columns=0 (See
+QConcatenateTablesProxyModel). In those cases we would render glitchy
+items until the elements are marked as dirty.
+
+Change-Id: I615c9cacbb1b6f9dee3898b03476605e5ac39d0a
+Reviewed-by: Ulf Hermann 
+(cherry picked from commit ec9251efb918f37971aeefa1f687d137d037ff12)
+Reviewed-by: Qt Cherry-pick Bot 
+Signed-off-by: Aleix Pol 
+---
+ src/qmlmodels/qqmldelegatemodel.cpp           | 44 +++++++++++++++++++
+ src/qmlmodels/qqmldelegatemodel_p.h           |  3 ++
+ .../data/redrawUponColumnChange.qml           | 11 +++++
+ .../tst_qqmldelegatemodel.cpp                 | 27 ++++++++++++
+ 4 files changed, 85 insertions(+)
+ create mode 100644 tests/auto/qml/qqmldelegatemodel/data/redrawUponColumnChange.qml
+
+diff --git a/src/qmlmodels/qqmldelegatemodel.cpp b/src/qmlmodels/qqmldelegatemodel.cpp
+index 312a621029..f5d586a4c2 100644
+--- a/src/qmlmodels/qqmldelegatemodel.cpp
++++ b/src/qmlmodels/qqmldelegatemodel.cpp
+@@ -389,6 +389,12 @@ void QQmlDelegateModelPrivate::connectToAbstractItemModel()
+                       q,  QQmlDelegateModel, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
+     qmlobject_connect(aim, QAbstractItemModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+                       q,  QQmlDelegateModel, SLOT(_q_rowsAboutToBeRemoved(QModelIndex,int,int)));
++    qmlobject_connect(aim, QAbstractItemModel, SIGNAL(columnsInserted(QModelIndex,int,int)),
++                      q, QQmlDelegateModel, SLOT(_q_columnsInserted(QModelIndex,int,int)));
++    qmlobject_connect(aim, QAbstractItemModel, SIGNAL(columnsRemoved(QModelIndex,int,int)),
++                      q, QQmlDelegateModel, SLOT(_q_columnsRemoved(QModelIndex,int,int)));
++    qmlobject_connect(aim, QAbstractItemModel, SIGNAL(columnsMoved(QModelIndex,int,int,QModelIndex,int)),
++                      q, QQmlDelegateModel, SLOT(_q_columnsMoved(QModelIndex,int,int,QModelIndex,int)));
+     qmlobject_connect(aim, QAbstractItemModel, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector)),
+                       q, QQmlDelegateModel, SLOT(_q_dataChanged(QModelIndex,QModelIndex,QVector)));
+     qmlobject_connect(aim, QAbstractItemModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
+@@ -413,6 +419,12 @@ void QQmlDelegateModelPrivate::disconnectFromAbstractItemModel()
+                         q, SLOT(_q_rowsAboutToBeRemoved(QModelIndex,int,int)));
+     QObject::disconnect(aim, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                         q, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
++    QObject::disconnect(aim, SIGNAL(columnsInserted(QModelIndex,int,int)), q,
++                        SLOT(_q_columnsInserted(QModelIndex,int,int)));
++    QObject::disconnect(aim, SIGNAL(columnsRemoved(QModelIndex,int,int)), q,
++                        SLOT(_q_columnsRemoved(QModelIndex,int,int)));
++    QObject::disconnect(aim, SIGNAL(columnsMoved(QModelIndex,int,int,QModelIndex,int)), q,
++                        SLOT(_q_columnsMoved(QModelIndex,int,int,QModelIndex,int)));
+     QObject::disconnect(aim, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector)),
+                         q, SLOT(_q_dataChanged(QModelIndex,QModelIndex,QVector)));
+     QObject::disconnect(aim, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
+@@ -1960,6 +1972,38 @@ void QQmlDelegateModel::_q_rowsMoved(
+     }
+ }
+ 
++void QQmlDelegateModel::_q_columnsInserted(const QModelIndex &parent, int begin, int end)
++{
++    Q_D(QQmlDelegateModel);
++    Q_UNUSED(end);
++    if (parent == d->m_adaptorModel.rootIndex && begin == 0) {
++        // mark all items as changed
++        _q_itemsChanged(0, d->m_count, QVector());
++    }
++}
++
++void QQmlDelegateModel::_q_columnsRemoved(const QModelIndex &parent, int begin, int end)
++{
++    Q_D(QQmlDelegateModel);
++    Q_UNUSED(end);
++    if (parent == d->m_adaptorModel.rootIndex && begin == 0) {
++        // mark all items as changed
++        _q_itemsChanged(0, d->m_count, QVector());
++    }
++}
++
++void QQmlDelegateModel::_q_columnsMoved(const QModelIndex &parent, int start, int end,
++                                        const QModelIndex &destination, int column)
++{
++    Q_D(QQmlDelegateModel);
++    Q_UNUSED(end);
++    if ((parent == d->m_adaptorModel.rootIndex && start == 0)
++        || (destination == d->m_adaptorModel.rootIndex && column == 0)) {
++        // mark all items as changed
++        _q_itemsChanged(0, d->m_count, QVector());
++    }
++}
++
+ void QQmlDelegateModel::_q_dataChanged(const QModelIndex &begin, const QModelIndex &end, const QVector &roles)
+ {
+     Q_D(QQmlDelegateModel);
+diff --git a/src/qmlmodels/qqmldelegatemodel_p.h b/src/qmlmodels/qqmldelegatemodel_p.h
+index 8aab4badca..d140bfbaaf 100644
+--- a/src/qmlmodels/qqmldelegatemodel_p.h
++++ b/src/qmlmodels/qqmldelegatemodel_p.h
+@@ -152,6 +152,9 @@ private Q_SLOTS:
+     void _q_itemsMoved(int from, int to, int count);
+     void _q_modelReset();
+     void _q_rowsInserted(const QModelIndex &,int,int);
++    void _q_columnsInserted(const QModelIndex &, int, int);
++    void _q_columnsRemoved(const QModelIndex &, int, int);
++    void _q_columnsMoved(const QModelIndex &, int, int, const QModelIndex &, int);
+     void _q_rowsAboutToBeRemoved(const QModelIndex &parent, int begin, int end);
+     void _q_rowsRemoved(const QModelIndex &,int,int);
+     void _q_rowsMoved(const QModelIndex &, int, int, const QModelIndex &, int);
+diff --git a/tests/auto/qml/qqmldelegatemodel/data/redrawUponColumnChange.qml b/tests/auto/qml/qqmldelegatemodel/data/redrawUponColumnChange.qml
+new file mode 100644
+index 0000000000..206133bb39
+--- /dev/null
++++ b/tests/auto/qml/qqmldelegatemodel/data/redrawUponColumnChange.qml
+@@ -0,0 +1,11 @@
++import QtQuick 2.8
++
++ListView {
++    id: root
++    width: 200
++    height: 200
++
++    delegate: Text {
++        text: display
++    }
++}
+diff --git a/tests/auto/qml/qqmldelegatemodel/tst_qqmldelegatemodel.cpp b/tests/auto/qml/qqmldelegatemodel/tst_qqmldelegatemodel.cpp
+index 9bc359d243..120b1897a1 100644
+--- a/tests/auto/qml/qqmldelegatemodel/tst_qqmldelegatemodel.cpp
++++ b/tests/auto/qml/qqmldelegatemodel/tst_qqmldelegatemodel.cpp
+@@ -27,6 +27,8 @@
+ ****************************************************************************/
+ 
+ #include 
++#include 
++#include 
+ #include 
+ #include 
+ #include 
+@@ -46,6 +48,7 @@ private slots:
+     void valueWithoutCallingObjectFirst();
+     void filterOnGroup_removeWhenCompleted();
+     void qtbug_86017();
++    void redrawUponColumnChange();
+ };
+ 
+ class AbstractItemModel : public QAbstractItemModel
+@@ -164,6 +167,30 @@ void tst_QQmlDelegateModel::qtbug_86017()
+     QCOMPARE(model->filterGroup(), "selected");
+ }
+ 
++void tst_QQmlDelegateModel::redrawUponColumnChange()
++{
++    QStandardItemModel m1;
++    m1.appendRow({
++            new QStandardItem("Banana"),
++            new QStandardItem("Coconut"),
++    });
++
++    QQuickView view(testFileUrl("redrawUponColumnChange.qml"));
++    QCOMPARE(view.status(), QQuickView::Ready);
++    view.show();
++    QQuickItem *root = view.rootObject();
++    root->setProperty("model", QVariant::fromValue(&m1));
++
++    QObject *item = root->property("currentItem").value();
++    QVERIFY(item);
++    QCOMPARE(item->property("text").toString(), "Banana");
++
++    QVERIFY(root);
++    m1.removeColumn(0);
++
++    QCOMPARE(item->property("text").toString(), "Coconut");
++}
++
+ QTEST_MAIN(tst_QQmlDelegateModel)
+ 
+ #include "tst_qqmldelegatemodel.moc"
+-- 
+2.36.1
+
diff --git a/0007-Fix-sweep-step-for-tainted-QObject-JavaScript-wrappe.patch b/0007-Fix-sweep-step-for-tainted-QObject-JavaScript-wrappe.patch
new file mode 100644
index 0000000000000000000000000000000000000000..559d5e8ffe734967dad15ba9e80d7d87f68202d1
--- /dev/null
+++ b/0007-Fix-sweep-step-for-tainted-QObject-JavaScript-wrappe.patch
@@ -0,0 +1,119 @@
+From c580a46359307b03bb3e8d5a3ce844fcd167d92d Mon Sep 17 00:00:00 2001
+From: Vlad Zahorodnii 
+Date: Sun, 10 Oct 2021 21:04:21 +0300
+Subject: [PATCH 07/19] Fix sweep step for tainted QObject JavaScript wrappers
+
+Currently, whenever the garbage collector runs, it will destroy all
+valid tainted wrappers.
+
+Only null or undefined wrappers will be preserved in the
+m_multiplyWrappedQObjects map.
+
+It seems like "!" was overlooked in
+3b5d37ce3841c4bfdf1c629d33f0e33b881b47fb. Prior to that change, it
+was "!it.value()->markBit()", so calling erase() in the then branch
+did make sense. But with "!it.value().isNullOrUndefined()", erase()
+will be called for every valid wrapper, which is the opposite what we
+want.
+
+Pick-to: 5.15 6.2
+Change-Id: I2bf2630f538af8cbd4bfffcff29d67be6c278265
+Reviewed-by: Fabian Kosmale 
+(cherry picked from commit e6b2f88d892dcf396580a61662f569bf69d6d9d1)
+---
+ src/qml/memory/qv4mm.cpp                   |  2 +-
+ tests/auto/qml/qjsengine/tst_qjsengine.cpp | 39 ++++++++++++++++++++++
+ tests/auto/qml/qv4mm/tst_qv4mm.cpp         |  6 ++--
+ 3 files changed, 43 insertions(+), 4 deletions(-)
+
+diff --git a/src/qml/memory/qv4mm.cpp b/src/qml/memory/qv4mm.cpp
+index 06caf04e5a..da149a67c4 100644
+--- a/src/qml/memory/qv4mm.cpp
++++ b/src/qml/memory/qv4mm.cpp
+@@ -981,7 +981,7 @@ void MemoryManager::sweep(bool lastSweep, ClassDestroyStatsCallback classCountPt
+ 
+     if (MultiplyWrappedQObjectMap *multiplyWrappedQObjects = engine->m_multiplyWrappedQObjects) {
+         for (MultiplyWrappedQObjectMap::Iterator it = multiplyWrappedQObjects->begin(); it != multiplyWrappedQObjects->end();) {
+-            if (!it.value().isNullOrUndefined())
++            if (it.value().isNullOrUndefined())
+                 it = multiplyWrappedQObjects->erase(it);
+             else
+                 ++it;
+diff --git a/tests/auto/qml/qjsengine/tst_qjsengine.cpp b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
+index 3b7d74df63..b75bf820d5 100644
+--- a/tests/auto/qml/qjsengine/tst_qjsengine.cpp
++++ b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
+@@ -102,6 +102,7 @@ private slots:
+     void valueConversion_RegularExpression();
+     void castWithMultipleInheritance();
+     void collectGarbage();
++    void collectGarbageNestedWrappersTwoEngines();
+     void gcWithNestedDataStructure();
+     void stacktrace();
+     void numberParsing_data();
+@@ -1809,6 +1810,44 @@ void tst_QJSEngine::collectGarbage()
+     QVERIFY(ptr.isNull());
+ }
+ 
++class TestObjectContainer : public QObject
++{
++    Q_OBJECT
++    Q_PROPERTY(QObject *dummy MEMBER m_dummy CONSTANT)
++
++public:
++    TestObjectContainer() : m_dummy(new QObject(this)) {}
++
++private:
++    QObject *m_dummy;
++};
++
++void tst_QJSEngine::collectGarbageNestedWrappersTwoEngines()
++{
++    QJSEngine engine1;
++    QJSEngine engine2;
++
++    TestObjectContainer container;
++    QQmlEngine::setObjectOwnership(&container, QQmlEngine::CppOwnership);
++
++    engine1.globalObject().setProperty("foobar", engine1.newQObject(&container));
++    engine2.globalObject().setProperty("foobar", engine2.newQObject(&container));
++
++    engine1.evaluate("foobar.dummy.baz = 42");
++    engine2.evaluate("foobar.dummy.baz = 43");
++
++    QCOMPARE(engine1.evaluate("foobar.dummy.baz").toInt(), 42);
++    QCOMPARE(engine2.evaluate("foobar.dummy.baz").toInt(), 43);
++
++    engine1.collectGarbage();
++    engine2.collectGarbage();
++
++    // The GC should not collect dummy object wrappers neither in engine1 nor engine2, we
++    // verify that by checking whether the baz property still has its previous value.
++    QCOMPARE(engine1.evaluate("foobar.dummy.baz").toInt(), 42);
++    QCOMPARE(engine2.evaluate("foobar.dummy.baz").toInt(), 43);
++}
++
+ void tst_QJSEngine::gcWithNestedDataStructure()
+ {
+     // The GC must be able to traverse deeply nested objects, otherwise this
+diff --git a/tests/auto/qml/qv4mm/tst_qv4mm.cpp b/tests/auto/qml/qv4mm/tst_qv4mm.cpp
+index 5d635aa63b..824fd89e5b 100644
+--- a/tests/auto/qml/qv4mm/tst_qv4mm.cpp
++++ b/tests/auto/qml/qv4mm/tst_qv4mm.cpp
+@@ -76,10 +76,10 @@ void tst_qv4mm::multiWrappedQObjects()
+         QCOMPARE(engine1.memoryManager->m_pendingFreedObjectWrapperValue.size(), 1);
+         QCOMPARE(engine2.memoryManager->m_pendingFreedObjectWrapperValue.size(), 0);
+ 
+-        // Moves the additional WeakValue from m_multiplyWrappedQObjects to
+-        // m_pendingFreedObjectWrapperValue. It's still alive after all.
++        // The additional WeakValue from m_multiplyWrappedQObjects hasn't been moved
++        // to m_pendingFreedObjectWrapperValue yet. It's still alive after all.
+         engine1.memoryManager->runGC();
+-        QCOMPARE(engine1.memoryManager->m_pendingFreedObjectWrapperValue.size(), 2);
++        QCOMPARE(engine1.memoryManager->m_pendingFreedObjectWrapperValue.size(), 1);
+ 
+         // engine2 doesn't own the object as engine1 was the first to wrap it above.
+         // Therefore, no effect here.
+-- 
+2.36.1
+
diff --git a/0008-Fix-distorted-text-with-subpixel-matrix-translation.patch b/0008-Fix-distorted-text-with-subpixel-matrix-translation.patch
new file mode 100644
index 0000000000000000000000000000000000000000..4146a45bbe041fa69436c678a2865c57f451d47b
--- /dev/null
+++ b/0008-Fix-distorted-text-with-subpixel-matrix-translation.patch
@@ -0,0 +1,483 @@
+From 74db4a874a39b189d000d0b8507fccfbacf83294 Mon Sep 17 00:00:00 2001
+From: Eskil Abrahamsen Blomfeldt 
+Date: Tue, 12 Oct 2021 13:13:01 +0200
+Subject: [PATCH 08/19] Fix distorted text with subpixel matrix translation
+
+We would pixel-align native text *before* applying the
+model-view matrix, which would cause GL_NEAREST artifacts to
+show up when the text was positioned at a subpixel offset in
+some cases. Instead, we pixel-align the coordinates after mapping
+them to the view frustum, but before applying the projection to the
+screen.
+
+To make it easier to modify the buffer layout for the shaders the
+next time, this also adds some constants for offsets.
+
+[ChangeLog][Text] Fixed an issue where text using NativeRendering
+would look slightly skewed if it was inside a parent that had
+been positioned at a subpixel offset.
+
+Pick-to: 5.15 6.2
+Fixes: QTBUG-96112
+Fixes: QTBUG-83626
+Task-number: QTBUG-55638
+Change-Id: Ifb785ad5830093df94afc75a7bc288e24ca7aa38
+Reviewed-by: Eirik Aavitsland 
+(cherry picked from commit b21948f5e811ce1b7abf065bc48af61a231e86f4)
+---
+ .../scenegraph/qsgdefaultglyphnode_p.cpp      | 46 ++++++----
+ .../scenegraph/shaders_ng/24bittextmask.frag  |  5 +-
+ .../scenegraph/shaders_ng/32bitcolortext.frag |  5 +-
+ .../scenegraph/shaders_ng/8bittextmask.frag   |  3 +-
+ .../scenegraph/shaders_ng/8bittextmask_a.frag |  3 +-
+ .../scenegraph/shaders_ng/outlinedtext.frag   |  5 +-
+ .../scenegraph/shaders_ng/outlinedtext.vert   |  9 +-
+ .../scenegraph/shaders_ng/outlinedtext_a.frag |  5 +-
+ .../scenegraph/shaders_ng/styledtext.frag     |  3 +-
+ .../scenegraph/shaders_ng/styledtext.vert     |  7 +-
+ .../scenegraph/shaders_ng/styledtext_a.frag   |  3 +-
+ src/quick/scenegraph/shaders_ng/textmask.frag |  3 +-
+ src/quick/scenegraph/shaders_ng/textmask.vert |  7 +-
+ ...text_nativerendering_subpixelpositions.qml | 91 +++++++++++++++++++
+ 14 files changed, 155 insertions(+), 40 deletions(-)
+ create mode 100644 tests/manual/scenegraph_lancelot/data/text/text_nativerendering_subpixelpositions.qml
+
+diff --git a/src/quick/scenegraph/qsgdefaultglyphnode_p.cpp b/src/quick/scenegraph/qsgdefaultglyphnode_p.cpp
+index 3c60f830de..0fd6581dc4 100644
+--- a/src/quick/scenegraph/qsgdefaultglyphnode_p.cpp
++++ b/src/quick/scenegraph/qsgdefaultglyphnode_p.cpp
+@@ -428,6 +428,18 @@ QSGTextMaskRhiShader::QSGTextMaskRhiShader(QFontEngine::GlyphFormat glyphFormat)
+                       QStringLiteral(":/qt-project.org/scenegraph/shaders_ng/textmask.frag.qsb"));
+ }
+ 
++enum UbufOffset {
++    ModelViewMatrixOffset = 0,
++    ProjectionMatrixOffset = ModelViewMatrixOffset + 64,
++    ColorOffset = ProjectionMatrixOffset + 64,
++    TextureScaleOffset = ColorOffset + 16,
++    DprOffset = TextureScaleOffset + 8,
++
++    // + 1 float padding (vec4 must be aligned to 16)
++    StyleColorOffset = DprOffset + 4 + 4,
++    ShiftOffset = StyleColorOffset + 16
++};
++
+ bool QSGTextMaskRhiShader::updateUniformData(RenderState &state,
+                                              QSGMaterial *newMaterial, QSGMaterial *oldMaterial)
+ {
+@@ -443,11 +455,14 @@ bool QSGTextMaskRhiShader::updateUniformData(RenderState &state,
+ 
+     bool changed = false;
+     QByteArray *buf = state.uniformData();
+-    Q_ASSERT(buf->size() >= 92);
++    Q_ASSERT(buf->size() >= DprOffset + 4);
+ 
+     if (state.isMatrixDirty()) {
+-        const QMatrix4x4 m = state.combinedMatrix();
+-        memcpy(buf->data(), m.constData(), 64);
++        const QMatrix4x4 mv = state.modelViewMatrix();
++        memcpy(buf->data() + ModelViewMatrixOffset, mv.constData(), 64);
++        const QMatrix4x4 p = state.projectionMatrix();
++        memcpy(buf->data() + ProjectionMatrixOffset, p.constData(), 64);
++
+         changed = true;
+     }
+ 
+@@ -456,13 +471,13 @@ bool QSGTextMaskRhiShader::updateUniformData(RenderState &state,
+     if (updated || !oldMat || oldRtex != newRtex) {
+         const QVector2D textureScale = QVector2D(1.0f / mat->rhiGlyphCache()->width(),
+                                                  1.0f / mat->rhiGlyphCache()->height());
+-        memcpy(buf->data() + 64 + 16, &textureScale, 8);
++        memcpy(buf->data() + TextureScaleOffset, &textureScale, 8);
+         changed = true;
+     }
+ 
+     if (!oldMat) {
+         float dpr = state.devicePixelRatio();
+-        memcpy(buf->data() + 64 + 16 + 8, &dpr, 4);
++        memcpy(buf->data() + DprOffset, &dpr, 4);
+     }
+ 
+     // move texture uploads/copies onto the renderer's soon-to-be-committed list
+@@ -510,11 +525,11 @@ bool QSG8BitTextMaskRhiShader::updateUniformData(RenderState &state,
+     QSGTextMaskMaterial *oldMat = static_cast(oldMaterial);
+ 
+     QByteArray *buf = state.uniformData();
+-    Q_ASSERT(buf->size() >= 80);
++    Q_ASSERT(buf->size() >= ColorOffset + 16);
+ 
+     if (oldMat == nullptr || mat->color() != oldMat->color() || state.isOpacityDirty()) {
+         const QVector4D color = qsg_premultiply(mat->color(), state.opacity());
+-        memcpy(buf->data() + 64, &color, 16);
++        memcpy(buf->data() + ColorOffset, &color, 16);
+         changed = true;
+     }
+ 
+@@ -553,12 +568,12 @@ bool QSG24BitTextMaskRhiShader::updateUniformData(RenderState &state,
+     QSGTextMaskMaterial *oldMat = static_cast(oldMaterial);
+ 
+     QByteArray *buf = state.uniformData();
+-    Q_ASSERT(buf->size() >= 92);
++    Q_ASSERT(buf->size() >= ColorOffset + 16);
+ 
+     if (oldMat == nullptr || mat->color() != oldMat->color() || state.isOpacityDirty()) {
+         // shader takes vec4 but uses alpha only; coloring happens via the blend constant
+         const QVector4D color = qsg_premultiply(mat->color(), state.opacity());
+-        memcpy(buf->data() + 64, &color, 16);
++        memcpy(buf->data() + ColorOffset, &color, 16);
+         changed = true;
+     }
+ 
+@@ -608,12 +623,12 @@ bool QSG32BitColorTextRhiShader::updateUniformData(RenderState &state,
+     QSGTextMaskMaterial *oldMat = static_cast(oldMaterial);
+ 
+     QByteArray *buf = state.uniformData();
+-    Q_ASSERT(buf->size() >= 92);
++    Q_ASSERT(buf->size() >= ColorOffset + 16);
+ 
+     if (oldMat == nullptr || mat->color() != oldMat->color() || state.isOpacityDirty()) {
+         // shader takes vec4 but uses alpha only
+         const QVector4D color(0, 0, 0, mat->color().w() * state.opacity());
+-        memcpy(buf->data() + 64, &color, 16);
++        memcpy(buf->data() + ColorOffset, &color, 16);
+         changed = true;
+     }
+ 
+@@ -649,20 +664,17 @@ bool QSGStyledTextRhiShader::updateUniformData(RenderState &state,
+     QSGStyledTextMaterial *oldMat = static_cast(oldMaterial);
+ 
+     QByteArray *buf = state.uniformData();
+-    Q_ASSERT(buf->size() >= 120);
+-
+-    // matrix..dpr + 1 float padding (vec4 must be aligned to 16)
+-    const int startOffset = 64 + 16 + 8 + 4 + 4;
++    Q_ASSERT(buf->size() >= ShiftOffset + 8);
+ 
+     if (oldMat == nullptr || mat->styleColor() != oldMat->styleColor() || state.isOpacityDirty()) {
+         const QVector4D styleColor = qsg_premultiply(mat->styleColor(), state.opacity());
+-        memcpy(buf->data() + startOffset, &styleColor, 16);
++        memcpy(buf->data() + StyleColorOffset, &styleColor, 16);
+         changed = true;
+     }
+ 
+     if (oldMat == nullptr || oldMat->styleShift() != mat->styleShift()) {
+         const QVector2D v = mat->styleShift();
+-        memcpy(buf->data() + startOffset + 16, &v, 8);
++        memcpy(buf->data() + ShiftOffset, &v, 8);
+         changed = true;
+     }
+ 
+diff --git a/src/quick/scenegraph/shaders_ng/24bittextmask.frag b/src/quick/scenegraph/shaders_ng/24bittextmask.frag
+index bc3826a924..ed8da4cd30 100644
+--- a/src/quick/scenegraph/shaders_ng/24bittextmask.frag
++++ b/src/quick/scenegraph/shaders_ng/24bittextmask.frag
+@@ -6,8 +6,9 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
+-    vec4 color; // only alpha is used, but must be vec4 due to layout compat
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
++    vec4 color;
+     vec2 textureScale;
+     float dpr;
+ } ubuf;
+diff --git a/src/quick/scenegraph/shaders_ng/32bitcolortext.frag b/src/quick/scenegraph/shaders_ng/32bitcolortext.frag
+index 63e445f90b..4198a4d339 100644
+--- a/src/quick/scenegraph/shaders_ng/32bitcolortext.frag
++++ b/src/quick/scenegraph/shaders_ng/32bitcolortext.frag
+@@ -6,8 +6,9 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
+-    vec4 color; // only alpha is used, but must be vec4 due to layout compat
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
++    vec4 color;
+     vec2 textureScale;
+     float dpr;
+ } ubuf;
+diff --git a/src/quick/scenegraph/shaders_ng/8bittextmask.frag b/src/quick/scenegraph/shaders_ng/8bittextmask.frag
+index 6304e821ff..a06743876d 100644
+--- a/src/quick/scenegraph/shaders_ng/8bittextmask.frag
++++ b/src/quick/scenegraph/shaders_ng/8bittextmask.frag
+@@ -6,7 +6,8 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+diff --git a/src/quick/scenegraph/shaders_ng/8bittextmask_a.frag b/src/quick/scenegraph/shaders_ng/8bittextmask_a.frag
+index 0d0fa1cd3a..f725cbc5e7 100644
+--- a/src/quick/scenegraph/shaders_ng/8bittextmask_a.frag
++++ b/src/quick/scenegraph/shaders_ng/8bittextmask_a.frag
+@@ -6,7 +6,8 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+diff --git a/src/quick/scenegraph/shaders_ng/outlinedtext.frag b/src/quick/scenegraph/shaders_ng/outlinedtext.frag
+index 947d161a50..e2f82d3845 100644
+--- a/src/quick/scenegraph/shaders_ng/outlinedtext.frag
++++ b/src/quick/scenegraph/shaders_ng/outlinedtext.frag
+@@ -11,11 +11,12 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    // must match styledtext
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
++    // the above must stay compatible with textmask/8bittextmask
+     vec4 styleColor;
+     vec2 shift;
+ } ubuf;
+diff --git a/src/quick/scenegraph/shaders_ng/outlinedtext.vert b/src/quick/scenegraph/shaders_ng/outlinedtext.vert
+index 023f9dfdc2..4068e42f28 100644
+--- a/src/quick/scenegraph/shaders_ng/outlinedtext.vert
++++ b/src/quick/scenegraph/shaders_ng/outlinedtext.vert
+@@ -10,11 +10,12 @@ layout(location = 3) out vec2 sCoordLeft;
+ layout(location = 4) out vec2 sCoordRight;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    // must match styledtext
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
++    // the above must stay compatible with textmask/8bittextmask
+     vec4 styleColor;
+     vec2 shift;
+ } ubuf;
+@@ -28,6 +29,6 @@ void main()
+      sCoordDown = (tCoord - vec2(0.0, 1.0)) * ubuf.textureScale;
+      sCoordLeft = (tCoord - vec2(-1.0, 0.0)) * ubuf.textureScale;
+      sCoordRight = (tCoord - vec2(1.0, 0.0)) * ubuf.textureScale;
+-     vec3 dprSnapPos = floor(vCoord.xyz * ubuf.dpr + 0.5) / ubuf.dpr;
+-     gl_Position = ubuf.matrix * vec4(dprSnapPos, vCoord.w);
++     vec4 xformed = ubuf.modelViewMatrix * vCoord;
++     gl_Position = ubuf.projectionMatrix * vec4(floor(xformed.xyz * ubuf.dpr + 0.5) / ubuf.dpr, xformed.w);
+ }
+diff --git a/src/quick/scenegraph/shaders_ng/outlinedtext_a.frag b/src/quick/scenegraph/shaders_ng/outlinedtext_a.frag
+index 5b7bd9ca82..274d891a3c 100644
+--- a/src/quick/scenegraph/shaders_ng/outlinedtext_a.frag
++++ b/src/quick/scenegraph/shaders_ng/outlinedtext_a.frag
+@@ -11,11 +11,12 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    // must match styledtext
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
++    // the above must stay compatible with textmask/8bittextmask
+     vec4 styleColor;
+     vec2 shift;
+ } ubuf;
+diff --git a/src/quick/scenegraph/shaders_ng/styledtext.frag b/src/quick/scenegraph/shaders_ng/styledtext.frag
+index 0b16396037..2e380dfeae 100644
+--- a/src/quick/scenegraph/shaders_ng/styledtext.frag
++++ b/src/quick/scenegraph/shaders_ng/styledtext.frag
+@@ -8,7 +8,8 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+diff --git a/src/quick/scenegraph/shaders_ng/styledtext.vert b/src/quick/scenegraph/shaders_ng/styledtext.vert
+index beadf07c79..271dae8d8a 100644
+--- a/src/quick/scenegraph/shaders_ng/styledtext.vert
++++ b/src/quick/scenegraph/shaders_ng/styledtext.vert
+@@ -7,7 +7,8 @@ layout(location = 0) out vec2 sampleCoord;
+ layout(location = 1) out vec2 shiftedSampleCoord;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+@@ -22,6 +23,6 @@ void main()
+ {
+      sampleCoord = tCoord * ubuf.textureScale;
+      shiftedSampleCoord = (tCoord - ubuf.shift) * ubuf.textureScale;
+-     vec3 dprSnapPos = floor(vCoord.xyz * ubuf.dpr + 0.5) / ubuf.dpr;
+-     gl_Position = ubuf.matrix * vec4(dprSnapPos, vCoord.w);
++     vec4 xformed = ubuf.modelViewMatrix * vCoord;
++     gl_Position = ubuf.projectionMatrix * vec4(floor(xformed.xyz * ubuf.dpr + 0.5) / ubuf.dpr, xformed.w);
+ }
+diff --git a/src/quick/scenegraph/shaders_ng/styledtext_a.frag b/src/quick/scenegraph/shaders_ng/styledtext_a.frag
+index b673137895..62e162c851 100644
+--- a/src/quick/scenegraph/shaders_ng/styledtext_a.frag
++++ b/src/quick/scenegraph/shaders_ng/styledtext_a.frag
+@@ -8,7 +8,8 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+diff --git a/src/quick/scenegraph/shaders_ng/textmask.frag b/src/quick/scenegraph/shaders_ng/textmask.frag
+index 518d5c965f..ed8da4cd30 100644
+--- a/src/quick/scenegraph/shaders_ng/textmask.frag
++++ b/src/quick/scenegraph/shaders_ng/textmask.frag
+@@ -6,7 +6,8 @@ layout(location = 0) out vec4 fragColor;
+ layout(binding = 1) uniform sampler2D _qt_texture;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+diff --git a/src/quick/scenegraph/shaders_ng/textmask.vert b/src/quick/scenegraph/shaders_ng/textmask.vert
+index 9d80d5dadb..e0b3c01bce 100644
+--- a/src/quick/scenegraph/shaders_ng/textmask.vert
++++ b/src/quick/scenegraph/shaders_ng/textmask.vert
+@@ -6,7 +6,8 @@ layout(location = 1) in vec2 tCoord;
+ layout(location = 0) out vec2 sampleCoord;
+ 
+ layout(std140, binding = 0) uniform buf {
+-    mat4 matrix;
++    mat4 modelViewMatrix;
++    mat4 projectionMatrix;
+     vec4 color;
+     vec2 textureScale;
+     float dpr;
+@@ -17,6 +18,6 @@ out gl_PerVertex { vec4 gl_Position; };
+ void main()
+ {
+      sampleCoord = tCoord * ubuf.textureScale;
+-     vec3 dprSnapPos = floor(vCoord.xyz * ubuf.dpr + 0.5) / ubuf.dpr;
+-     gl_Position = ubuf.matrix * vec4(dprSnapPos, vCoord.w);
++     vec4 xformed = ubuf.modelViewMatrix * vCoord;
++     gl_Position = ubuf.projectionMatrix * vec4(floor(xformed.xyz * ubuf.dpr + 0.5) / ubuf.dpr, xformed.w);
+ }
+diff --git a/tests/manual/scenegraph_lancelot/data/text/text_nativerendering_subpixelpositions.qml b/tests/manual/scenegraph_lancelot/data/text/text_nativerendering_subpixelpositions.qml
+new file mode 100644
+index 0000000000..c60fc4d8b0
+--- /dev/null
++++ b/tests/manual/scenegraph_lancelot/data/text/text_nativerendering_subpixelpositions.qml
+@@ -0,0 +1,91 @@
++import QtQuick 2.0
++
++//vary font style, native rendering at non-integer offsets
++
++Item {
++    id: topLevel
++    width: 320
++    height: 580
++
++    Repeater {
++        model: [Text.Normal, Text.Outline, Text.Raised, Text.Sunken]
++        Text {
++            y: 20 * index
++            clip: true
++            renderType: Text.NativeRendering
++            width: parent.width
++            wrapMode: Text.Wrap
++            font.pointSize: 10
++            style: modelData
++            styleColor: "green"
++            text: "The quick fox jumps in style " + modelData
++        }
++    }
++
++    Repeater {
++        model: [Text.Normal, Text.Outline, Text.Raised, Text.Sunken]
++        Text {
++            y: 100.5 + 20 * index
++            clip: true
++            renderType: Text.NativeRendering
++            width: parent.width
++            wrapMode: Text.Wrap
++            font.pointSize: 10
++            style: modelData
++            styleColor: "green"
++            text: "The quick fox jumps in style " + modelData
++        }
++    }
++
++    Repeater {
++        model: [Text.Normal, Text.Outline, Text.Raised, Text.Sunken]
++        Text {
++            y: 200.5 + 20 * index
++            x: 0.5
++            clip: true
++            renderType: Text.NativeRendering
++            width: parent.width
++            wrapMode: Text.Wrap
++            font.pointSize: 10
++            style: modelData
++            styleColor: "green"
++            text: "The quick fox jumps in style " + modelData
++        }
++    }
++
++    Repeater {
++        model: [Text.Normal, Text.Outline, Text.Raised, Text.Sunken]
++        Text {
++            y: 300.5 + 20 * index
++            x: 0.5
++            clip: true
++            renderType: Text.NativeRendering
++            width: parent.width
++            wrapMode: Text.Wrap
++            font.pointSize: 10
++            style: modelData
++            styleColor: "green"
++            text: "The quick fox jumps in style " + modelData
++        }
++    }
++
++    Repeater {
++        model: [Text.Normal, Text.Outline, Text.Raised, Text.Sunken]
++        Rectangle {
++            y: 400.5 + 20 * index
++            x: 0.5
++            width: topLevel.width
++            height: topLevel.height
++            clip: true
++            Text {
++                renderType: Text.NativeRendering
++                width: parent.width
++                wrapMode: Text.Wrap
++                font.pointSize: 10
++                style: modelData
++                styleColor: "green"
++                text: "The quick fox jumps in style " + modelData
++            }
++        }
++    }
++}
+-- 
+2.36.1
+
diff --git a/0009-Revert-Fix-for-possible-crash-in-QSGDefaultLayer-gra.patch b/0009-Revert-Fix-for-possible-crash-in-QSGDefaultLayer-gra.patch
new file mode 100644
index 0000000000000000000000000000000000000000..8b1eecb299fcb689da135b81a678c5cf6c5c891c
--- /dev/null
+++ b/0009-Revert-Fix-for-possible-crash-in-QSGDefaultLayer-gra.patch
@@ -0,0 +1,71 @@
+From b92f401a758890d26ef0d00d15c33af5c81f9038 Mon Sep 17 00:00:00 2001
+From: Laszlo Agocs 
+Date: Mon, 11 Oct 2021 15:37:33 +0200
+Subject: [PATCH 09/19] Revert "Fix for possible crash in
+ QSGDefaultLayer::grab"
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+This reverts commit 1c5de027d0c31d1d6697bd0557128d92207763d8.
+
+The fix here is not correct. Calling a QSGRhiLayer function from the gui
+thread is very wrong and can cause a set of unexpected issues. The
+Address Sanitizer catches this by recognizing that the render thread is
+trying to do something with an object destroyed in the meantime on the
+main thread in the layer->setItem(null) call.
+
+The issue the original fix is trying to address needs to be addressed in
+some different form.
+
+Fixes: QTBUG-94975
+Pick-to: 6.2 6.1 5.15
+Change-Id: I46f904026281201fc6d233ed7d3bdc7080934afe
+Reviewed-by: Christian Strømme 
+(cherry picked from commit a5f0361622eb08eab6c3474d5fc249d1962e3d1e)
+---
+ src/quick/items/qquickshadereffectsource.cpp | 8 --------
+ src/quick/items/qquickshadereffectsource_p.h | 1 -
+ 2 files changed, 9 deletions(-)
+
+diff --git a/src/quick/items/qquickshadereffectsource.cpp b/src/quick/items/qquickshadereffectsource.cpp
+index 4f61d61309..b298ed74da 100644
+--- a/src/quick/items/qquickshadereffectsource.cpp
++++ b/src/quick/items/qquickshadereffectsource.cpp
+@@ -344,7 +344,6 @@ void QQuickShaderEffectSource::setSourceItem(QQuickItem *item)
+             d->refFromEffectItem(m_hideSource);
+             d->addItemChangeListener(this, QQuickItemPrivate::Geometry);
+             connect(m_sourceItem, SIGNAL(destroyed(QObject*)), this, SLOT(sourceItemDestroyed(QObject*)));
+-            connect(m_sourceItem, SIGNAL(parentChanged(QQuickItem*)), this, SLOT(sourceItemParentChanged(QQuickItem*)));
+         } else {
+             qWarning("ShaderEffectSource: sourceItem and ShaderEffectSource must both be children of the same window.");
+             m_sourceItem = nullptr;
+@@ -364,13 +363,6 @@ void QQuickShaderEffectSource::sourceItemDestroyed(QObject *item)
+ }
+ 
+ 
+-void QQuickShaderEffectSource::sourceItemParentChanged(QQuickItem *parent)
+-{
+-    if (!parent && m_texture)
+-        m_texture->setItem(0);
+-}
+-
+-
+ /*!
+     \qmlproperty rect QtQuick::ShaderEffectSource::sourceRect
+ 
+diff --git a/src/quick/items/qquickshadereffectsource_p.h b/src/quick/items/qquickshadereffectsource_p.h
+index 4deb6c70a3..c0a1ccab78 100644
+--- a/src/quick/items/qquickshadereffectsource_p.h
++++ b/src/quick/items/qquickshadereffectsource_p.h
+@@ -173,7 +173,6 @@ Q_SIGNALS:
+ private Q_SLOTS:
+     void sourceItemDestroyed(QObject *item);
+     void invalidateSceneGraph();
+-    void sourceItemParentChanged(QQuickItem *parent);
+ 
+ protected:
+     void releaseResources() override;
+-- 
+2.36.1
+
diff --git a/0010-Fix-TapHandler-so-that-it-actually-registers-a-tap.patch b/0010-Fix-TapHandler-so-that-it-actually-registers-a-tap.patch
new file mode 100644
index 0000000000000000000000000000000000000000..c8f6cde6b07c73302778e1799035fdc12bdb8b8d
--- /dev/null
+++ b/0010-Fix-TapHandler-so-that-it-actually-registers-a-tap.patch
@@ -0,0 +1,73 @@
+From 695e1217f2e568feb3ddec91b2cf70df251964e5 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Jan=20Arve=20S=C3=A6ther?= 
+Date: Thu, 3 Sep 2020 10:51:01 +0200
+Subject: [PATCH 10/19] Fix TapHandler so that it actually registers a tap
+
+This bug caused all quick examples that used the
+shared\LauncherList.qml to be broken.
+
+In QtGui, QSinglePointEvent will construct itself with a point id of 0
+if there is a valid point, and with a point id of -1 if the point is
+invalid (the default constructor does the latter).
+However, QQuickSinglePointHandler::wantsPointerEvent() did not agree
+with that, because it assumed that a point id of 0 meant
+uninitialized/invalid point.
+The fix is to change QQuickSinglePointHandler::wantsPointerEvent() and
+QQuickHandlerPoint so that it assumes that the id -1 is now an invalid
+point, (instead of 0)
+
+Change-Id: I8c9683dfe06ebb77c5342a26f08174b67e7cbd90
+Reviewed-by: Shawn Rutledge 
+(cherry picked from commit 8d3a91016506fd0afedb0be535f7c34a4ca762f6)
+---
+ src/quick/handlers/qquickhandlerpoint.cpp       | 4 ++--
+ src/quick/handlers/qquicksinglepointhandler.cpp | 4 ++--
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/src/quick/handlers/qquickhandlerpoint.cpp b/src/quick/handlers/qquickhandlerpoint.cpp
+index 72efdfd0f4..6aef3545dd 100644
+--- a/src/quick/handlers/qquickhandlerpoint.cpp
++++ b/src/quick/handlers/qquickhandlerpoint.cpp
+@@ -82,7 +82,7 @@ void QQuickHandlerPoint::localize(QQuickItem *item)
+ 
+ void QQuickHandlerPoint::reset()
+ {
+-    m_id = 0;
++    m_id = -1;
+     m_uniqueId = QPointingDeviceUniqueId();
+     m_position = QPointF();
+     m_scenePosition = QPointF();
+@@ -165,7 +165,7 @@ void QQuickHandlerPoint::reset(const QVector &points)
+         pressureSum += point.pressure();
+         ellipseDiameterSum += point.ellipseDiameters();
+     }
+-    m_id = 0;
++    m_id = -1;
+     m_uniqueId = QPointingDeviceUniqueId();
+     // all points are required to be from the same event, so pressed buttons and modifiers should be the same
+     m_pressedButtons = points.first().pressedButtons();
+diff --git a/src/quick/handlers/qquicksinglepointhandler.cpp b/src/quick/handlers/qquicksinglepointhandler.cpp
+index b51f53b74f..89081b4e84 100644
+--- a/src/quick/handlers/qquicksinglepointhandler.cpp
++++ b/src/quick/handlers/qquicksinglepointhandler.cpp
+@@ -75,7 +75,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event)
+     if (!QQuickPointerDeviceHandler::wantsPointerEvent(event))
+         return false;
+ 
+-    if (d->pointInfo.id()) {
++    if (d->pointInfo.id() != -1) {
+         // We already know which one we want, so check whether it's there.
+         // It's expected to be an update or a release.
+         // If we no longer want it, cancel the grab.
+@@ -125,7 +125,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event)
+             chosen->setAccepted();
+         }
+     }
+-    return d->pointInfo.id();
++    return d->pointInfo.id() != -1;
+ }
+ 
+ void QQuickSinglePointHandler::handlePointerEventImpl(QQuickPointerEvent *event)
+-- 
+2.36.1
+
diff --git a/0011-Revert-Fix-TapHandler-so-that-it-actually-registers-.patch b/0011-Revert-Fix-TapHandler-so-that-it-actually-registers-.patch
new file mode 100644
index 0000000000000000000000000000000000000000..bfa99c49f1416405eaddad09c84b7a6f964422a1
--- /dev/null
+++ b/0011-Revert-Fix-TapHandler-so-that-it-actually-registers-.patch
@@ -0,0 +1,61 @@
+From d46164fdd36d748d427716e473e8f006d391f088 Mon Sep 17 00:00:00 2001
+From: Albert Astals Cid 
+Date: Tue, 16 Nov 2021 22:43:37 +0100
+Subject: [PATCH 11/19] Revert "Fix TapHandler so that it actually registers a
+ tap"
+
+This reverts commit 36e8ccd434f948e4f11a8f9d59139ec072e41ff5.
+
+It's causing regresions
+---
+ src/quick/handlers/qquickhandlerpoint.cpp       | 4 ++--
+ src/quick/handlers/qquicksinglepointhandler.cpp | 4 ++--
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/src/quick/handlers/qquickhandlerpoint.cpp b/src/quick/handlers/qquickhandlerpoint.cpp
+index 6aef3545dd..72efdfd0f4 100644
+--- a/src/quick/handlers/qquickhandlerpoint.cpp
++++ b/src/quick/handlers/qquickhandlerpoint.cpp
+@@ -82,7 +82,7 @@ void QQuickHandlerPoint::localize(QQuickItem *item)
+ 
+ void QQuickHandlerPoint::reset()
+ {
+-    m_id = -1;
++    m_id = 0;
+     m_uniqueId = QPointingDeviceUniqueId();
+     m_position = QPointF();
+     m_scenePosition = QPointF();
+@@ -165,7 +165,7 @@ void QQuickHandlerPoint::reset(const QVector &points)
+         pressureSum += point.pressure();
+         ellipseDiameterSum += point.ellipseDiameters();
+     }
+-    m_id = -1;
++    m_id = 0;
+     m_uniqueId = QPointingDeviceUniqueId();
+     // all points are required to be from the same event, so pressed buttons and modifiers should be the same
+     m_pressedButtons = points.first().pressedButtons();
+diff --git a/src/quick/handlers/qquicksinglepointhandler.cpp b/src/quick/handlers/qquicksinglepointhandler.cpp
+index 89081b4e84..b51f53b74f 100644
+--- a/src/quick/handlers/qquicksinglepointhandler.cpp
++++ b/src/quick/handlers/qquicksinglepointhandler.cpp
+@@ -75,7 +75,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event)
+     if (!QQuickPointerDeviceHandler::wantsPointerEvent(event))
+         return false;
+ 
+-    if (d->pointInfo.id() != -1) {
++    if (d->pointInfo.id()) {
+         // We already know which one we want, so check whether it's there.
+         // It's expected to be an update or a release.
+         // If we no longer want it, cancel the grab.
+@@ -125,7 +125,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event)
+             chosen->setAccepted();
+         }
+     }
+-    return d->pointInfo.id() != -1;
++    return d->pointInfo.id();
+ }
+ 
+ void QQuickSinglePointHandler::handlePointerEventImpl(QQuickPointerEvent *event)
+-- 
+2.36.1
+
diff --git a/0012-QQmlJs-FixedPoolArray-fix-UB-precondition-violation-.patch b/0012-QQmlJs-FixedPoolArray-fix-UB-precondition-violation-.patch
new file mode 100644
index 0000000000000000000000000000000000000000..623af7e64c7e1355beda2bd5024d0e74d277eba6
--- /dev/null
+++ b/0012-QQmlJs-FixedPoolArray-fix-UB-precondition-violation-.patch
@@ -0,0 +1,36 @@
+From 01322ea1a58b441071be7c66754d62ac50f49c4e Mon Sep 17 00:00:00 2001
+From: Marc Mutz 
+Date: Tue, 21 Dec 2021 09:20:17 +0100
+Subject: [PATCH 12/19] QQmlJs::FixedPoolArray: fix UB (precondition violation)
+ in allocate()
+
+Says ubsan:
+
+  qqmljsfixedpoolarray_p.h:90:19: runtime error: null pointer passed as argument 2, which is declared to never be null
+
+Fix, like in so many other places, by a size check.
+
+Pick-to: 6.3 6.2 5.15
+Change-Id: I9181d6ecb467c2dc726978ce7f93b35a6bf2f944
+Reviewed-by: Lars Knoll 
+(cherry picked from commit d74e931f3fc2587ac6d1e2930acbbe54ea5be2b5)
+---
+ src/qml/common/qqmljsfixedpoolarray_p.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/qml/common/qqmljsfixedpoolarray_p.h b/src/qml/common/qqmljsfixedpoolarray_p.h
+index b65b994d6c..15a8cd6878 100644
+--- a/src/qml/common/qqmljsfixedpoolarray_p.h
++++ b/src/qml/common/qqmljsfixedpoolarray_p.h
+@@ -86,7 +86,7 @@ public:
+         if (QTypeInfo::isComplex) {
+             for (int i = 0; i < count; ++i)
+                 new (data + i) T(vector.at(i));
+-        } else {
++        } else if (count) {
+             memcpy(data, static_cast(vector.constData()), count * sizeof(T));
+         }
+     }
+-- 
+2.36.1
+
diff --git a/0013-V4-Do-not-call-dtor-of-an-object-we-continue-to-use.patch b/0013-V4-Do-not-call-dtor-of-an-object-we-continue-to-use.patch
new file mode 100644
index 0000000000000000000000000000000000000000..68f1bad8b3fe734dcfd3065a818550a92511672b
--- /dev/null
+++ b/0013-V4-Do-not-call-dtor-of-an-object-we-continue-to-use.patch
@@ -0,0 +1,51 @@
+From f5de08d116481630ad0843990ffdf141fd6ce69e Mon Sep 17 00:00:00 2001
+From: Ulf Hermann 
+Date: Thu, 3 Feb 2022 10:02:06 +0100
+Subject: [PATCH 13/19] V4: Do not call dtor of an object we continue to use
+
+After destroyObject(), the QObjectWrapper is still alive. We might use
+its heap object again. Furthermore, the Heap::QObjectWrapper dtor does
+not actually do anything defined. What we want to do here is clear the
+QObject pointer because we've just gotten rid of the QObject. There is a
+method for that: Heap::QObjectWrapper::destroy().
+
+Finally, the internalClass must never ever be nullptr. Assert on that
+rather than checking it.
+
+Pick-to: 5.15 6.2 6.3
+Task-number: QTBUG-100431
+Change-Id: I794a295c182b2ed4ba80673f58d6143c861b7391
+Reviewed-by: Andrei Golubev 
+Reviewed-by: Qt CI Bot 
+Reviewed-by: Fabian Kosmale 
+(cherry picked from commit 6c197319f34b8098d034f1543eb5feb9d7be54c3)
+---
+ src/qml/jsruntime/qv4qobjectwrapper.cpp | 5 ++---
+ 1 file changed, 2 insertions(+), 3 deletions(-)
+
+diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
+index 9899c9274e..272b85069f 100644
+--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
++++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
+@@ -1160,8 +1160,7 @@ void Heap::QObjectWrapper::markObjects(Heap::Base *that, QV4::MarkStack *markSta
+ void QObjectWrapper::destroyObject(bool lastCall)
+ {
+     Heap::QObjectWrapper *h = d();
+-    if (!h->internalClass)
+-        return; // destroyObject already got called
++    Q_ASSERT(h->internalClass);
+ 
+     if (h->object()) {
+         QQmlData *ddata = QQmlData::get(h->object(), false);
+@@ -1191,7 +1190,7 @@ void QObjectWrapper::destroyObject(bool lastCall)
+         }
+     }
+ 
+-    h->~Data();
++    h->destroy();
+ }
+ 
+ 
+-- 
+2.36.1
+
diff --git a/0014-Make-sure-QQuickWidget-and-its-offscreen-window-s-sc.patch b/0014-Make-sure-QQuickWidget-and-its-offscreen-window-s-sc.patch
new file mode 100644
index 0000000000000000000000000000000000000000..3fbbbcd8e2b7eb7d476aa898afa0075839e6b9b9
--- /dev/null
+++ b/0014-Make-sure-QQuickWidget-and-its-offscreen-window-s-sc.patch
@@ -0,0 +1,84 @@
+From b485b9ca8983499a55d7e06a3ac3f0ac45a61b99 Mon Sep 17 00:00:00 2001
+From: Vlad Zahorodnii 
+Date: Sat, 29 Jan 2022 21:59:33 +0200
+Subject: [PATCH 14/19] Make sure QQuickWidget and its offscreen window's
+ screens are always in sync
+
+By default, the offscreen window is placed on the primary screen.
+However, if the parent widget argument is passed to the QQuickWidget's
+constructor, then QQuickWidget's and the offscreen window's screens can
+be different and that can create rendering issues, e.g. blurry text if
+the primary screen and QQuickWidget's screen have different scale
+factors.
+
+Change-Id: I10c62b5635664f943b11828773f14017f198a770
+Reviewed-by: David Edmundson 
+Reviewed-by: Laszlo Agocs 
+(cherry picked from commit a2a2734bffa1459639b31fb3f4f83873ba44ab5c)
+---
+ src/quickwidgets/qquickwidget.cpp | 26 +++++++++++---------------
+ 1 file changed, 11 insertions(+), 15 deletions(-)
+
+diff --git a/src/quickwidgets/qquickwidget.cpp b/src/quickwidgets/qquickwidget.cpp
+index 39780f8de3..223d91f579 100644
+--- a/src/quickwidgets/qquickwidget.cpp
++++ b/src/quickwidgets/qquickwidget.cpp
+@@ -106,6 +106,7 @@ void QQuickWidgetPrivate::init(QQmlEngine* e)
+ 
+     renderControl = new QQuickWidgetRenderControl(q);
+     offscreenWindow = new QQuickWindow(*new QQuickOffcreenWindowPrivate(),renderControl);
++    offscreenWindow->setScreen(q->screen());
+     offscreenWindow->setTitle(QString::fromLatin1("Offscreen"));
+     offscreenWindow->setObjectName(QString::fromLatin1("QQuickOffScreenWindow"));
+     // Do not call create() on offscreenWindow.
+@@ -901,9 +902,7 @@ void QQuickWidgetPrivate::createContext()
+ 
+         context = new QOpenGLContext;
+         context->setFormat(offscreenWindow->requestedFormat());
+-        const QWindow *win = q->window()->windowHandle();
+-        if (win && win->screen())
+-            context->setScreen(win->screen());
++        context->setScreen(q->screen());
+         QOpenGLContext *shareContext = qt_gl_global_share_context();
+         if (!shareContext)
+             shareContext = QWidgetPrivate::get(q->window())->shareContext();
+@@ -1520,19 +1519,16 @@ bool QQuickWidget::event(QEvent *e)
+         d->handleWindowChange();
+         break;
+ 
+-    case QEvent::ScreenChangeInternal:
+-        if (QWindow *window = this->window()->windowHandle()) {
+-            QScreen *newScreen = window->screen();
+-
+-            if (d->offscreenWindow)
+-                d->offscreenWindow->setScreen(newScreen);
+-            if (d->offscreenSurface)
+-                d->offscreenSurface->setScreen(newScreen);
++    case QEvent::ScreenChangeInternal: {
++        QScreen *newScreen = screen();
++        if (d->offscreenWindow)
++            d->offscreenWindow->setScreen(newScreen);
++        if (d->offscreenSurface)
++            d->offscreenSurface->setScreen(newScreen);
+ #if QT_CONFIG(opengl)
+-            if (d->context)
+-                d->context->setScreen(newScreen);
++        if (d->context)
++            d->context->setScreen(newScreen);
+ #endif
+-        }
+ 
+         if (d->useSoftwareRenderer
+ #if QT_CONFIG(opengl)
+@@ -1545,7 +1541,7 @@ bool QQuickWidget::event(QEvent *e)
+             d->render(true);
+         }
+         break;
+-
++    }
+     case QEvent::Show:
+     case QEvent::Move:
+         d->updatePosition();
+-- 
+2.36.1
+
diff --git a/0015-QQuickItem-Guard-against-cycles-in-nextPrevItemInTab.patch b/0015-QQuickItem-Guard-against-cycles-in-nextPrevItemInTab.patch
new file mode 100644
index 0000000000000000000000000000000000000000..d587bb4483e115a55e6fa2a94f3c20e275fe3c17
--- /dev/null
+++ b/0015-QQuickItem-Guard-against-cycles-in-nextPrevItemInTab.patch
@@ -0,0 +1,122 @@
+From aca0c736c99439a8f4d297bc57c1fa5a2d2a6e88 Mon Sep 17 00:00:00 2001
+From: Fabian Kosmale 
+Date: Wed, 4 May 2022 09:10:54 +0200
+Subject: [PATCH 15/19] QQuickItem: Guard against cycles in
+ nextPrevItemInTabFocusChain
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+nextPrevItemInTabFocusChain already had a check to prevent running into
+cycles, it would however only detect if we reached the original item. If
+our cycle instead would loop between reachable items without ever
+returning to the initial one, as in the diagram below, then we would
+never terminate the loop.
+
+            /-->other item<---next item
+initial-item           \          ^
+                        \         |
+			 --->different item
+
+To prevent this from happening, we keep track of all items we've seen so
+far. One last complications arises due to the fact that we do visit the
+parent twice under some cicrcumstances, but we already have the skip
+variable to indicate that case – we simply skip the duplicate check if
+it is set to true.
+
+Pick-to: 6.2 6.3
+Fixes: QTBUG-87190
+Change-Id: I1449a7ebf8f325f00c296e8a8db4360faf1049e4
+Reviewed-by: Volker Hilsheimer 
+(cherry picked from commit e74bcf751495d9fe27efd195bc04e2a6ae6732a4)
+---
+ src/quick/items/qquickitem.cpp                      |  7 ++++++-
+ .../data/activeFocusOnTab_infiniteLoop3.qml         | 13 +++++++++++++
+ tests/auto/quick/qquickitem2/tst_qquickitem.cpp     | 12 ++++++++++++
+ 3 files changed, 31 insertions(+), 1 deletion(-)
+ create mode 100644 tests/auto/quick/qquickitem2/data/activeFocusOnTab_infiniteLoop3.qml
+
+diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
+index 3df899d63d..83e52b12e5 100644
+--- a/src/quick/items/qquickitem.cpp
++++ b/src/quick/items/qquickitem.cpp
+@@ -59,6 +59,7 @@
+ #include 
+ #include 
+ #include 
++#include 
+ 
+ #include 
+ #include 
+@@ -2526,6 +2527,7 @@ QQuickItem* QQuickItemPrivate::nextPrevItemInTabFocusChain(QQuickItem *item, boo
+     QQuickItem *current = item;
+     qCDebug(DBG_FOCUS) << "QQuickItemPrivate::nextPrevItemInTabFocusChain: startItem:" << startItem;
+     qCDebug(DBG_FOCUS) << "QQuickItemPrivate::nextPrevItemInTabFocusChain: firstFromItem:" << firstFromItem;
++    QDuplicateTracker cycleDetector;
+     do {
+         qCDebug(DBG_FOCUS) << "QQuickItemPrivate::nextPrevItemInTabFocusChain: current:" << current;
+         qCDebug(DBG_FOCUS) << "QQuickItemPrivate::nextPrevItemInTabFocusChain: from:" << from;
+@@ -2592,7 +2594,10 @@ QQuickItem* QQuickItemPrivate::nextPrevItemInTabFocusChain(QQuickItem *item, boo
+         // traversed all of the chain (by compare the [current] item with [startItem])
+         // Since the [startItem] might be promoted to its parent if it is invisible,
+         // we still have to check [current] item with original start item
+-        if ((current == startItem || current == originalStartItem) && from == firstFromItem) {
++        // We might also run into a cycle before we reach firstFromItem again
++        // but note that we have to ignore current if we are meant to skip it
++        if (((current == startItem || current == originalStartItem) && from == firstFromItem) ||
++                (!skip && cycleDetector.hasSeen(current))) {
+             // wrapped around, avoid endless loops
+             if (item == contentItem) {
+                 qCDebug(DBG_FOCUS) << "QQuickItemPrivate::nextPrevItemInTabFocusChain: looped, return contentItem";
+diff --git a/tests/auto/quick/qquickitem2/data/activeFocusOnTab_infiniteLoop3.qml b/tests/auto/quick/qquickitem2/data/activeFocusOnTab_infiniteLoop3.qml
+new file mode 100644
+index 0000000000..889e480f3b
+--- /dev/null
++++ b/tests/auto/quick/qquickitem2/data/activeFocusOnTab_infiniteLoop3.qml
+@@ -0,0 +1,13 @@
++import QtQuick 2.6
++
++Item {
++    visible: true
++    Item {
++        visible: false
++        Item {
++            objectName: "hiddenChild"
++            activeFocusOnTab: true
++            focus: true
++        }
++    }
++}
+diff --git a/tests/auto/quick/qquickitem2/tst_qquickitem.cpp b/tests/auto/quick/qquickitem2/tst_qquickitem.cpp
+index f65650cf9c..eeff768bb4 100644
+--- a/tests/auto/quick/qquickitem2/tst_qquickitem.cpp
++++ b/tests/auto/quick/qquickitem2/tst_qquickitem.cpp
+@@ -66,6 +66,7 @@ private slots:
+     void activeFocusOnTab10();
+     void activeFocusOnTab_infiniteLoop_data();
+     void activeFocusOnTab_infiniteLoop();
++    void activeFocusOnTab_infiniteLoopControls();
+ 
+     void nextItemInFocusChain();
+     void nextItemInFocusChain2();
+@@ -1055,6 +1056,17 @@ void tst_QQuickItem::activeFocusOnTab_infiniteLoop()
+     QCOMPARE(item, window->rootObject());
+ }
+ 
++
++void tst_QQuickItem::activeFocusOnTab_infiniteLoopControls()
++{
++    auto source = testFileUrl("activeFocusOnTab_infiniteLoop3.qml");
++    QScopedPointerwindow(new QQuickView());
++    window->setSource(source);
++    window->show();
++    QVERIFY(window->errors().isEmpty());
++    QTest::keyClick(window.get(), Qt::Key_Tab); // should not hang
++}
++
+ void tst_QQuickItem::nextItemInFocusChain()
+ {
+     if (!qt_tab_all_widgets())
+-- 
+2.36.1
+
diff --git a/0016-QSGOpenGLDistanceFieldGlyphCache-fix-multiplication-.patch b/0016-QSGOpenGLDistanceFieldGlyphCache-fix-multiplication-.patch
new file mode 100644
index 0000000000000000000000000000000000000000..3e1f824b9c6f5afe8a5122255aff857198f15f20
--- /dev/null
+++ b/0016-QSGOpenGLDistanceFieldGlyphCache-fix-multiplication-.patch
@@ -0,0 +1,43 @@
+From db0c06d98464d8d0cc6dfddfc502593951bac768 Mon Sep 17 00:00:00 2001
+From: Marc Mutz 
+Date: Tue, 16 Jul 2019 11:23:37 +0200
+Subject: [PATCH 16/19] QSGOpenGLDistanceFieldGlyphCache: fix multiplication
+ result truncation
+
+The type of the expression int * int is int, so truncation has already
+happened when the result is assigned to a qint64.
+
+Fix by casting one of the multiplicants to qint64 before performing
+the multiplication. This multiplication cannot overflow, because int
+is 32-bit on all supported platforms.
+
+The addition of 'size' to the pointer will still truncate the result,
+on 32bit platforms, but that check is in itself UB. A follow-up commit
+will fix the check, and with it the last truncation to 32bit.
+
+Coverity-Id: 218769
+Pick-to: 6.3 6.2 5.15
+Change-Id: I0d71950695b9743db8c96d825e68bb1e9c47de02
+Reviewed-by: Fabian Kosmale 
+Reviewed-by: Thiago Macieira 
+(cherry picked from commit cacfc1dbb9719c0ef55cff69dad0921ce1405438)
+---
+ src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp b/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
+index 53b6fe117f..f7cb8bede3 100644
+--- a/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
++++ b/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
+@@ -512,7 +512,7 @@ bool QSGRhiDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
+ 
+             int width = texInfo->allocatedArea.width();
+             int height = texInfo->allocatedArea.height();
+-            qint64 size = width * height;
++            qint64 size = qint64(width) * height;
+             if (reinterpret_cast(textureData + size) > qtdfTableEnd) {
+                 qWarning("qtdf table too small in font '%s'.",
+                          qPrintable(font.familyName()));
+-- 
+2.36.1
+
diff --git a/0017-QSGOpenGLDistanceFieldGlyphCache-fix-UB-ordering-of-.patch b/0017-QSGOpenGLDistanceFieldGlyphCache-fix-UB-ordering-of-.patch
new file mode 100644
index 0000000000000000000000000000000000000000..e22eaf396cc2a01ff40749aac98c049ecf9ec280
--- /dev/null
+++ b/0017-QSGOpenGLDistanceFieldGlyphCache-fix-UB-ordering-of-.patch
@@ -0,0 +1,68 @@
+From 59019a226146d9d80a01db21c0c3d692027048aa Mon Sep 17 00:00:00 2001
+From: Marc Mutz 
+Date: Tue, 16 Jul 2019 11:31:01 +0200
+Subject: [PATCH 17/19] QSGOpenGLDistanceFieldGlyphCache: fix UB (ordering of
+ pointers not from the same array)
+
+The code performed out of bounds checks by adding the size of the
+buffer to a pointer and comparing the result to the the
+one-past-the-end pointer of the buffer.
+
+This is UB, for three reasons:
+
+- in one case, a qint64 is added to a pointer, silently truncating the
+  result on 32bit platforms
+
+- if the buffer overflow is large, the pointer value may wrap around,
+  yielding a result that is numerically less than the end pointer, but
+  still out-of-bounds.
+
+- pointer order is only defined within a C array, plus one past the
+  end. On failure, pointers outside that range are compared.
+
+Fix by comparing distance(it, end) with the required size for the
+chunk to be written instead.
+
+Pick-to: 6.3 6.2 5.15
+Change-Id: I356bb8c8a65a93b8b1c1eb7bac381dd64bea719e
+Reviewed-by: Fabian Kosmale 
+Reviewed-by: Thiago Macieira 
+(cherry picked from commit 8d9bd6b381bfc759d575954801b683354ad6a790)
+---
+ src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp b/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
+index f7cb8bede3..219cdd5966 100644
+--- a/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
++++ b/src/quick/scenegraph/qsgrhidistancefieldglyphcache.cpp
+@@ -446,7 +446,7 @@ bool QSGRhiDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
+ 
+         const char *textureRecord = allocatorData;
+         for (int i = 0; i < textureCount; ++i, textureRecord += Qtdf::TextureRecordSize) {
+-            if (textureRecord + Qtdf::TextureRecordSize > qtdfTableEnd) {
++            if (qtdfTableEnd - textureRecord < Qtdf::TextureRecordSize) {
+                 qWarning("qtdf table too small in font '%s'.",
+                          qPrintable(font.familyName()));
+                 return false;
+@@ -462,7 +462,7 @@ bool QSGRhiDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
+ 
+         const char *glyphRecord = textureRecord;
+         for (quint32 i = 0; i < glyphCount; ++i, glyphRecord += Qtdf::GlyphRecordSize) {
+-            if (glyphRecord + Qtdf::GlyphRecordSize > qtdfTableEnd) {
++            if (qtdfTableEnd - glyphRecord < Qtdf:: GlyphRecordSize) {
+                 qWarning("qtdf table too small in font '%s'.",
+                          qPrintable(font.familyName()));
+                 return false;
+@@ -513,7 +513,7 @@ bool QSGRhiDistanceFieldGlyphCache::loadPregeneratedCache(const QRawFont &font)
+             int width = texInfo->allocatedArea.width();
+             int height = texInfo->allocatedArea.height();
+             qint64 size = qint64(width) * height;
+-            if (reinterpret_cast(textureData + size) > qtdfTableEnd) {
++            if (qtdfTableEnd - reinterpret_cast(textureData) < size) {
+                 qWarning("qtdf table too small in font '%s'.",
+                          qPrintable(font.familyName()));
+                 return false;
+-- 
+2.36.1
+
diff --git a/0018-Fix-Flickable-wheel-velocity-calculation.patch b/0018-Fix-Flickable-wheel-velocity-calculation.patch
new file mode 100644
index 0000000000000000000000000000000000000000..159f15fa150c4dd57a763484de7f2f101d5a24e6
--- /dev/null
+++ b/0018-Fix-Flickable-wheel-velocity-calculation.patch
@@ -0,0 +1,423 @@
+From 955c47dd07d4337c279433b246421b92a4d16341 Mon Sep 17 00:00:00 2001
+From: Shawn Rutledge 
+Date: Tue, 4 May 2021 10:12:39 +0200
+Subject: [PATCH 18/19] Fix Flickable wheel velocity calculation
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Angular velocity is defined as angle rotated divided by time elapsed.
+But the historical problem with Flickable is that the calculation
+ignored time, as if there was a maximum frequency of events and we
+only needed to know the rotation angle per fixed unit of time.
+With "clicky" mouse wheels perhaps it was a reasonable approximation.
+With touchpads that provide pixel deltas, we've been doing the velocity
+calculation the right way since a6ed830f4779e218b8e8f8d82dc4aa9b4b4528a1
+Now we divide by dt also in the wheel rotation case.
+
+That gives instantaneous velocity.  Next question: how to do smoothing?
+AxisData::velocityBuffer is basically a Kalman filter, but until now
+it was used only when dragging ends and we animate the deceleration from
+the velocity at that time.  It seems to work well for smoothing the
+velocity that comes from wheel events, too.  So now we use that instead
+of smoothVelocity, and it stays in control better.
+
+Next question: when a series of wheel events occurs, we have valid
+dt for the dy / dt velocity calculation (or dx / dt horizontally),
+but what about the initial flick?  What if first thing the user does
+is rotate a physical mouse wheel by one "click", how far should
+Flickable move before it comes to rest?  QStyleHints::wheelScrollLines()
+tells us how far to move for one wheel event... in "lines", whatever
+that is.  Flickable doesn't know about its contents.  But it "feels"
+reasonable if we define a "line" as 24 pixels.  At least the setting
+will do something now: applications can adjust it, and some system
+control panels can adjust it.  A subclass of QQuickFlickable (such as
+TableView) could even change QQFlickablePrivate::initialWheelFlickDistance
+to be the actual number of pixels per "line", to scroll exactly by rows.
+(But when the events occur faster, it moves further and faster, like it
+always did.)
+
+OK so we know how far we want to move when the Flickable is at rest
+and receives a QWheelEvent with angleDelta of 120.  I.e. when isMoving()
+is false.  So I tried an experiment: set dt to 0.25.  How far did it move?
+77 pixels.  Why?  We're making it move via QQuickFlickablePrivate::flick()
+which does some math and drives the timeline. The key formula is
+qreal dist = v2 / (accel * 2.0)
+which agrees with the testing: if the wheel turns by 120 units,
+(120 / 0.25)^2 / (1500 * 2) =~ 77
+So it's possible to do the algebra to reverse-engineer what dt should be
+so that we will move the right distance with a single wheel event,
+despite the complexity of the animation itself.  That's what is now
+done.  When the user rotates the wheel very slowly, it moves by discrete
+amounts but with smooth animation.  A little faster, and it speeds up,
+somewhat like it did before, but with more control.  If it has sped
+up to a high speed and then the user rotates the wheel backwards,
+it reverses instantly: we clear the Kalman filter and insert instantaneous
+velocity (so it will go from there at the next event).
+
+On a touchpad, it also feels quite in-control because the velocity
+is calculated properly as distance-delta / time-delta.  Smoothing
+it out doesn't hurt, and animating after release doesn't hurt.
+It longer goes "zing" out of control when the wheel events come in too
+frequently from a touchpad or a free-spinning wheel.
+
+None of this affects trackpads on macOS, because then the wheel events
+have phases and pixel deltas, and we don't use this animation.  We still
+should try to get that working on as many OSes as possible, eventually.
+
+Clarify the meaning of the flickDeceleration property.
+
+[ChangeLog][QtQuick][Flickable] Flickable no longer tries to detect
+whether you're using a "clicky" wheel or a touchpad, but rather does the
+velocity calculation more correctly with elapsed time (dθ / dt).
+A single rotation of a "clicky" wheel also moves a fixed distance,
+which is now adjustable via QStyleHints::wheelScrollLines().
+Animation is restored, but should now stay in control on touchpads;
+and it will once again transition the "moving" properties correctly
+when scrolling ends.
+
+Fixes: QTBUG-56075
+Pick-to: 6.2
+Change-Id: I5166ca31c86335641cf407a922a3a970fced653d
+Reviewed-by: Richard Moe Gustavsen 
+(cherry picked from commit a8fbd865140d4dd165723c7e3d4168514d4b1d0c)
+---
+ src/quick/items/qquickflickable.cpp           | 95 +++++++++++++------
+ src/quick/items/qquickflickable_p_p.h         |  1 +
+ src/quick/util/qquicktimeline.cpp             |  3 +
+ .../qquickflickable/tst_qquickflickable.cpp   |  9 +-
+ tests/manual/touch/flicktext.qml              | 30 ++++++
+ 5 files changed, 107 insertions(+), 31 deletions(-)
+
+diff --git a/src/quick/items/qquickflickable.cpp b/src/quick/items/qquickflickable.cpp
+index 9a68be4c49..efb2f11d02 100644
+--- a/src/quick/items/qquickflickable.cpp
++++ b/src/quick/items/qquickflickable.cpp
+@@ -263,7 +263,8 @@ QQuickFlickablePrivate::QQuickFlickablePrivate()
+     , deceleration(QML_FLICK_DEFAULTDECELERATION)
+     , maxVelocity(QML_FLICK_DEFAULTMAXVELOCITY), reportedVelocitySmoothing(100)
+     , delayedPressEvent(nullptr), pressDelay(0), fixupDuration(400)
+-    , flickBoost(1.0), fixupMode(Normal), vTime(0), visibleArea(nullptr)
++    , flickBoost(1.0), initialWheelFlickDistance(qApp->styleHints()->wheelScrollLines() * 24)
++    , fixupMode(Normal), vTime(0), visibleArea(nullptr)
+     , flickableDirection(QQuickFlickable::AutoFlickDirection)
+     , boundsBehavior(QQuickFlickable::DragAndOvershootBounds)
+     , boundsMovement(QQuickFlickable::FollowBoundsBehavior)
+@@ -531,10 +532,14 @@ void QQuickFlickablePrivate::updateBeginningEnd()
+     if (atBeginning != vData.atBeginning) {
+         vData.atBeginning = atBeginning;
+         atYBeginningChange = true;
++        if (!vData.moving && atBeginning)
++            vData.smoothVelocity.setValue(0);
+     }
+     if (atEnd != vData.atEnd) {
+         vData.atEnd = atEnd;
+         atYEndChange = true;
++        if (!vData.moving && atEnd)
++            vData.smoothVelocity.setValue(0);
+     }
+ 
+     // Horizontal
+@@ -547,10 +552,14 @@ void QQuickFlickablePrivate::updateBeginningEnd()
+     if (atBeginning != hData.atBeginning) {
+         hData.atBeginning = atBeginning;
+         atXBeginningChange = true;
++        if (!hData.moving && atBeginning)
++            hData.smoothVelocity.setValue(0);
+     }
+     if (atEnd != hData.atEnd) {
+         hData.atEnd = atEnd;
+         atXEndChange = true;
++        if (!hData.moving && atEnd)
++            hData.smoothVelocity.setValue(0);
+     }
+ 
+     if (vData.extentsChanged) {
+@@ -1489,6 +1498,7 @@ void QQuickFlickable::wheelEvent(QWheelEvent *event)
+         d->hData.velocity = 0;
+         d->timer.start();
+         d->maybeBeginDrag(currentTimestamp, event->position());
++        d->lastPosTime = -1;
+         break;
+     case Qt::NoScrollPhase: // default phase with an ordinary wheel mouse
+     case Qt::ScrollUpdate:
+@@ -1515,20 +1525,34 @@ void QQuickFlickable::wheelEvent(QWheelEvent *event)
+         return;
+     }
+ 
++    qreal elapsed = qreal(currentTimestamp - d->lastPosTime) / qreal(1000);
++    if (elapsed <= 0) {
++        d->lastPosTime = currentTimestamp;
++        qCDebug(lcWheel) << "insufficient elapsed time: can't calculate velocity" << elapsed;
++        return;
++    }
++
+     if (event->source() == Qt::MouseEventNotSynthesized || event->pixelDelta().isNull()) {
+-        // physical mouse wheel, so use angleDelta
++        // no pixel delta (physical mouse wheel, or "dumb" touchpad), so use angleDelta
+         int xDelta = event->angleDelta().x();
+         int yDelta = event->angleDelta().y();
++        // For a single "clicky" wheel event (angleDelta +/- 120),
++        // we want flick() to end up moving a distance proportional to QStyleHints::wheelScrollLines().
++        // The decel algo from there is
++        // qreal dist = v2 / (accel * 2.0);
++        // i.e. initialWheelFlickDistance = (120 / dt)^2 / (deceleration * 2)
++        // now solve for dt:
++        // dt = 120 / sqrt(deceleration * 2 * initialWheelFlickDistance)
++        if (!isMoving())
++            elapsed = 120 / qSqrt(d->deceleration * 2 * d->initialWheelFlickDistance);
+         if (yflick() && yDelta != 0) {
+-            bool valid = false;
+-            if (yDelta > 0 && contentY() > -minYExtent()) {
+-                d->vData.velocity = qMax(yDelta*2 - d->vData.smoothVelocity.value(), qreal(d->maxVelocity/4));
+-                valid = true;
+-            } else if (yDelta < 0 && contentY() < -maxYExtent()) {
+-                d->vData.velocity = qMin(yDelta*2 - d->vData.smoothVelocity.value(), qreal(-d->maxVelocity/4));
+-                valid = true;
+-            }
+-            if (valid) {
++            qreal instVelocity = yDelta / elapsed;
++            // if the direction has changed, start over with filtering, to allow instant movement in the opposite direction
++            if ((instVelocity < 0 && d->vData.velocity > 0) || (instVelocity > 0 && d->vData.velocity < 0))
++                d->vData.velocityBuffer.clear();
++            d->vData.addVelocitySample(instVelocity, d->maxVelocity);
++            d->vData.updateVelocity();
++            if ((yDelta > 0 && contentY() > -minYExtent()) || (yDelta < 0 && contentY() < -maxYExtent())) {
+                 d->flickY(d->vData.velocity);
+                 d->flickingStarted(false, true);
+                 if (d->vData.flicking) {
+@@ -1539,15 +1563,13 @@ void QQuickFlickable::wheelEvent(QWheelEvent *event)
+             }
+         }
+         if (xflick() && xDelta != 0) {
+-            bool valid = false;
+-            if (xDelta > 0 && contentX() > -minXExtent()) {
+-                d->hData.velocity = qMax(xDelta*2 - d->hData.smoothVelocity.value(), qreal(d->maxVelocity/4));
+-                valid = true;
+-            } else if (xDelta < 0 && contentX() < -maxXExtent()) {
+-                d->hData.velocity = qMin(xDelta*2 - d->hData.smoothVelocity.value(), qreal(-d->maxVelocity/4));
+-                valid = true;
+-            }
+-            if (valid) {
++            qreal instVelocity = xDelta / elapsed;
++            // if the direction has changed, start over with filtering, to allow instant movement in the opposite direction
++            if ((instVelocity < 0 && d->hData.velocity > 0) || (instVelocity > 0 && d->hData.velocity < 0))
++                d->hData.velocityBuffer.clear();
++            d->hData.addVelocitySample(instVelocity, d->maxVelocity);
++            d->hData.updateVelocity();
++            if ((xDelta > 0 && contentX() > -minXExtent()) || (xDelta < 0 && contentX() < -maxXExtent())) {
+                 d->flickX(d->hData.velocity);
+                 d->flickingStarted(true, false);
+                 if (d->hData.flicking) {
+@@ -1562,18 +1584,13 @@ void QQuickFlickable::wheelEvent(QWheelEvent *event)
+         int xDelta = event->pixelDelta().x();
+         int yDelta = event->pixelDelta().y();
+ 
+-        qreal elapsed = qreal(currentTimestamp - d->lastPosTime) / 1000.;
+-        if (elapsed <= 0) {
+-            d->lastPosTime = currentTimestamp;
+-            return;
+-        }
+         QVector2D velocity(xDelta / elapsed, yDelta / elapsed);
+-        d->lastPosTime = currentTimestamp;
+         d->accumulatedWheelPixelDelta += QVector2D(event->pixelDelta());
+         d->drag(currentTimestamp, event->type(), event->position(), d->accumulatedWheelPixelDelta,
+                 true, !d->scrollingPhase, true, velocity);
+         event->accept();
+     }
++    d->lastPosTime = currentTimestamp;
+ 
+     if (!event->isAccepted())
+         QQuickItem::wheelEvent(event);
+@@ -1744,6 +1761,10 @@ void QQuickFlickable::componentComplete()
+         setContentX(-minXExtent());
+     if (!d->vData.explicitValue && d->vData.startMargin != 0.)
+         setContentY(-minYExtent());
++    if (lcWheel().isDebugEnabled() || lcVel().isDebugEnabled()) {
++        d->timeline.setObjectName(QLatin1String("timeline for Flickable ") + objectName());
++        d->velocityTimeline.setObjectName(QLatin1String("velocity timeline for Flickable ") + objectName());
++    }
+ }
+ 
+ void QQuickFlickable::viewportMoved(Qt::Orientations orient)
+@@ -2491,9 +2512,23 @@ void QQuickFlickable::setMaximumFlickVelocity(qreal v)
+ 
+ /*!
+     \qmlproperty real QtQuick::Flickable::flickDeceleration
+-    This property holds the rate at which a flick will decelerate.
+-
+-    The default value is platform dependent.
++    This property holds the rate at which a flick will decelerate:
++    the higher the number, the faster it slows down when the user stops
++    flicking via touch, touchpad or mouse wheel. For example 0.0001 is nearly
++    "frictionless", and 10000 feels quite "sticky".
++
++    The default value is platform dependent. Values of zero or less are not allowed.
++
++    \note For touchpad flicking, some platforms drive Flickable directly by
++    sending QWheelEvents with QWheelEvent::phase() being \c Qt::ScrollMomentum,
++    after the user has released all fingers from the touchpad. In that case,
++    the operating system is controlling the deceleration, and this property has
++    no effect.
++
++    \note For mouse wheel scrolling, and for gesture scrolling on touchpads
++    that do not have a momentum phase, extremely large values of
++    flickDeceleration can make Flickable very resistant to scrolling,
++    especially if \l maximumFlickVelocity is too small.
+ */
+ qreal QQuickFlickable::flickDeceleration() const
+ {
+@@ -2506,7 +2541,7 @@ void QQuickFlickable::setFlickDeceleration(qreal deceleration)
+     Q_D(QQuickFlickable);
+     if (deceleration == d->deceleration)
+         return;
+-    d->deceleration = deceleration;
++    d->deceleration = qMax(0.001, deceleration);
+     emit flickDecelerationChanged();
+ }
+ 
+diff --git a/src/quick/items/qquickflickable_p_p.h b/src/quick/items/qquickflickable_p_p.h
+index 414c9c33d6..6163613493 100644
+--- a/src/quick/items/qquickflickable_p_p.h
++++ b/src/quick/items/qquickflickable_p_p.h
+@@ -241,6 +241,7 @@ public:
+     int pressDelay;
+     int fixupDuration;
+     qreal flickBoost;
++    qreal initialWheelFlickDistance;
+ 
+     enum FixupMode { Normal, Immediate, ExtentChanged };
+     FixupMode fixupMode;
+diff --git a/src/quick/util/qquicktimeline.cpp b/src/quick/util/qquicktimeline.cpp
+index 7ec7c827eb..abe6eb7261 100644
+--- a/src/quick/util/qquicktimeline.cpp
++++ b/src/quick/util/qquicktimeline.cpp
+@@ -53,6 +53,8 @@
+ 
+ QT_BEGIN_NAMESPACE
+ 
++Q_LOGGING_CATEGORY(lcTl, "qt.quick.timeline")
++
+ struct Update {
+     Update(QQuickTimeLineValue *_g, qreal _v)
+         : g(_g), v(_v) {}
+@@ -513,6 +515,7 @@ void QQuickTimeLine::reset(QQuickTimeLineValue &timeLineValue)
+         qWarning() << "QQuickTimeLine: Cannot reset a QQuickTimeLineValue owned by another timeline.";
+         return;
+     }
++    qCDebug(lcTl) << static_cast(this) << timeLineValue.value();
+     remove(&timeLineValue);
+     timeLineValue._t = nullptr;
+ }
+diff --git a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
+index f3659290eb..9fa51da6f8 100644
+--- a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
++++ b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
+@@ -870,6 +870,7 @@ void tst_qquickflickable::wheel()
+     QVERIFY(flick != nullptr);
+     QQuickFlickablePrivate *fp = QQuickFlickablePrivate::get(flick);
+     QSignalSpy moveEndSpy(flick, SIGNAL(movementEnded()));
++    quint64 timestamp = 10;
+ 
+     // test a vertical flick
+     {
+@@ -877,6 +878,7 @@ void tst_qquickflickable::wheel()
+         QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(), QPoint(0,-120),
+                           Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase, false);
+         event.setAccepted(false);
++        event.setTimestamp(timestamp);
+         QGuiApplication::sendEvent(window.data(), &event);
+     }
+ 
+@@ -887,6 +889,7 @@ void tst_qquickflickable::wheel()
+     QCOMPARE(fp->velocityTimeline.isActive(), false);
+     QCOMPARE(fp->timeline.isActive(), false);
+     QTest::qWait(50); // make sure that onContentYChanged won't sneak in again
++    timestamp += 50;
+     QCOMPARE(flick->property("movementsAfterEnd").value(), 0); // QTBUG-55886
+ 
+     // get ready to test horizontal flick
+@@ -900,8 +903,8 @@ void tst_qquickflickable::wheel()
+         QPoint pos(200, 200);
+         QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(), QPoint(-120,0),
+                           Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase, false);
+-
+         event.setAccepted(false);
++        event.setTimestamp(timestamp);
+         QGuiApplication::sendEvent(window.data(), &event);
+     }
+ 
+@@ -926,11 +929,13 @@ void tst_qquickflickable::trackpad()
+     QVERIFY(flick != nullptr);
+     QSignalSpy moveEndSpy(flick, SIGNAL(movementEnded()));
+     QPoint pos(200, 200);
++    quint64 timestamp = 10;
+ 
+     {
+         QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(0,-100), QPoint(0,-120),
+                           Qt::NoButton, Qt::NoModifier, Qt::ScrollBegin, false);
+         event.setAccepted(false);
++        event.setTimestamp(timestamp++);
+         QGuiApplication::sendEvent(window.data(), &event);
+     }
+ 
+@@ -944,6 +949,7 @@ void tst_qquickflickable::trackpad()
+         QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(-100,0), QPoint(-120,0),
+                           Qt::NoButton, Qt::NoModifier, Qt::ScrollUpdate, false);
+         event.setAccepted(false);
++        event.setTimestamp(timestamp++);
+         QGuiApplication::sendEvent(window.data(), &event);
+     }
+ 
+@@ -954,6 +960,7 @@ void tst_qquickflickable::trackpad()
+         QWheelEvent event(pos, window->mapToGlobal(pos), QPoint(0,0), QPoint(0,0),
+                           Qt::NoButton, Qt::NoModifier, Qt::ScrollEnd, false);
+         event.setAccepted(false);
++        event.setTimestamp(timestamp++);
+         QGuiApplication::sendEvent(window.data(), &event);
+     }
+ 
+diff --git a/tests/manual/touch/flicktext.qml b/tests/manual/touch/flicktext.qml
+index 9e84261687..e69d6207a9 100644
+--- a/tests/manual/touch/flicktext.qml
++++ b/tests/manual/touch/flicktext.qml
+@@ -380,6 +380,36 @@ Rectangle {
+                 text: "content X " + flick.contentX.toFixed(2) + " Y " + flick.contentY.toFixed(2)
+             }
+         }
++
++        Column {
++            Row {
++                spacing: 2
++                Examples.Button {
++                    id: decrButton
++                    text: "-"
++                    onClicked: flick.flickDeceleration -= 100
++                    Timer {
++                        running: decrButton.pressed
++                        interval: 100; repeat: true
++                        onTriggered: flick.flickDeceleration -= 100
++                    }
++                }
++                Text {
++                    horizontalAlignment: Text.AlignHCenter
++                    text: "decel:\n" + flick.flickDeceleration.toFixed(4)
++                }
++                Examples.Button {
++                    id: incrButton
++                    text: "+"
++                    onClicked: flick.flickDeceleration += 100
++                }
++                Timer {
++                    running: incrButton.pressed
++                    interval: 100; repeat: true
++                    onTriggered: flick.flickDeceleration += 100
++                }
++            }
++        }
+     }
+ 
+     Component.onCompleted: {
+-- 
+2.36.1
+
diff --git a/0019-Fix-Flickable-with-QTBUG-56075-patch-applied.patch b/0019-Fix-Flickable-with-QTBUG-56075-patch-applied.patch
new file mode 100644
index 0000000000000000000000000000000000000000..0ee7d82b9df109c9368bee95dbbb3d537a196cd4
--- /dev/null
+++ b/0019-Fix-Flickable-with-QTBUG-56075-patch-applied.patch
@@ -0,0 +1,25 @@
+From c47f3d7b227c9bc86ca1702ae3291a62c2116cfa Mon Sep 17 00:00:00 2001
+From: Wolfgang Frisch 
+Date: Thu, 19 May 2022 00:55:50 +0200
+Subject: [PATCH 19/19] Fix Flickable with QTBUG-56075 patch applied
+
+---
+ src/quick/items/qquickflickable.cpp | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/src/quick/items/qquickflickable.cpp b/src/quick/items/qquickflickable.cpp
+index efb2f11d02..2a5b16c31a 100644
+--- a/src/quick/items/qquickflickable.cpp
++++ b/src/quick/items/qquickflickable.cpp
+@@ -62,6 +62,8 @@
+ QT_BEGIN_NAMESPACE
+ 
+ Q_DECLARE_LOGGING_CATEGORY(lcHandlerParent)
++Q_LOGGING_CATEGORY(lcWheel, "qt.quick.flickable.wheel")
++Q_LOGGING_CATEGORY(lcVel, "qt.quick.flickable.velocity")
+ 
+ // FlickThreshold determines how far the "mouse" must have moved
+ // before we perform a flick.
+-- 
+2.36.1
+
diff --git a/qt5-qtdeclarative-gcc11.patch b/qt5-qtdeclarative-gcc11.patch
new file mode 100644
index 0000000000000000000000000000000000000000..1af4ac10f15395ac070add27c69f6064dd55b6bd
--- /dev/null
+++ b/qt5-qtdeclarative-gcc11.patch
@@ -0,0 +1,25 @@
+diff --git a/src/qml/jsruntime/qv4regexp.cpp b/src/qml/jsruntime/qv4regexp.cpp
+index 76daead8..4f707703 100644
+--- a/src/qml/jsruntime/qv4regexp.cpp
++++ b/src/qml/jsruntime/qv4regexp.cpp
+@@ -37,6 +37,7 @@
+ **
+ ****************************************************************************/
+ 
++#include 
+ #include "qv4regexp_p.h"
+ #include "qv4engine_p.h"
+ #include "qv4scopedvalue_p.h"
+diff --git a/src/qmldebug/qqmlprofilerevent_p.h b/src/qmldebug/qqmlprofilerevent_p.h
+index a7e37d19..21c3b465 100644
+--- a/src/qmldebug/qqmlprofilerevent_p.h
++++ b/src/qmldebug/qqmlprofilerevent_p.h
+@@ -40,6 +40,8 @@
+ #ifndef QQMLPROFILEREVENT_P_H
+ #define QQMLPROFILEREVENT_P_H
+ 
++#include 
++
+ #include "qqmlprofilerclientdefinitions_p.h"
+ 
+ #include 
diff --git a/qt5-qtdeclarative.spec b/qt5-qtdeclarative.spec
new file mode 100644
index 0000000000000000000000000000000000000000..529f0d2a21c5719df8e773803cb41e3a5b45d109
--- /dev/null
+++ b/qt5-qtdeclarative.spec
@@ -0,0 +1,217 @@
+%define anolis_release 1
+%define _lto_cflags %{nil}
+
+%global qt_module qtdeclarative
+
+Summary: Qt5 - QtDeclarative component
+Name:    qt5-%{qt_module}
+Version: 5.15.5
+Release: %{anolis_release}%{?dist}
+
+# See LICENSE.GPL LICENSE.LGPL LGPL_EXCEPTION.txt, for details
+License: LGPLv2 with exceptions or GPLv3 with exceptions
+Url:     http://www.qt.io
+%global majmin %(echo %{version} | cut -d. -f1-2)
+Source0: https://download.qt.io/official_releases/qt/%{majmin}/%{version}/submodules/%{qt_module}-everywhere-opensource-src-%{version}.tar.xz
+
+## upstream patches
+## repo: https://invent.kde.org/qt/qt/qtdeclarative
+## branch: kde/5.15
+## git format-patch v5.15.5-lts-lgpl
+Patch1:  0001-Document-that-StyledText-also-supports-nbsp-and-quot.patch
+Patch2:  0002-Support-apos-in-styled-text.patch
+Patch3:  0003-Remove-unused-QPointer-QQuickPointerMask.patch
+Patch4:  0004-Include-limits-in-Yarr.h-to-fix-build-with-GCC-11.patch
+Patch5:  0005-QQuickLoader-Do-not-incubate-if-the-source-arrives-a.patch
+Patch6:  0006-QQmlDelegateModel-Refresh-the-view-when-a-column-is-.patch
+Patch7:  0007-Fix-sweep-step-for-tainted-QObject-JavaScript-wrappe.patch
+Patch8:  0008-Fix-distorted-text-with-subpixel-matrix-translation.patch
+Patch9:  0009-Revert-Fix-for-possible-crash-in-QSGDefaultLayer-gra.patch
+Patch10: 0010-Fix-TapHandler-so-that-it-actually-registers-a-tap.patch
+Patch11: 0011-Revert-Fix-TapHandler-so-that-it-actually-registers-.patch
+Patch12: 0012-QQmlJs-FixedPoolArray-fix-UB-precondition-violation-.patch
+Patch13: 0013-V4-Do-not-call-dtor-of-an-object-we-continue-to-use.patch
+Patch14: 0014-Make-sure-QQuickWidget-and-its-offscreen-window-s-sc.patch
+Patch15: 0015-QQuickItem-Guard-against-cycles-in-nextPrevItemInTab.patch
+Patch16: 0016-QSGOpenGLDistanceFieldGlyphCache-fix-multiplication-.patch
+Patch17: 0017-QSGOpenGLDistanceFieldGlyphCache-fix-UB-ordering-of-.patch
+Patch18: 0018-Fix-Flickable-wheel-velocity-calculation.patch
+Patch19: 0019-Fix-Flickable-with-QTBUG-56075-patch-applied.patch
+
+
+## upstreamable patches
+Patch100: %{name}-gcc11.patch
+# https://pagure.io/fedora-kde/SIG/issue/82
+Patch101: qtdeclarative-5.15.0-FixMaxXMaxYExtent.patch
+
+# filter qml provides
+%global __provides_exclude_from ^%{_qt5_archdatadir}/qml/.*\\.so$
+
+Obsoletes: qt5-qtjsbackend < 5.2.0
+Obsoletes: qt5-qtdeclarative-render2d < 5.7.1-10
+
+BuildRequires: make
+BuildRequires: gcc-c++
+BuildRequires: qt5-rpm-macros
+BuildRequires: qt5-qtbase-devel >= %{version}
+BuildRequires: qt5-qtbase-private-devel
+%{?_qt5:Requires: %{_qt5}%{?_isa} = %{_qt5_version}}
+BuildRequires: python%{python3_pkgversion}
+
+%if 0%{?bootstrap}
+Obsoletes: %{name}-examples < %{version}-%{release}
+%global no_examples CONFIG-=compile_examples
+%endif
+
+%if 0%{?tests}
+BuildRequires: dbus-x11
+BuildRequires: mesa-dri-drivers
+BuildRequires: time
+BuildRequires: xorg-x11-server-Xvfb
+%endif
+
+%description
+%{summary}.
+
+%package devel
+Summary: Development files for %{name}
+Obsoletes: qt5-qtjsbackend-devel < 5.2.0
+Obsoletes: qt5-qtdeclarative-render2d-devel < 5.7.1-10
+Provides:  %{name}-private-devel = %{version}-%{release}
+Requires: %{name}%{?_isa} = %{version}-%{release}
+Requires: qt5-qtbase-devel%{?_isa}
+%description devel
+%{summary}.
+
+%package static
+Summary: Static library files for %{name}
+Requires: %{name}-devel%{?_isa} = %{version}-%{release}
+%description static
+%{summary}.
+
+%package examples
+Summary: Programming examples for %{name}
+Requires: %{name}%{?_isa} = %{version}-%{release}
+%description examples
+%{summary}.
+
+
+%prep
+%autosetup -n %{qt_module}-everywhere-src-%{version} -p1
+
+
+%build
+
+# HACK so calls to "python" get what we want
+ln -s %{__python3} python
+export PATH=`pwd`:$PATH
+
+%qmake_qt5
+
+%make_build
+
+
+%install
+%make_install INSTALL_ROOT=%{buildroot}
+
+# hardlink files to %{_bindir}, add -qt5 postfix to not conflict
+mkdir %{buildroot}%{_bindir}
+pushd %{buildroot}%{_qt5_bindir}
+for i in * ; do
+  case "${i}" in
+    # qt4 conflicts
+    qmlplugindump|qmlprofiler)
+      ln -v  ${i} %{buildroot}%{_bindir}/${i}-qt5
+      ln -sv ${i} ${i}-qt5
+      ;;
+    # qtchooser stuff
+    qml|qmlbundle|qmlmin|qmlscene)
+      ln -v  ${i} %{buildroot}%{_bindir}/${i}
+      ln -v  ${i} %{buildroot}%{_bindir}/${i}-qt5
+      ln -sv ${i} ${i}-qt5
+      ;;
+    *)
+      ln -v  ${i} %{buildroot}%{_bindir}/${i}
+      ;;
+  esac
+done
+popd
+
+## .prl/.la file love
+# nuke .prl reference(s) to %%buildroot, excessive (.la-like) libs
+pushd %{buildroot}%{_qt5_libdir}
+for prl_file in libQt5*.prl ; do
+  sed -i -e "/^QMAKE_PRL_BUILD_DIR/d" ${prl_file}
+  rm -fv "$(basename ${prl_file} .prl).la"
+  sed -i -e "/^QMAKE_PRL_LIBS/d" ${prl_file}
+done
+popd
+
+
+%check
+%if 0%{?tests}
+export CTEST_OUTPUT_ON_FAILURE=1
+export PATH=%{buildroot}%{_qt5_bindir}:$PATH
+export LD_LIBRARY_PATH=%{buildroot}%{_qt5_libdir}
+make sub-tests-all %{?_smp_mflags}
+xvfb-run -a \
+dbus-launch --exit-with-session \
+time \
+make check -k -C tests ||:
+%endif
+
+
+%ldconfig_scriptlets
+
+%files
+%license LICENSE.LGPL*
+%{_qt5_libdir}/libQt5Qml.so.5*
+%{_qt5_libdir}/libQt5QmlModels.so.5*
+%{_qt5_libdir}/libQt5QmlWorkerScript.so.5*
+%{_qt5_libdir}/libQt5Quick.so.5*
+%{_qt5_libdir}/libQt5QuickWidgets.so.5*
+%{_qt5_libdir}/libQt5QuickParticles.so.5*
+%{_qt5_libdir}/libQt5QuickShapes.so.5*
+%{_qt5_libdir}/libQt5QuickTest.so.5*
+%{_qt5_plugindir}/qmltooling/
+%{_qt5_archdatadir}/qml/
+
+%files devel
+%{_bindir}/qml*
+%{_qt5_bindir}/qml*
+%{_qt5_headerdir}/Qt*/
+%{_qt5_libdir}/libQt5Qml.so
+%{_qt5_libdir}/libQt5Qml.prl
+%{_qt5_libdir}/libQt5QmlModels.so
+%{_qt5_libdir}/libQt5QmlModels.prl
+%{_qt5_libdir}/libQt5QmlWorkerScript.so
+%{_qt5_libdir}/libQt5QmlWorkerScript.prl
+%{_qt5_libdir}/libQt5Quick*.so
+%{_qt5_libdir}/libQt5Quick*.prl
+%dir %{_qt5_libdir}/cmake/Qt5Quick*/
+%{_qt5_libdir}/cmake/Qt5*/Qt5*Config*.cmake
+%{_qt5_libdir}/metatypes/qt5*_metatypes.json
+%{_qt5_libdir}/pkgconfig/Qt5*.pc
+%{_qt5_archdatadir}/mkspecs/modules/*.pri
+%{_qt5_archdatadir}/mkspecs/features/*.prf
+%dir %{_qt5_libdir}/cmake/Qt5Qml/
+%{_qt5_libdir}/cmake/Qt5Qml/Qt5Qml_*Factory.cmake
+%{_qt5_libdir}/cmake/Qt5QmlImportScanner/
+
+%files static
+%{_qt5_libdir}/libQt5QmlDevTools.a
+%{_qt5_libdir}/libQt5QmlDevTools.prl
+%{_qt5_libdir}/libQt5PacketProtocol.a
+%{_qt5_libdir}/libQt5PacketProtocol.prl
+%{_qt5_libdir}/libQt5QmlDebug.a
+%{_qt5_libdir}/libQt5QmlDebug.prl
+
+%if ! 0%{?no_examples:1}
+%files examples
+%{_qt5_examplesdir}/
+%endif
+
+
+%changelog
+* Wed Jul 27 2022 Chunmei Xu  - 5.15.5-1
+- init from upstream
diff --git a/qtdeclarative-5.15.0-FixMaxXMaxYExtent.patch b/qtdeclarative-5.15.0-FixMaxXMaxYExtent.patch
new file mode 100644
index 0000000000000000000000000000000000000000..e04dd9f201cfe3a1048b9b54250becc443e098d8
--- /dev/null
+++ b/qtdeclarative-5.15.0-FixMaxXMaxYExtent.patch
@@ -0,0 +1,89 @@
+Parent:     f5a4e984 (QQuickTextInputPrivate: refactor getImplicitWidth() to calculateImplicitWidth())
+Author:     David Redondo 
+AuthorDate: 2020-05-13 11:04:23 +0200
+Commit:     Mitch Curtis 
+CommitDate: 2020-05-25 10:58:35 +0200
+
+QQuickItemView: Fix max(X/Y)Extent()
+
+QQuickFlickable maxXExtent() and maxYExtent() return the amount of space
+that is not shown when inside a ScrollView. QQuickItemView however just
+returned width() if vertical and height() if horizontal. In these cases
+just defer to the QQuickFlickable base implementation like minXExtent()
+and minYExtent() already do.
+
+This change also adds tst_qquicklistview2 to speed up development.
+tst_QQuickListView is almost 9000 lines long, and compiling it
+is slow. In addition, a similar approach (creating a second test to
+avoid the slowness of a massive one) already exists for QQuickItem
+tests.
+
+Fixes: QTBUG-83890
+Pick-to: 5.15
+Change-Id: I7f4060c2f46ae07611bedceca0d322c5f7f6affb
+
+diff --git a/src/quick/items/qquickitemview.cpp b/src/quick/items/qquickitemview.cpp
+index 2b4ca9e2..f2feba2a 100644
+--- a/src/quick/items/qquickitemview.cpp
++++ b/src/quick/items/qquickitemview.cpp
+@@ -1393,7 +1393,7 @@ qreal QQuickItemView::maxYExtent() const
+ {
+     Q_D(const QQuickItemView);
+     if (d->layoutOrientation() == Qt::Horizontal)
+-        return height();
++        return QQuickFlickable::maxYExtent();
+
+     if (d->vData.maxExtentDirty) {
+         d->maxExtent = d->maxExtentForAxis(d->vData, false);
+@@ -1421,7 +1421,7 @@ qreal QQuickItemView::maxXExtent() const
+ {
+     Q_D(const QQuickItemView);
+     if (d->layoutOrientation() == Qt::Vertical)
+-        return width();
++        return QQuickFlickable::maxXExtent();
+
+     if (d->hData.maxExtentDirty) {
+         d->maxExtent = d->maxExtentForAxis(d->hData, true);
+diff --git a/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp b/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
+index a7aefbe4..afe5c5ac 100644
+--- a/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
++++ b/tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
+@@ -73,6 +73,8 @@ public:
+     tst_QQuickListView();
+
+ private slots:
++    // WARNING: please add new tests to tst_qquicklistview2; this file is too slow to work with.
++
+     void init();
+     void cleanupTestCase();
+     // Test QAbstractItemModel model types
+@@ -300,6 +302,8 @@ private slots:
+     void clickHeaderAndFooterWhenClip();
+     void animatedDelegate();
+
++    // WARNING: please add new tests to tst_qquicklistview2; this file is too slow to work with.
++
+ private:
+     template  void items(const QUrl &source);
+     template  void changed(const QUrl &source);
+@@ -10109,6 +10113,8 @@ void tst_QQuickListView::animatedDelegate()
+     }
+ }
+
++// WARNING: please add new tests to tst_qquicklistview2; this file is too slow to work with.
++
+ QTEST_MAIN(tst_QQuickListView)
+
+ #include "tst_qquicklistview.moc"
+diff --git a/tests/auto/quick/quick.pro b/tests/auto/quick/quick.pro
+index 45bcf8a9..00f7d64d 100644
+--- a/tests/auto/quick/quick.pro
++++ b/tests/auto/quick/quick.pro
+@@ -67,6 +67,7 @@ QUICKTESTS += \
+     qquickitem2 \
+     qquickitemlayer \
+     qquicklistview \
++    qquicklistview2 \
+     qquicktableview \
+     qquickloader \
+     qquickmousearea \
diff --git a/qtdeclarative-everywhere-opensource-src-5.15.5.tar.xz b/qtdeclarative-everywhere-opensource-src-5.15.5.tar.xz
new file mode 100644
index 0000000000000000000000000000000000000000..9ed43886fae5f96eebb429e562b257f95dae0742
Binary files /dev/null and b/qtdeclarative-everywhere-opensource-src-5.15.5.tar.xz differ