Add files using upload-large-folder tool

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qaccessiblequickitem_p.h

@@ -0,0 +1,118 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QACCESSIBLEQUICKITEM_H
+#define QACCESSIBLEQUICKITEM_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/QQuickItem>
+#include <QtQuick/QQuickView>
+#include <QtGui/qaccessibleobject.h>
+#include <QtQuick/private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#if QT_CONFIG(accessibility)
+
+class QTextDocument;
+
+class Q_QUICK_EXPORT QAccessibleQuickItem : public QAccessibleObject, public QAccessibleActionInterface, public QAccessibleValueInterface, public QAccessibleTextInterface
+{
+public:
+    QAccessibleQuickItem(QQuickItem *item);
+
+    QWindow *window() const override;
+
+    QRect rect() const override;
+    QRect viewRect() const;
+
+    bool clipsChildren() const;
+    QAccessibleInterface *childAt(int x, int y) const override;
+
+    QAccessibleInterface *parent() const override;
+    QAccessibleInterface *child(int index) const override;
+    int childCount() const override;
+    int indexOfChild(const QAccessibleInterface *iface) const override;
+    QList<QQuickItem *> childItems() const;
+
+    QAccessible::State state() const override;
+    QAccessible::Role role() const override;
+    QString text(QAccessible::Text) const override;
+    void setText(QAccessible::Text, const QString &text) override;
+
+    bool isAccessible() const;
+
+    // Action Interface
+    QStringList actionNames() const override;
+    void doAction(const QString &actionName) override;
+    QStringList keyBindingsForAction(const QString &actionName) const override;
+
+    // Value Interface
+    QVariant currentValue() const override;
+    void setCurrentValue(const QVariant &value) override;
+    QVariant maximumValue() const override;
+    QVariant minimumValue() const override;
+    QVariant minimumStepSize() const override;
+
+
+    // Text Interface
+    void selection(int selectionIndex, int *startOffset, int *endOffset) const override;
+    int selectionCount() const override;
+    void addSelection(int startOffset, int endOffset) override;
+    void removeSelection(int selectionIndex) override;
+    void setSelection(int selectionIndex, int startOffset, int endOffset) override;
+
+    // cursor
+    int cursorPosition() const override;
+    void setCursorPosition(int position) override;
+
+    // text
+    QString text(int startOffset, int endOffset) const override;
+    QString textBeforeOffset(int offset, QAccessible::TextBoundaryType boundaryType,
+                                     int *startOffset, int *endOffset) const override;
+    QString textAfterOffset(int offset, QAccessible::TextBoundaryType boundaryType,
+                                    int *startOffset, int *endOffset) const override;
+    QString textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType,
+                                 int *startOffset, int *endOffset) const override;
+    int characterCount() const override;
+
+    // character <-> geometry
+    QRect characterRect(int /* offset */) const override { return QRect(); }
+    int offsetAtPoint(const QPoint & /* point */) const override { return -1; }
+
+    void scrollToSubstring(int /* startIndex */, int /* endIndex */) override {}
+    QString attributes(int /* offset */, int *startOffset, int *endOffset) const override
+    { *startOffset = 0; *endOffset = 0; return QString(); }
+
+    QTextDocument *textDocument() const;
+
+protected:
+    QQuickItem *item() const { return static_cast<QQuickItem*>(object()); }
+    void *interface_cast(QAccessible::InterfaceType t) override;
+
+private:
+    // for Text nodes:
+    QTextDocument *m_doc;
+    typedef QHash<int, QAccessible::Id> ChildCache;
+    mutable ChildCache m_childToId;
+
+};
+
+QRect itemScreenRect(QQuickItem *item);
+QList<QQuickItem *> accessibleUnignoredChildren(QQuickItem *item, bool paintOrder = false);
+
+#endif // accessibility
+
+QT_END_NAMESPACE
+
+#endif // QACCESSIBLEQUICKITEM_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qaccessiblequickview_p.h

@@ -0,0 +1,53 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QAccessibleQuickView_H
+#define QAccessibleQuickView_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qaccessibleobject.h>
+#include <QtQuick/qquickwindow.h>
+#include <QtCore/private/qglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#if QT_CONFIG(accessibility)
+
+class Q_QUICK_EXPORT QAccessibleQuickWindow : public QAccessibleObject
+{
+public:
+    QAccessibleQuickWindow(QQuickWindow *object);
+
+    QAccessibleInterface *parent() const override;
+    QAccessibleInterface *child(int index) const override;
+    QAccessibleInterface *focusChild() const override;
+
+    QAccessible::Role role() const override;
+    QAccessible::State state() const override;
+    QRect rect() const override;
+
+    int childCount() const override;
+    int indexOfChild(const QAccessibleInterface *iface) const override;
+    QString text(QAccessible::Text text) const override;
+    QAccessibleInterface *childAt(int x, int y) const override;
+
+private:
+    QQuickWindow *window() const override { return static_cast<QQuickWindow*>(object()); }
+    QList<QQuickItem *> rootItems() const;
+};
+
+#endif // accessibility
+
+QT_END_NAMESPACE
+
+#endif // QAccessibleQuickView_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qqmldesignermetaobject_p.h

@@ -0,0 +1,74 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef NODEINSTANCEMETAOBJECT_H
+#define NODEINSTANCEMETAOBJECT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QQmlContext>
+#include <QScopedPointer>
+#include <private/qqmlopenmetaobject_p.h>
+#include <private/qqmlvmemetaobject_p.h>
+
+#include <QtCore/qpointer.h>
+
+#include <memory>
+
+QT_BEGIN_NAMESPACE
+
+struct MetaPropertyData;
+
+class QQmlDesignerMetaObject : public QQmlOpenMetaObject
+{
+public:
+    ~QQmlDesignerMetaObject();
+
+    static void registerNotifyPropertyChangeCallBack(void (*callback)(QObject*, const QQuickDesignerSupport::PropertyName &propertyName));
+
+protected:
+    static QQmlDesignerMetaObject* getNodeInstanceMetaObject(QObject *object, QQmlEngine *engine);
+
+    void createNewDynamicProperty(const QString &name);
+    int createProperty(const char *name, const char *passAlong) override;
+    int openMetaCall(QObject *o, QMetaObject::Call _c, int _id, void **_a);
+    int metaCall(QObject *o, QMetaObject::Call _c, int _id, void **_a) override;
+    void notifyPropertyChange(int id);
+    void setValue(int id, const QVariant &value);
+    QVariant propertyWriteValue(int, const QVariant &) override;
+
+    QObject *myObject() const { return object(); }
+
+    QDynamicMetaObjectData *dynamicMetaObjectParent() const;
+
+    int propertyOffset() const;
+
+    int count() const;
+    QByteArray name(int) const;
+
+private:
+    QQmlDesignerMetaObject(QObject *object, QQmlEngine *engine);
+    void init(QObject *);
+
+    QQmlPropertyCache::Ptr cache() const;
+
+    QPointer<QQmlContext> m_context;
+    QScopedPointer<MetaPropertyData> m_data;
+
+    friend class QQuickDesignerSupportProperties;
+};
+
+QT_END_NAMESPACE
+
+#endif // NODEINSTANCEMETAOBJECT_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquadpath_p.h

@@ -0,0 +1,341 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUADPATH_P_H
+#define QQUADPATH_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of a number of Qt sources files.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qrect.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/qvector2d.h>
+#include <QtGui/qpainterpath.h>
+#include <QtQuick/qtquickexports.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuadPath
+{
+public:
+    // This is a copy of the flags in QQuickShapePath ### TODO: use a common definition
+    enum PathHint : quint8 {
+        PathLinear = 0x1,
+        PathQuadratic = 0x2,
+        PathConvex = 0x4,
+        PathFillOnRight = 0x8,
+        PathSolid = 0x10,
+        PathNonIntersecting = 0x20,
+        PathNonOverlappingControlPointTriangles = 0x40
+    };
+    Q_DECLARE_FLAGS(PathHints, PathHint)
+
+    class Q_QUICK_EXPORT Element
+    {
+    public:
+        Element ()
+            : m_isSubpathStart(false), m_isSubpathEnd(false), m_isLine(false)
+        {
+        }
+
+        Element (QVector2D s, QVector2D c, QVector2D e)
+            : sp(s), cp(c), ep(e), m_isSubpathStart(false), m_isSubpathEnd(false), m_isLine(false)
+        {
+        }
+
+        bool isSubpathStart() const
+        {
+            return m_isSubpathStart;
+        }
+
+        bool isSubpathEnd() const
+        {
+            return m_isSubpathEnd;
+        }
+
+        bool isLine() const
+        {
+            return m_isLine;
+        }
+
+        bool isConvex() const
+        {
+            return m_curvatureFlags & Convex;
+        }
+
+        QVector2D startPoint() const
+        {
+            return sp;
+        }
+
+        QVector2D controlPoint() const
+        {
+            return cp;
+        }
+
+        QVector2D endPoint() const
+        {
+            return ep;
+        }
+
+        QVector2D midPoint() const
+        {
+            return isLine() ? 0.5f * (sp + ep) : (0.25f * sp) + (0.5f * cp) + (0.25 * ep);
+        }
+
+        /* For a curve, returns the control point. For a line, returns an arbitrary point on the
+         * inside side of the line (assuming the curvature has been set for the path). The point
+         * doesn't need to actually be inside the shape: it just makes for easier calculations
+         * later when it is at the same side as the fill. */
+        QVector2D referencePoint() const
+        {
+            if (isLine()) {
+                QVector2D normal(sp.y() - ep.y(), ep.x() - sp.x());
+                return m_curvatureFlags & Element::FillOnRight ? sp + normal : sp - normal;
+            } else {
+                return cp;
+            }
+        }
+
+        Element segmentFromTo(float t0, float t1) const;
+
+        Element reversed() const;
+
+        int childCount() const { return m_numChildren; }
+
+        int indexOfChild(int childNumber) const
+        {
+            Q_ASSERT(childNumber >= 0 && childNumber < childCount());
+            return -(m_firstChildIndex + 1 + childNumber);
+        }
+
+        QVector2D pointAtFraction(float t) const;
+
+        QVector2D tangentAtFraction(float t) const
+        {
+            return isLine() ? (ep - sp) : ((1 - t) * 2 * (cp - sp)) + (t * 2 * (ep - cp));
+        }
+
+        QVector2D normalAtFraction(float t) const
+        {
+            const QVector2D tan = tangentAtFraction(t);
+            return QVector2D(-tan.y(), tan.x());
+        }
+
+        float extent() const;
+
+        void setAsConvex(bool isConvex)
+        {
+            if (isConvex)
+                m_curvatureFlags = Element::CurvatureFlags(m_curvatureFlags | Element::Convex);
+            else
+                m_curvatureFlags = Element::CurvatureFlags(m_curvatureFlags & ~Element::Convex);
+        }
+
+        void setFillOnRight(bool isFillOnRight)
+        {
+            if (isFillOnRight)
+                m_curvatureFlags = Element::CurvatureFlags(m_curvatureFlags | Element::FillOnRight);
+            else
+                m_curvatureFlags = Element::CurvatureFlags(m_curvatureFlags & ~Element::FillOnRight);
+        }
+
+        bool isFillOnRight() const { return m_curvatureFlags & FillOnRight; }
+
+        bool isControlPointOnLeft() const
+        {
+            return isPointOnLeft(cp, sp, ep);
+        }
+
+        enum CurvatureFlags : quint8 {
+            CurvatureUndetermined = 0,
+            FillOnRight = 1,
+            Convex = 2
+        };
+
+        enum FillSide : quint8 {
+            FillSideUndetermined = 0,
+            FillSideRight = 1,
+            FillSideLeft = 2,
+            FillSideBoth = 3
+        };
+
+    private:
+        int intersectionsAtY(float y, float *fractions, bool swapXY = false) const;
+
+        QVector2D sp;
+        QVector2D cp;
+        QVector2D ep;
+        int m_firstChildIndex = 0;
+        quint8 m_numChildren = 0;
+        CurvatureFlags m_curvatureFlags = CurvatureUndetermined;
+        quint8 m_isSubpathStart : 1;
+        quint8 m_isSubpathEnd : 1;
+        quint8 m_isLine : 1;
+        friend class QQuadPath;
+        friend Q_QUICK_EXPORT QDebug operator<<(QDebug, const QQuadPath::Element &);
+    };
+
+    void moveTo(const QVector2D &to)
+    {
+        m_subPathToStart = true;
+        m_currentPoint = to;
+    }
+
+    void lineTo(const QVector2D &to)
+    {
+        addElement({}, to, true);
+    }
+
+    void quadTo(const QVector2D &control, const QVector2D &to)
+    {
+        addElement(control, to);
+    }
+
+    Element &elementAt(int i)
+    {
+        return i < 0 ? m_childElements[-(i + 1)] : m_elements[i];
+    }
+
+    const Element &elementAt(int i) const
+    {
+        return i < 0 ? m_childElements[-(i + 1)] : m_elements[i];
+    }
+
+    int indexOfChildAt(int i, int childNumber) const
+    {
+        return elementAt(i).indexOfChild(childNumber);
+    }
+
+    QRectF controlPointRect() const;
+
+    Qt::FillRule fillRule() const { return m_windingFill ? Qt::WindingFill : Qt::OddEvenFill; }
+    void setFillRule(Qt::FillRule rule) { m_windingFill = (rule == Qt::WindingFill); }
+
+    void reserve(int size) { m_elements.reserve(size); }
+    int elementCount() const { return m_elements.size(); }
+    bool isEmpty() const { return m_elements.size() == 0; }
+    int elementCountRecursive() const;
+
+    static QQuadPath fromPainterPath(const QPainterPath &path, PathHints hints = {});
+    QPainterPath toPainterPath() const;
+    QString asSvgString() const;
+
+    QQuadPath subPathsClosed(bool *didClose = nullptr) const;
+    void addCurvatureData();
+    QQuadPath flattened() const;
+    QQuadPath dashed(qreal lineWidth, const QList<qreal> &dashPattern, qreal dashOffset = 0) const;
+    void splitElementAt(int index);
+    bool contains(const QVector2D &point) const;
+    bool contains(const QVector2D &point, int fromIndex, int toIndex) const;
+    Element::FillSide fillSideOf(int elementIdx, float elementT) const;
+
+    template<typename Func>
+    void iterateChildrenOf(Element &e, Func &&lambda)
+    {
+        const int lastChildIndex = e.m_firstChildIndex + e.childCount() - 1;
+        for (int i = e.m_firstChildIndex; i <= lastChildIndex; i++) {
+            Element &c = m_childElements[i];
+            if (c.childCount() > 0)
+                iterateChildrenOf(c, lambda);
+            else
+                lambda(c, -(i + 1));
+        }
+    }
+
+    template<typename Func>
+    void iterateChildrenOf(const Element &e, Func &&lambda) const
+    {
+        const int lastChildIndex = e.m_firstChildIndex + e.childCount() - 1;
+        for (int i = e.m_firstChildIndex; i <= lastChildIndex; i++) {
+            const Element &c = m_childElements[i];
+            if (c.childCount() > 0)
+                iterateChildrenOf(c, lambda);
+            else
+                lambda(c, -(i + 1));
+        }
+    }
+
+    template<typename Func>
+    void iterateElements(Func &&lambda)
+    {
+        for (int i = 0; i < m_elements.size(); i++) {
+            Element &e = m_elements[i];
+            if (e.childCount() > 0)
+                iterateChildrenOf(e, lambda);
+            else
+                lambda(e, i);
+        }
+    }
+
+    template<typename Func>
+    void iterateElements(Func &&lambda) const
+    {
+        for (int i = 0; i < m_elements.size(); i++) {
+            const Element &e = m_elements[i];
+            if (e.childCount() > 0)
+                iterateChildrenOf(e, lambda);
+            else
+                lambda(e, i);
+        }
+    }
+
+    static QVector2D closestPointOnLine(const QVector2D &p, const QVector2D &sp, const QVector2D &ep);
+    static bool isPointOnLeft(const QVector2D &p, const QVector2D &sp, const QVector2D &ep);
+    static bool isPointOnLine(const QVector2D &p, const QVector2D &sp, const QVector2D &ep);
+    static bool isPointNearLine(const QVector2D &p, const QVector2D &sp, const QVector2D &ep);
+
+    bool testHint(PathHint hint) const
+    {
+        return m_hints.testFlag(hint);
+    }
+
+    void setHint(PathHint hint, bool on = true)
+    {
+        m_hints.setFlag(hint, on);
+    }
+
+    PathHints pathHints() const
+    {
+        return m_hints;
+    }
+
+    void setPathHints(PathHints newHints)
+    {
+        m_hints = newHints;
+    }
+
+private:
+    void addElement(const QVector2D &control, const QVector2D &to, bool isLine = false);
+    void addElement(const Element &e);
+    Element::CurvatureFlags coordinateOrderOfElement(const Element &element) const;
+
+    friend Q_QUICK_EXPORT QDebug operator<<(QDebug, const QQuadPath &);
+
+    QList<Element> m_elements;
+    QList<Element> m_childElements;
+    QVector2D m_currentPoint;
+    bool m_subPathToStart = true;
+    bool m_windingFill = false;
+    PathHints m_hints;
+
+    friend class QSGCurveProcessor;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuadPath::PathHints);
+
+Q_QUICK_EXPORT QDebug operator<<(QDebug, const QQuadPath::Element &);
+Q_QUICK_EXPORT QDebug operator<<(QDebug, const QQuadPath &);
+
+QT_END_NAMESPACE
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickabstractpaletteprovider_p.h

@@ -0,0 +1,31 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef QQUICKABSTRACTPALETTEPROVIDER_P_H
+#define QQUICKABSTRACTPALETTEPROVIDER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAbstractPaletteProvider
+{
+public:
+    virtual ~QQuickAbstractPaletteProvider() = default;
+    virtual QPalette defaultPalette() const = 0;
+    virtual QPalette parentPalette(const QPalette &fallbackPalette) const { return fallbackPalette; }
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKABSTRACTPALETTEPROVIDER_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickaccessibleattached_p.h

@@ -0,0 +1,250 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKACCESSIBLEATTACHED_H
+#define QQUICKACCESSIBLEATTACHED_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qquickitem.h>
+
+#include <QtCore/qobject.h>
+#include <QtCore/qstring.h>
+
+#if QT_CONFIG(accessibility)
+
+#include <QtGui/qaccessible.h>
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+
+#define STATE_PROPERTY(P) \
+    Q_PROPERTY(bool P READ P WRITE set_ ## P NOTIFY P ## Changed FINAL) \
+    bool P() const { return m_proxying && !m_stateExplicitlySet.P ? m_proxying->P() : m_state.P ; } \
+    void set_ ## P(bool arg) \
+    { \
+        if (m_proxying) \
+            m_proxying->set_##P(arg);\
+        m_stateExplicitlySet.P = true; \
+        if (m_state.P == arg) \
+            return; \
+        m_state.P = arg; \
+        Q_EMIT P ## Changed(arg); \
+        QAccessible::State changedState; \
+        changedState.P = true; \
+        QAccessibleStateChangeEvent ev(parent(), changedState); \
+        QAccessible::updateAccessibility(&ev); \
+    } \
+    Q_SIGNAL void P ## Changed(bool arg);
+
+class Q_QUICK_EXPORT QQuickAccessibleAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QAccessible::Role role READ role WRITE setRole NOTIFY roleChanged FINAL)
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged FINAL)
+    Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged FINAL)
+    Q_PROPERTY(QString id READ id WRITE setId NOTIFY idChanged REVISION(6, 8) FINAL)
+    Q_PROPERTY(bool ignored READ ignored WRITE setIgnored NOTIFY ignoredChanged FINAL)
+
+    QML_NAMED_ELEMENT(Accessible)
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_UNCREATABLE("Accessible is only available via attached properties.")
+    QML_ATTACHED(QQuickAccessibleAttached)
+    QML_EXTENDED_NAMESPACE(QAccessible)
+
+public:
+    STATE_PROPERTY(checkable)
+    STATE_PROPERTY(checked)
+    STATE_PROPERTY(editable)
+    STATE_PROPERTY(focusable)
+    STATE_PROPERTY(focused)
+    STATE_PROPERTY(multiLine)
+    STATE_PROPERTY(readOnly)
+    STATE_PROPERTY(selected)
+    STATE_PROPERTY(selectable)
+    STATE_PROPERTY(pressed)
+    STATE_PROPERTY(checkStateMixed)
+    STATE_PROPERTY(defaultButton)
+    STATE_PROPERTY(passwordEdit)
+    STATE_PROPERTY(selectableText)
+    STATE_PROPERTY(searchEdit)
+
+    QQuickAccessibleAttached(QObject *parent);
+    ~QQuickAccessibleAttached();
+
+    QAccessible::Role role() const { return m_role; }
+    void setRole(QAccessible::Role role);
+    QString name() const {
+        if (m_state.passwordEdit)
+            return QString();
+        if (!m_nameExplicitlySet && m_proxying && m_proxying->wasNameExplicitlySet())
+            return m_proxying->name();
+        return m_name;
+    }
+
+    bool wasNameExplicitlySet() const;
+    void setName(const QString &name) {
+        m_nameExplicitlySet = true;
+        if (name != m_name) {
+            m_name = name;
+            Q_EMIT nameChanged();
+            QAccessibleEvent ev(parent(), QAccessible::NameChanged);
+            QAccessible::updateAccessibility(&ev);
+        }
+    }
+    void setNameImplicitly(const QString &name);
+
+    QString description() const {
+        return !m_descriptionExplicitlySet && m_proxying ? m_proxying->description() : m_description;
+    }
+    void setDescription(const QString &description)
+    {
+        if (!m_descriptionExplicitlySet && m_proxying) {
+            disconnect(m_proxying, &QQuickAccessibleAttached::descriptionChanged, this, &QQuickAccessibleAttached::descriptionChanged);
+        }
+        m_descriptionExplicitlySet = true;
+        if (m_description != description) {
+            m_description = description;
+            Q_EMIT descriptionChanged();
+            QAccessibleEvent ev(parent(), QAccessible::DescriptionChanged);
+            QAccessible::updateAccessibility(&ev);
+        }
+    }
+
+    QString id() const { return m_id; }
+    void setId(const QString &id)
+    {
+        if (m_id != id) {
+            m_id = id;
+            Q_EMIT idChanged();
+            QAccessibleEvent ev(parent(), QAccessible::IdentifierChanged);
+            QAccessible::updateAccessibility(&ev);
+        }
+    }
+
+    // Factory function
+    static QQuickAccessibleAttached *qmlAttachedProperties(QObject *obj);
+
+    static QQuickAccessibleAttached *attachedProperties(const QObject *obj)
+    {
+        return qobject_cast<QQuickAccessibleAttached*>(qmlAttachedPropertiesObject<QQuickAccessibleAttached>(obj, false));
+    }
+
+    // Property getter
+    static QVariant property(const QObject *object, const char *propertyName)
+    {
+        if (QObject *attachedObject = QQuickAccessibleAttached::attachedProperties(object))
+            return attachedObject->property(propertyName);
+        return QVariant();
+    }
+
+    static bool setProperty(QObject *object, const char *propertyName, const QVariant &value)
+    {
+        QObject *obj = qmlAttachedPropertiesObject<QQuickAccessibleAttached>(object, true);
+        if (!obj) {
+            qWarning("cannot set property Accessible.%s of QObject %s", propertyName, object->metaObject()->className());
+            return false;
+        }
+        return obj->setProperty(propertyName, value);
+    }
+
+    static QObject *findAccessible(QObject *object, QAccessible::Role role = QAccessible::NoRole)
+    {
+        while (object) {
+            QQuickAccessibleAttached *att = QQuickAccessibleAttached::attachedProperties(object);
+            if (att && (role == QAccessible::NoRole || att->role() == role)) {
+                break;
+            }
+            if (auto action = object->property("action").value<QObject *>(); action) {
+                QQuickAccessibleAttached *att = QQuickAccessibleAttached::attachedProperties(action);
+                if (att && (role == QAccessible::NoRole || att->role() == role)) {
+                    object = action;
+                    break;
+                }
+            }
+            object = object->parent();
+        }
+        return object;
+    }
+
+    QAccessible::State state() const { return m_state; }
+    bool ignored() const;
+    bool doAction(const QString &actionName);
+    void availableActions(QStringList *actions) const;
+
+    Q_REVISION(6, 2) Q_INVOKABLE static QString stripHtml(const QString &html);
+    void setProxying(QQuickAccessibleAttached *proxying);
+
+    Q_REVISION(6, 8) Q_INVOKABLE void announce(const QString &message, QAccessible::AnnouncementPoliteness politeness = QAccessible::AnnouncementPoliteness::Polite);
+
+public Q_SLOTS:
+    void valueChanged() {
+        QAccessibleValueChangeEvent ev(parent(), parent()->property("value"));
+        QAccessible::updateAccessibility(&ev);
+    }
+    void cursorPositionChanged() {
+        QAccessibleTextCursorEvent ev(parent(), parent()->property("cursorPosition").toInt());
+        QAccessible::updateAccessibility(&ev);
+    }
+
+    void setIgnored(bool ignored);
+
+Q_SIGNALS:
+    void roleChanged();
+    void nameChanged();
+    void descriptionChanged();
+    void idChanged();
+    void ignoredChanged();
+    void pressAction();
+    void toggleAction();
+    void increaseAction();
+    void decreaseAction();
+    void scrollUpAction();
+    void scrollDownAction();
+    void scrollLeftAction();
+    void scrollRightAction();
+    void previousPageAction();
+    void nextPageAction();
+
+private:
+    QAccessible::Role m_role;
+    QAccessible::State m_state;
+    QAccessible::State m_stateExplicitlySet;
+    QString m_name;
+    bool m_nameExplicitlySet = false;
+    QString m_description;
+    bool m_descriptionExplicitlySet = false;
+    QQuickAccessibleAttached* m_proxying = nullptr;
+    QString m_id;
+
+    static QMetaMethod sigPress;
+    static QMetaMethod sigToggle;
+    static QMetaMethod sigIncrease;
+    static QMetaMethod sigDecrease;
+    static QMetaMethod sigScrollUp;
+    static QMetaMethod sigScrollDown;
+    static QMetaMethod sigScrollLeft;
+    static QMetaMethod sigScrollRight;
+    static QMetaMethod sigPreviousPage;
+    static QMetaMethod sigNextPage;
+
+public:
+    using QObject::property;
+};
+
+
+QT_END_NAMESPACE
+
+#endif // accessibility
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickaccessiblefactory_p.h

@@ -0,0 +1,29 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKACCESSIBLEFACTORY_H
+#define QQUICKACCESSIBLEFACTORY_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qaccessible.h>
+#include <QtCore/private/qglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+#if QT_CONFIG(accessibility)
+
+QAccessibleInterface *qQuickAccessibleFactory(const QString &classname, QObject *object);
+
+#endif
+QT_END_NAMESPACE
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanchors_p.h

@@ -0,0 +1,183 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANCHORS_P_H
+#define QQUICKANCHORS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qqml.h>
+
+#include <QtCore/QObject>
+
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QQuickAnchorsPrivate;
+class QQuickAnchorLine;
+class Q_QUICK_EXPORT QQuickAnchors : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QQuickAnchorLine left READ left WRITE setLeft RESET resetLeft NOTIFY leftChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine right READ right WRITE setRight RESET resetRight NOTIFY rightChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine horizontalCenter READ horizontalCenter WRITE setHorizontalCenter RESET resetHorizontalCenter NOTIFY horizontalCenterChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine top READ top WRITE setTop RESET resetTop NOTIFY topChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine bottom READ bottom WRITE setBottom RESET resetBottom NOTIFY bottomChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine verticalCenter READ verticalCenter WRITE setVerticalCenter RESET resetVerticalCenter NOTIFY verticalCenterChanged FINAL)
+    Q_PROPERTY(QQuickAnchorLine baseline READ baseline WRITE setBaseline RESET resetBaseline NOTIFY baselineChanged FINAL)
+    Q_PROPERTY(qreal margins READ margins WRITE setMargins NOTIFY marginsChanged FINAL)
+    Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin RESET resetLeftMargin NOTIFY leftMarginChanged FINAL)
+    Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin RESET resetRightMargin NOTIFY rightMarginChanged FINAL)
+    Q_PROPERTY(qreal horizontalCenterOffset READ horizontalCenterOffset WRITE setHorizontalCenterOffset NOTIFY horizontalCenterOffsetChanged FINAL)
+    Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin RESET resetTopMargin NOTIFY topMarginChanged FINAL)
+    Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin RESET resetBottomMargin NOTIFY bottomMarginChanged FINAL)
+    Q_PROPERTY(qreal verticalCenterOffset READ verticalCenterOffset WRITE setVerticalCenterOffset NOTIFY verticalCenterOffsetChanged FINAL)
+    Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged FINAL)
+    Q_PROPERTY(QQuickItem *fill READ fill WRITE setFill RESET resetFill NOTIFY fillChanged FINAL)
+    Q_PROPERTY(QQuickItem *centerIn READ centerIn WRITE setCenterIn RESET resetCenterIn NOTIFY centerInChanged FINAL)
+    Q_PROPERTY(bool alignWhenCentered READ alignWhenCentered WRITE setAlignWhenCentered NOTIFY centerAlignedChanged FINAL)
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickAnchors(QQuickItem *item, QObject *parent=nullptr);
+    ~QQuickAnchors() override;
+
+    enum Anchor
+#if defined(Q_CC_CLANG) || !defined(Q_CC_GNU) // meaning: clang and msvc, but NOT gcc proper (because, you know, Q_CC_CLANG implies Q_CC_GNU)
+            // Not specifying the enum base type will have MSVC 'interpret' it as signed instead of an unsigned bit-field.
+            // However, specifying the enum base type breaks many GCCs, which complain that it can't store all values in a 7 bit bitfield.
+            : uint
+#endif
+    {
+        InvalidAnchor = 0x0,
+        LeftAnchor = 0x01,
+        RightAnchor = 0x02,
+        TopAnchor = 0x04,
+        BottomAnchor = 0x08,
+        HCenterAnchor = 0x10,
+        VCenterAnchor = 0x20,
+        BaselineAnchor = 0x40,
+        Horizontal_Mask = LeftAnchor | RightAnchor | HCenterAnchor,
+        Vertical_Mask = TopAnchor | BottomAnchor | VCenterAnchor | BaselineAnchor
+    };
+    Q_DECLARE_FLAGS(Anchors, Anchor)
+    Q_FLAG(Anchors)
+
+    QQuickAnchorLine left() const;
+    void setLeft(const QQuickAnchorLine &edge);
+    void resetLeft();
+
+    QQuickAnchorLine right() const;
+    void setRight(const QQuickAnchorLine &edge);
+    void resetRight();
+
+    QQuickAnchorLine horizontalCenter() const;
+    void setHorizontalCenter(const QQuickAnchorLine &edge);
+    void resetHorizontalCenter();
+
+    QQuickAnchorLine top() const;
+    void setTop(const QQuickAnchorLine &edge);
+    void resetTop();
+
+    QQuickAnchorLine bottom() const;
+    void setBottom(const QQuickAnchorLine &edge);
+    void resetBottom();
+
+    QQuickAnchorLine verticalCenter() const;
+    void setVerticalCenter(const QQuickAnchorLine &edge);
+    void resetVerticalCenter();
+
+    QQuickAnchorLine baseline() const;
+    void setBaseline(const QQuickAnchorLine &edge);
+    void resetBaseline();
+
+    qreal leftMargin() const;
+    void setLeftMargin(qreal);
+    void resetLeftMargin();
+
+    qreal rightMargin() const;
+    void setRightMargin(qreal);
+    void resetRightMargin();
+
+    qreal horizontalCenterOffset() const;
+    void setHorizontalCenterOffset(qreal);
+
+    qreal topMargin() const;
+    void setTopMargin(qreal);
+    void resetTopMargin();
+
+    qreal bottomMargin() const;
+    void setBottomMargin(qreal);
+    void resetBottomMargin();
+
+    qreal margins() const;
+    void setMargins(qreal);
+
+    qreal verticalCenterOffset() const;
+    void setVerticalCenterOffset(qreal);
+
+    qreal baselineOffset() const;
+    void setBaselineOffset(qreal);
+
+    QQuickItem *fill() const;
+    void setFill(QQuickItem *);
+    void resetFill();
+
+    QQuickItem *centerIn() const;
+    void setCenterIn(QQuickItem *);
+    void resetCenterIn();
+
+    Anchors usedAnchors() const;
+    Qt::Orientations activeDirections() const;
+
+    bool mirrored();
+
+    bool alignWhenCentered() const;
+    void setAlignWhenCentered(bool);
+
+    void classBegin();
+    void componentComplete();
+
+Q_SIGNALS:
+    void leftChanged();
+    void rightChanged();
+    void topChanged();
+    void bottomChanged();
+    void verticalCenterChanged();
+    void horizontalCenterChanged();
+    void baselineChanged();
+    void fillChanged();
+    void centerInChanged();
+    void leftMarginChanged();
+    void rightMarginChanged();
+    void topMarginChanged();
+    void bottomMarginChanged();
+    void marginsChanged();
+    void verticalCenterOffsetChanged();
+    void horizontalCenterOffsetChanged();
+    void baselineOffsetChanged();
+    void centerAlignedChanged();
+
+private:
+    friend class QQuickItemPrivate;
+    Q_DISABLE_COPY(QQuickAnchors)
+    Q_DECLARE_PRIVATE(QQuickAnchors)
+};
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickAnchors::Anchors)
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANCHORS_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanchors_p_p.h

@@ -0,0 +1,188 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANCHORS_P_P_H
+#define QQUICKANCHORS_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickanchors_p.h"
+#include "qquickitemchangelistener_p.h"
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickAnchorLine
+{
+    Q_GADGET
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+public:
+    QQuickAnchorLine() {}
+    QQuickAnchorLine(QQuickItem *i, QQuickAnchors::Anchor l) : item(i), anchorLine(l) {}
+    QQuickAnchorLine(QQuickItem *i, uint l)
+        : item(i)
+        , anchorLine(static_cast<QQuickAnchors::Anchor>(l))
+    { Q_ASSERT(l < ((QQuickAnchors::BaselineAnchor << 1) - 1)); }
+
+    QQuickItem *item = nullptr;
+    QQuickAnchors::Anchor anchorLine = QQuickAnchors::InvalidAnchor;
+};
+
+inline bool operator==(const QQuickAnchorLine& a, const QQuickAnchorLine& b)
+{
+    return a.item == b.item && a.anchorLine == b.anchorLine;
+}
+
+class QQuickAnchorsPrivate : public QObjectPrivate, public QQuickItemChangeListener
+{
+    Q_DECLARE_PUBLIC(QQuickAnchors)
+public:
+    QQuickAnchorsPrivate(QQuickItem *i)
+        : leftMargin(0)
+        , rightMargin(0)
+        , topMargin(0)
+        , bottomMargin(0)
+        , margins(0)
+        , vCenterOffset(0)
+        , hCenterOffset(0)
+        , baselineOffset(0)
+        , item(i)
+        , fill(nullptr)
+        , centerIn(nullptr)
+        , leftAnchorItem(nullptr)
+        , rightAnchorItem(nullptr)
+        , topAnchorItem(nullptr)
+        , bottomAnchorItem(nullptr)
+        , vCenterAnchorItem(nullptr)
+        , hCenterAnchorItem(nullptr)
+        , baselineAnchorItem(nullptr)
+        , leftAnchorLine(QQuickAnchors::InvalidAnchor)
+        , leftMarginExplicit(false)
+        , rightAnchorLine(QQuickAnchors::InvalidAnchor)
+        , rightMarginExplicit(false)
+        , topAnchorLine(QQuickAnchors::InvalidAnchor)
+        , topMarginExplicit(false)
+        , bottomAnchorLine(QQuickAnchors::InvalidAnchor)
+        , bottomMarginExplicit(false)
+        , vCenterAnchorLine(QQuickAnchors::InvalidAnchor)
+        , updatingMe(false)
+        , hCenterAnchorLine(QQuickAnchors::InvalidAnchor)
+        , inDestructor(false)
+        , baselineAnchorLine(QQuickAnchors::InvalidAnchor)
+        , centerAligned(true)
+        , usedAnchors(QQuickAnchors::InvalidAnchor)
+        , componentComplete(true)
+        , updatingFill(0)
+        , updatingCenterIn(0)
+        , updatingHorizontalAnchor(0)
+        , updatingVerticalAnchor(0)
+    {
+    }
+
+    void clearItem(QQuickItem *);
+
+    QQuickGeometryChange calculateDependency(QQuickItem *) const;
+    void addDepend(QQuickItem *);
+    void remDepend(QQuickItem *);
+    bool isItemComplete() const;
+
+    void setItemHeight(qreal);
+    void setItemWidth(qreal);
+    void setItemX(qreal);
+    void setItemY(qreal);
+    void setItemPos(const QPointF &);
+    void setItemSize(const QSizeF &);
+
+    void update();
+    void updateOnComplete();
+    void updateMe();
+
+    // QQuickItemGeometryListener interface
+    void itemGeometryChanged(QQuickItem *, QQuickGeometryChange, const QRectF &) override;
+    QQuickAnchorsPrivate *anchorPrivate() override { return this; }
+
+    bool checkHValid() const;
+    bool checkVValid() const;
+    bool checkHAnchorValid(QQuickAnchorLine anchor) const;
+    bool checkVAnchorValid(QQuickAnchorLine anchor) const;
+    bool calcStretch(QQuickItem *edge1Item, QQuickAnchors::Anchor edge1Line,
+                     QQuickItem *edge2Item, QQuickAnchors::Anchor edge2Line,
+                     qreal offset1, qreal offset2, QQuickAnchors::Anchor line, qreal &stretch) const;
+
+    bool isMirrored() const;
+    void updateHorizontalAnchors();
+    void updateVerticalAnchors();
+    void fillChanged();
+    void centerInChanged();
+
+    qreal leftMargin;
+    qreal rightMargin;
+    qreal topMargin;
+    qreal bottomMargin;
+    qreal margins;
+    qreal vCenterOffset;
+    qreal hCenterOffset;
+    qreal baselineOffset;
+
+    QQuickItem *item;
+
+    QQuickItem *fill;
+    QQuickItem *centerIn;
+
+    QQuickItem *leftAnchorItem;
+    QQuickItem *rightAnchorItem;
+    QQuickItem *topAnchorItem;
+    QQuickItem *bottomAnchorItem;
+    QQuickItem *vCenterAnchorItem;
+    QQuickItem *hCenterAnchorItem;
+    QQuickItem *baselineAnchorItem;
+
+    // The bit fields below are carefully laid out in chunks of 1 byte, so the compiler doesn't
+    // need to generate 2 loads (and combining shifts/ors) to create a single field.
+
+    QQuickAnchors::Anchor leftAnchorLine     : 7;
+    uint leftMarginExplicit                  : 1;
+    QQuickAnchors::Anchor rightAnchorLine    : 7;
+    uint rightMarginExplicit                 : 1;
+    QQuickAnchors::Anchor topAnchorLine      : 7;
+    uint topMarginExplicit                   : 1;
+    QQuickAnchors::Anchor bottomAnchorLine   : 7;
+    uint bottomMarginExplicit                : 1;
+
+    QQuickAnchors::Anchor vCenterAnchorLine  : 7;
+    uint updatingMe                          : 1;
+    QQuickAnchors::Anchor hCenterAnchorLine  : 7;
+    uint inDestructor                        : 1;
+    QQuickAnchors::Anchor baselineAnchorLine : 7;
+    uint centerAligned                       : 1;
+    uint usedAnchors                         : 7; // QQuickAnchors::Anchors
+    uint componentComplete                   : 1;
+
+    // Instead of using a mostly empty bit field, we can stretch the following fields up to be full
+    // bytes. The advantage is that incrementing/decrementing does not need any combining ands/ors.
+    qint8 updatingFill;
+    qint8 updatingCenterIn;
+    qint8 updatingHorizontalAnchor;
+    qint8 updatingVerticalAnchor;
+
+
+    static inline QQuickAnchorsPrivate *get(QQuickAnchors *o) {
+        return static_cast<QQuickAnchorsPrivate *>(QObjectPrivate::get(o));
+    }
+};
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QQuickAnchorLine)
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatedimage_p.h

@@ -0,0 +1,88 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATEDIMAGE_P_H
+#define QQUICKANIMATEDIMAGE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_animatedimage);
+
+#include "qquickimage_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QMovie;
+class QQuickAnimatedImagePrivate;
+
+class Q_QUICK_EXPORT QQuickAnimatedImage : public QQuickImage
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool playing READ isPlaying WRITE setPlaying NOTIFY playingChanged)
+    Q_PROPERTY(bool paused READ isPaused WRITE setPaused NOTIFY pausedChanged)
+    Q_PROPERTY(int currentFrame READ currentFrame WRITE setCurrentFrame NOTIFY frameChanged)
+    Q_PROPERTY(int frameCount READ frameCount NOTIFY frameCountChanged)
+    Q_PROPERTY(qreal speed READ speed WRITE setSpeed NOTIFY speedChanged REVISION(2, 11))
+
+    QML_NAMED_ELEMENT(AnimatedImage)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickAnimatedImage(QQuickItem *parent=nullptr);
+    ~QQuickAnimatedImage();
+
+    bool isPlaying() const;
+    void setPlaying(bool play);
+
+    bool isPaused() const;
+    void setPaused(bool pause);
+
+    int currentFrame() const override;
+    void setCurrentFrame(int frame) override;
+
+    int frameCount() const override;
+
+    qreal speed() const;
+    void setSpeed(qreal speed);
+
+    // Extends QQuickImage's src property
+    void setSource(const QUrl&) override;
+
+Q_SIGNALS:
+    void playingChanged();
+    void pausedChanged();
+    void frameChanged();
+    void currentFrameChanged();
+    void frameCountChanged();
+    Q_REVISION(2, 11) void speedChanged();
+
+private Q_SLOTS:
+    void movieUpdate();
+    void movieRequestFinished();
+    void playingStatusChanged();
+    void onCacheChanged();
+
+protected:
+    void load() override;
+    void componentComplete() override;
+
+private:
+    Q_DISABLE_COPY(QQuickAnimatedImage)
+    Q_DECLARE_PRIVATE(QQuickAnimatedImage)
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATEDIMAGE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatedimage_p_p.h

@@ -0,0 +1,61 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATEDIMAGE_P_P_H
+#define QQUICKANIMATEDIMAGE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qtquickglobal.h>
+
+QT_REQUIRE_CONFIG(quick_animatedimage);
+
+#include "qquickimage_p_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QMovie;
+#if QT_CONFIG(qml_network)
+class QNetworkReply;
+#endif
+
+class QQuickAnimatedImagePrivate : public QQuickImagePrivate
+{
+    Q_DECLARE_PUBLIC(QQuickAnimatedImage)
+
+public:
+    QQuickAnimatedImagePrivate()
+      : playing(true), paused(false), oldPlaying(false)
+    {
+    }
+
+    QQuickPixmap *infoForCurrentFrame(QQmlEngine *engine);
+    void setMovie(QMovie *movie);
+    void clearCache();
+
+    qreal speed = 1;
+    QMovie *movie = nullptr;
+    int presetCurrentFrame = 0;
+    QMap<int, QQuickPixmap *> frameMap;
+
+#if QT_CONFIG(qml_network)
+    QNetworkReply *reply = nullptr;
+#endif
+
+    bool playing : 1;
+    bool paused : 1;
+    bool oldPlaying : 1;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATEDIMAGE_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatedsprite_p.h

@@ -0,0 +1,165 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATEDSPRITE_P_H
+#define QQUICKANIMATEDSPRITE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_sprite);
+
+#include <QtQuick/QQuickItem>
+#include <private/qquicksprite_p.h>
+#include <QtCore/qelapsedtimer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSGContext;
+class QQuickSprite;
+class QQuickSpriteEngine;
+class QSGGeometryNode;
+class QQuickAnimatedSpritePrivate;
+class QSGSpriteNode;
+class Q_QUICK_EXPORT QQuickAnimatedSprite : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
+    Q_PROPERTY(bool interpolate READ interpolate WRITE setInterpolate NOTIFY interpolateChanged)
+    //###try to share similar spriteEngines for less overhead?
+    //These properties come out of QQuickSprite, since an AnimatedSprite is a renderer for a single sprite
+    Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
+    Q_PROPERTY(bool reverse READ reverse WRITE setReverse NOTIFY reverseChanged)
+    Q_PROPERTY(bool frameSync READ frameSync WRITE setFrameSync NOTIFY frameSyncChanged)
+    Q_PROPERTY(int frameCount READ frameCount WRITE setFrameCount NOTIFY frameCountChanged)
+    //If frame height or width is not specified, it is assumed to be a single long row of square frames.
+    //Otherwise, it can be multiple contiguous rows, when one row runs out the next will be used.
+    Q_PROPERTY(int frameHeight READ frameHeight WRITE setFrameHeight NOTIFY frameHeightChanged)
+    Q_PROPERTY(int frameWidth READ frameWidth WRITE setFrameWidth NOTIFY frameWidthChanged)
+    Q_PROPERTY(int frameX READ frameX WRITE setFrameX NOTIFY frameXChanged)
+    Q_PROPERTY(int frameY READ frameY WRITE setFrameY NOTIFY frameYChanged)
+    //Precedence order: frameRate, frameDuration
+    Q_PROPERTY(qreal frameRate READ frameRate WRITE setFrameRate NOTIFY frameRateChanged RESET resetFrameRate)
+    Q_PROPERTY(int frameDuration READ frameDuration WRITE setFrameDuration NOTIFY frameDurationChanged RESET resetFrameDuration)
+    //Extra Simple Sprite Stuff
+    Q_PROPERTY(int loops READ loops WRITE setLoops NOTIFY loopsChanged)
+    Q_PROPERTY(bool paused READ paused WRITE setPaused NOTIFY pausedChanged)
+    Q_PROPERTY(int currentFrame READ currentFrame WRITE setCurrentFrame NOTIFY currentFrameChanged)
+    Q_PROPERTY(FinishBehavior finishBehavior READ finishBehavior WRITE setFinishBehavior NOTIFY finishBehaviorChanged REVISION(2, 15))
+    QML_NAMED_ELEMENT(AnimatedSprite)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    explicit QQuickAnimatedSprite(QQuickItem *parent = nullptr);
+    enum LoopParameters {
+        Infinite = -1
+    };
+    Q_ENUM(LoopParameters)
+
+    enum FinishBehavior {
+        FinishAtInitialFrame,
+        FinishAtFinalFrame
+    };
+    Q_ENUM(FinishBehavior)
+
+    bool running() const;
+    bool interpolate() const;
+    QUrl source() const;
+    bool reverse() const;
+    bool frameSync() const;
+    int frameCount() const;
+    int frameHeight() const;
+    int frameWidth() const;
+    int frameX() const;
+    int frameY() const;
+    qreal frameRate() const;
+    int frameDuration() const;
+    int loops() const;
+    bool paused() const;
+    int currentFrame() const;
+    FinishBehavior finishBehavior() const;
+    void setFinishBehavior(FinishBehavior arg);
+
+Q_SIGNALS:
+
+    void pausedChanged(bool arg);
+    void runningChanged(bool arg);
+    void interpolateChanged(bool arg);
+
+    void sourceChanged(const QUrl &arg);
+    void reverseChanged(bool arg);
+    void frameSyncChanged(bool arg);
+    void frameCountChanged(int arg);
+    void frameHeightChanged(int arg);
+    void frameWidthChanged(int arg);
+    void frameXChanged(int arg);
+    void frameYChanged(int arg);
+    void frameRateChanged(qreal arg);
+    void frameDurationChanged(int arg);
+    void loopsChanged(int arg);
+    void currentFrameChanged(int arg);
+    Q_REVISION(2, 15) void finishBehaviorChanged(FinishBehavior arg);
+
+    Q_REVISION(2, 12) void finished();
+
+public Q_SLOTS:
+    void start();
+    void stop();
+    void restart() {stop(); start();}
+    void advance(int frames=1);
+    void pause();
+    void resume();
+
+    void setRunning(bool arg);
+    void setPaused(bool arg);
+    void setInterpolate(bool arg);
+    void setSource(const QUrl &arg);
+    void setReverse(bool arg);
+    void setFrameSync(bool arg);
+    void setFrameCount(int arg);
+    void setFrameHeight(int arg);
+    void setFrameWidth(int arg);
+    void setFrameX(int arg);
+    void setFrameY(int arg);
+    void setFrameRate(qreal arg);
+    void setFrameDuration(int arg);
+    void resetFrameRate();
+    void resetFrameDuration();
+    void setLoops(int arg);
+    void setCurrentFrame(int arg);
+
+private Q_SLOTS:
+    void createEngine();
+
+protected Q_SLOTS:
+    void reset();
+
+protected:
+    void componentComplete() override;
+    QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;
+    void itemChange(ItemChange, const ItemChangeData &) override;
+
+private:
+    void maybeUpdate();
+    bool isCurrentFrameChangedConnected();
+    void prepareNextFrame(QSGSpriteNode *node);
+    void reloadImage();
+    QSGSpriteNode* initNode();
+
+private:
+    Q_DECLARE_PRIVATE(QQuickAnimatedSprite)
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATEDSPRITE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatedsprite_p_p.h

@@ -0,0 +1,65 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATEDSPRITE_P_P_H
+#define QQUICKANIMATEDSPRITE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qtquickglobal.h>
+
+QT_REQUIRE_CONFIG(quick_sprite);
+
+#include "qquickitem_p.h"
+#include "qquicksprite_p.h"
+#include "qquickanimatedsprite_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAnimatedSpritePrivate : public QQuickItemPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickAnimatedSprite)
+
+public:
+    QQuickAnimatedSpritePrivate()
+        : m_sprite(nullptr)
+        , m_spriteEngine(nullptr)
+        , m_curFrame(0)
+        , m_pleaseReset(false)
+        , m_running(true)
+        , m_paused(false)
+        , m_interpolate(true)
+        , m_loops(-1)
+        , m_curLoop(0)
+        , m_pauseOffset(0)
+        , m_finishBehavior(QQuickAnimatedSprite::FinishAtInitialFrame)
+    {
+    }
+
+    QQuickSprite* m_sprite;
+    QQuickSpriteEngine* m_spriteEngine;
+    QElapsedTimer m_timestamp;
+    int m_curFrame;
+    bool m_pleaseReset;
+    bool m_running;
+    bool m_paused;
+    bool m_interpolate;
+    QSize m_sheetSize;
+    int m_loops;
+    int m_curLoop;
+    int m_pauseOffset;
+    QQuickAnimatedSprite::FinishBehavior m_finishBehavior;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATEDSPRITE_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimation_p.h

@@ -0,0 +1,455 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATION_H
+#define QQUICKANIMATION_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickstate_p.h"
+#include <QtGui/qvector3d.h>
+
+#include <qqmlpropertyvaluesource.h>
+#include <qqml.h>
+#include <qqmlscriptstring.h>
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qeasingcurve.h>
+#include "private/qabstractanimationjob_p.h"
+#include <QtGui/qcolor.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAbstractAnimationPrivate;
+class QQuickAnimationGroup;
+class Q_QUICK_EXPORT QQuickAbstractAnimation : public QObject, public QQmlPropertyValueSource, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickAbstractAnimation)
+
+    Q_INTERFACES(QQmlParserStatus)
+    Q_INTERFACES(QQmlPropertyValueSource)
+    Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY runningChanged)
+    Q_PROPERTY(bool paused READ isPaused WRITE setPaused NOTIFY pausedChanged)
+    Q_PROPERTY(bool alwaysRunToEnd READ alwaysRunToEnd WRITE setAlwaysRunToEnd NOTIFY alwaysRunToEndChanged)
+    Q_PROPERTY(int loops READ loops WRITE setLoops NOTIFY loopCountChanged)
+    Q_CLASSINFO("DefaultMethod", "start()")
+
+    QML_NAMED_ELEMENT(Animation)
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_UNCREATABLE("Animation is an abstract class")
+
+public:
+    enum ThreadingModel  {
+        GuiThread,
+        RenderThread,
+        AnyThread
+    };
+
+    QQuickAbstractAnimation(QObject *parent=nullptr);
+    ~QQuickAbstractAnimation() override;
+
+    enum Loops { Infinite = -2 };
+    Q_ENUM(Loops)
+
+    bool isRunning() const;
+    void setRunning(bool);
+    bool isPaused() const;
+    void setPaused(bool);
+    bool alwaysRunToEnd() const;
+    void setAlwaysRunToEnd(bool);
+
+    int loops() const;
+    void setLoops(int);
+    int duration() const;
+
+    int currentTime();
+    void setCurrentTime(int);
+
+    QQuickAnimationGroup *group() const;
+    void setGroup(QQuickAnimationGroup *, int index = -1);
+
+    void setDefaultTarget(const QQmlProperty &);
+    void setDisableUserControl();
+    void setEnableUserControl();
+    bool userControlDisabled() const;
+    void classBegin() override;
+    void componentComplete() override;
+
+    virtual ThreadingModel threadingModel() const;
+
+Q_SIGNALS:
+    void started();
+    void stopped();
+    void runningChanged(bool);
+    void pausedChanged(bool);
+    void alwaysRunToEndChanged(bool);
+    void loopCountChanged(int);
+    Q_REVISION(2, 12) void finished();
+
+public Q_SLOTS:
+    void restart();
+    void start();
+    void pause();
+    void resume();
+    void stop();
+    void complete();
+
+protected:
+    QQuickAbstractAnimation(QQuickAbstractAnimationPrivate &dd, QObject *parent);
+    QAbstractAnimationJob* initInstance(QAbstractAnimationJob *animation);
+
+public:
+    enum TransitionDirection { Forward, Backward };
+    virtual QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr);
+    QAbstractAnimationJob* qtAnimation();
+
+private:
+    void setTarget(const QQmlProperty &) override;
+    void notifyRunningChanged(bool running);
+    friend class QQuickBehavior;
+    friend class QQuickBehaviorPrivate;
+    friend class QQuickAnimationGroup;
+};
+
+class QQuickPauseAnimationPrivate;
+class Q_QUICK_EXPORT QQuickPauseAnimation : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPauseAnimation)
+
+    Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
+    QML_NAMED_ELEMENT(PauseAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickPauseAnimation(QObject *parent=nullptr);
+    ~QQuickPauseAnimation() override;
+
+    int duration() const;
+    void setDuration(int);
+
+Q_SIGNALS:
+    void durationChanged(int);
+
+protected:
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                                          QQmlProperties &modified,
+                                          TransitionDirection direction,
+                                          QObject *defaultTarget = nullptr) override;
+};
+
+class QQuickScriptActionPrivate;
+class Q_QUICK_EXPORT QQuickScriptAction : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickScriptAction)
+
+    Q_PROPERTY(QQmlScriptString script READ script WRITE setScript)
+    Q_PROPERTY(QString scriptName READ stateChangeScriptName WRITE setStateChangeScriptName)
+    QML_NAMED_ELEMENT(ScriptAction)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickScriptAction(QObject *parent=nullptr);
+    ~QQuickScriptAction() override;
+
+    QQmlScriptString script() const;
+    void setScript(const QQmlScriptString &);
+
+    QString stateChangeScriptName() const;
+    void setStateChangeScriptName(const QString &);
+
+protected:
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr) override;
+};
+
+class QQuickPropertyActionPrivate;
+class Q_QUICK_EXPORT QQuickPropertyAction : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPropertyAction)
+
+    Q_PROPERTY(QObject *target READ target WRITE setTargetObject NOTIFY targetChanged)
+    Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY propertyChanged)
+    Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
+    Q_PROPERTY(QQmlListProperty<QObject> targets READ targets)
+    Q_PROPERTY(QQmlListProperty<QObject> exclude READ exclude)
+    Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
+    QML_NAMED_ELEMENT(PropertyAction)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickPropertyAction(QObject *parent=nullptr);
+    ~QQuickPropertyAction() override;
+
+    QObject *target() const;
+    void setTargetObject(QObject *);
+
+    QString property() const;
+    void setProperty(const QString &);
+
+    QString properties() const;
+    void setProperties(const QString &);
+
+    QQmlListProperty<QObject> targets();
+    QQmlListProperty<QObject> exclude();
+
+    QVariant value() const;
+    void setValue(const QVariant &);
+
+Q_SIGNALS:
+    void valueChanged(const QVariant &);
+    void propertiesChanged(const QString &);
+    void targetChanged();
+    void propertyChanged();
+
+protected:
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr) override;
+};
+
+class QQuickPropertyAnimationPrivate;
+class Q_QUICK_EXPORT QQuickPropertyAnimation : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
+
+    Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
+    Q_PROPERTY(QVariant from READ from WRITE setFrom NOTIFY fromChanged)
+    Q_PROPERTY(QVariant to READ to WRITE setTo NOTIFY toChanged)
+    Q_PROPERTY(QEasingCurve easing READ easing WRITE setEasing NOTIFY easingChanged)
+    Q_PROPERTY(QObject *target READ target WRITE setTargetObject NOTIFY targetChanged)
+    Q_PROPERTY(QString property READ property WRITE setProperty NOTIFY propertyChanged)
+    Q_PROPERTY(QString properties READ properties WRITE setProperties NOTIFY propertiesChanged)
+    Q_PROPERTY(QQmlListProperty<QObject> targets READ targets)
+    Q_PROPERTY(QQmlListProperty<QObject> exclude READ exclude)
+    QML_NAMED_ELEMENT(PropertyAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickPropertyAnimation(QObject *parent=nullptr);
+    ~QQuickPropertyAnimation() override;
+
+    virtual int duration() const;
+    virtual void setDuration(int);
+
+    QVariant from() const;
+    void setFrom(const QVariant &);
+
+    QVariant to() const;
+    void setTo(const QVariant &);
+
+    QEasingCurve easing() const;
+    void setEasing(const QEasingCurve &);
+
+    QObject *target() const;
+    void setTargetObject(QObject *);
+
+    QString property() const;
+    void setProperty(const QString &);
+
+    QString properties() const;
+    void setProperties(const QString &);
+
+    QQmlListProperty<QObject> targets();
+    QQmlListProperty<QObject> exclude();
+
+protected:
+    QQuickStateActions createTransitionActions(QQuickStateActions &actions,
+                                                     QQmlProperties &modified,
+                                                     QObject *defaultTarget = nullptr);
+
+    QQuickPropertyAnimation(QQuickPropertyAnimationPrivate &dd, QObject *parent);
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr) override;
+Q_SIGNALS:
+    void durationChanged(int);
+    void fromChanged();
+    void toChanged();
+    void easingChanged(const QEasingCurve &);
+    void propertiesChanged(const QString &);
+    void targetChanged();
+    void propertyChanged();
+};
+
+class Q_QUICK_EXPORT QQuickColorAnimation : public QQuickPropertyAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
+    Q_PROPERTY(QColor from READ from WRITE setFrom)
+    Q_PROPERTY(QColor to READ to WRITE setTo)
+    QML_NAMED_ELEMENT(ColorAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickColorAnimation(QObject *parent=nullptr);
+    ~QQuickColorAnimation() override;
+
+    QColor from() const;
+    void setFrom(const QColor &);
+
+    QColor to() const;
+    void setTo(const QColor &);
+};
+
+class Q_QUICK_EXPORT QQuickNumberAnimation : public QQuickPropertyAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
+
+    Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged)
+    Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged)
+    QML_NAMED_ELEMENT(NumberAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickNumberAnimation(QObject *parent=nullptr);
+    ~QQuickNumberAnimation() override;
+
+    qreal from() const;
+    void setFrom(qreal);
+
+    qreal to() const;
+    void setTo(qreal);
+
+protected:
+    QQuickNumberAnimation(QQuickPropertyAnimationPrivate &dd, QObject *parent);
+
+private:
+    void init();
+};
+
+class Q_QUICK_EXPORT QQuickVector3dAnimation : public QQuickPropertyAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickPropertyAnimation)
+
+    Q_PROPERTY(QVector3D from READ from WRITE setFrom NOTIFY fromChanged)
+    Q_PROPERTY(QVector3D to READ to WRITE setTo NOTIFY toChanged)
+    QML_NAMED_ELEMENT(Vector3dAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickVector3dAnimation(QObject *parent=nullptr);
+    ~QQuickVector3dAnimation() override;
+
+    QVector3D from() const;
+    void setFrom(QVector3D);
+
+    QVector3D to() const;
+    void setTo(QVector3D);
+};
+
+class QQuickRotationAnimationPrivate;
+class Q_QUICK_EXPORT QQuickRotationAnimation : public QQuickPropertyAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickRotationAnimation)
+
+    Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged)
+    Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged)
+    Q_PROPERTY(RotationDirection direction READ direction WRITE setDirection NOTIFY directionChanged)
+    QML_NAMED_ELEMENT(RotationAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickRotationAnimation(QObject *parent=nullptr);
+    ~QQuickRotationAnimation() override;
+
+    qreal from() const;
+    void setFrom(qreal);
+
+    qreal to() const;
+    void setTo(qreal);
+
+    enum RotationDirection { Numerical, Shortest, Clockwise, Counterclockwise };
+    Q_ENUM(RotationDirection)
+    RotationDirection direction() const;
+    void setDirection(RotationDirection direction);
+
+Q_SIGNALS:
+    void directionChanged();
+};
+
+class QQuickAnimationGroupPrivate;
+class Q_QUICK_EXPORT QQuickAnimationGroup : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickAnimationGroup)
+
+    Q_CLASSINFO("DefaultProperty", "animations")
+    Q_PROPERTY(QQmlListProperty<QQuickAbstractAnimation> animations READ animations)
+
+public:
+    QQuickAnimationGroup(QObject *parent);
+    ~QQuickAnimationGroup() override;
+
+    QQmlListProperty<QQuickAbstractAnimation> animations();
+    friend class QQuickAbstractAnimation;
+
+protected:
+    QQuickAnimationGroup(QQuickAnimationGroupPrivate &dd, QObject *parent);
+};
+
+class Q_QUICK_EXPORT QQuickSequentialAnimation : public QQuickAnimationGroup
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickAnimationGroup)
+    QML_NAMED_ELEMENT(SequentialAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickSequentialAnimation(QObject *parent=nullptr);
+    ~QQuickSequentialAnimation() override;
+
+protected:
+    ThreadingModel threadingModel() const override;
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr) override;
+};
+
+class Q_QUICK_EXPORT QQuickParallelAnimation : public QQuickAnimationGroup
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickAnimationGroup)
+    QML_NAMED_ELEMENT(ParallelAnimation)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickParallelAnimation(QObject *parent=nullptr);
+    ~QQuickParallelAnimation() override;
+
+protected:
+    ThreadingModel threadingModel() const override;
+    QAbstractAnimationJob* transition(QQuickStateActions &actions,
+                            QQmlProperties &modified,
+                            TransitionDirection direction,
+                            QObject *defaultTarget = nullptr) override;
+};
+
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATION_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimation_p_p.h

@@ -0,0 +1,304 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATION2_P_H
+#define QQUICKANIMATION2_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickanimation_p.h"
+
+#include <private/qqmlnullablevalue_p.h>
+
+#include <qqml.h>
+#include <qqmlcontext.h>
+
+#include <private/qvariantanimation_p.h>
+#include "private/qpauseanimationjob_p.h"
+#include <QDebug>
+
+#include <private/qobject_p.h>
+#include "private/qanimationgroupjob_p.h"
+#include <QDebug>
+
+#include <private/qobject_p.h>
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+//interface for classes that provide animation actions for QActionAnimation
+class QAbstractAnimationAction
+{
+public:
+    virtual ~QAbstractAnimationAction() {}
+    virtual void doAction() = 0;
+    virtual void debugAction(QDebug, int) const {}
+};
+
+//templated animation action
+//allows us to specify an action that calls a function of a class.
+//(so that class doesn't have to inherit QQuickAbstractAnimationAction)
+template<class T, void (T::*method)(), void (T::*debugMethod)(QDebug, int) const>
+class QAnimationActionProxy : public QAbstractAnimationAction
+{
+public:
+    QAnimationActionProxy(T *instance) : m_instance(instance) {}
+    void doAction() override { (m_instance->*method)(); }
+    void debugAction(QDebug d, int indentLevel) const override { (m_instance->*debugMethod)(d, indentLevel); }
+private:
+    T *m_instance;
+};
+
+//performs an action of type QAbstractAnimationAction
+class Q_AUTOTEST_EXPORT QActionAnimation : public QAbstractAnimationJob
+{
+    Q_DISABLE_COPY(QActionAnimation)
+public:
+    QActionAnimation();
+
+    QActionAnimation(QAbstractAnimationAction *action);
+    ~QActionAnimation() override;
+
+    int duration() const override;
+    void setAnimAction(QAbstractAnimationAction *action);
+
+protected:
+    void updateCurrentTime(int) override;
+    void updateState(State newState, State oldState) override;
+    void debugAnimation(QDebug d) const override;
+
+private:
+    QAbstractAnimationAction *animAction;
+};
+
+class QQuickBulkValueUpdater
+{
+public:
+    virtual ~QQuickBulkValueUpdater() {}
+    virtual void setValue(qreal value) = 0;
+    virtual void debugUpdater(QDebug, int) const {}
+};
+
+//animates QQuickBulkValueUpdater (assumes start and end values will be reals or compatible)
+class Q_QUICK_AUTOTEST_EXPORT QQuickBulkValueAnimator : public QAbstractAnimationJob
+{
+    Q_DISABLE_COPY(QQuickBulkValueAnimator)
+public:
+    QQuickBulkValueAnimator();
+    ~QQuickBulkValueAnimator() override;
+
+    void setAnimValue(QQuickBulkValueUpdater *value);
+    QQuickBulkValueUpdater *getAnimValue() const { return animValue; }
+
+    void setFromIsSourcedValue(bool *value) { fromIsSourced = value; }
+
+    int duration() const override { return m_duration; }
+    void setDuration(int msecs) { m_duration = msecs; }
+
+    QEasingCurve easingCurve() const { return easing; }
+    void setEasingCurve(const QEasingCurve &curve) { easing = curve; }
+
+protected:
+    void updateCurrentTime(int currentTime) override;
+    void topLevelAnimationLoopChanged() override;
+    void debugAnimation(QDebug d) const override;
+
+private:
+    QQuickBulkValueUpdater *animValue;
+    bool *fromIsSourced;
+    int m_duration;
+    QEasingCurve easing;
+};
+
+//an animation that just gives a tick
+template<class T, void (T::*method)(int)>
+class QTickAnimationProxy : public QAbstractAnimationJob
+{
+    Q_DISABLE_COPY(QTickAnimationProxy)
+public:
+    QTickAnimationProxy(T *instance) : QAbstractAnimationJob(), m_instance(instance) {}
+    int duration() const override { return -1; }
+protected:
+    void updateCurrentTime(int msec) override { (m_instance->*method)(msec); }
+
+private:
+    T *m_instance;
+};
+
+class Q_QUICK_EXPORT QQuickAbstractAnimationPrivate : public QObjectPrivate, public QAnimationJobChangeListener
+{
+    Q_DECLARE_PUBLIC(QQuickAbstractAnimation)
+public:
+    QQuickAbstractAnimationPrivate()
+    : running(false), paused(false), alwaysRunToEnd(false),
+      /*connectedTimeLine(false), */componentComplete(true),
+      avoidPropertyValueSourceStart(false), disableUserControl(false),
+      needsDeferredSetRunning(false), loopCount(1), group(nullptr), animationInstance(nullptr) {}
+
+    bool running:1;
+    bool paused:1;
+    bool alwaysRunToEnd:1;
+    //bool connectedTimeLine:1;
+    bool componentComplete:1;
+    bool avoidPropertyValueSourceStart:1;
+    bool disableUserControl:1;
+    bool needsDeferredSetRunning:1;
+
+    int loopCount;
+
+    void commence();
+    void animationFinished(QAbstractAnimationJob *) override;
+
+    QQmlProperty defaultProperty;
+
+    QQuickAnimationGroup *group;
+    QAbstractAnimationJob* animationInstance;
+
+    static QQmlProperty createProperty(QObject *obj, const QString &str, QObject *infoObj, QString *errorMessage = nullptr);
+    void animationGroupDirty();
+};
+
+class QQuickPauseAnimationPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickPauseAnimation)
+public:
+    QQuickPauseAnimationPrivate()
+        : QQuickAbstractAnimationPrivate(), duration(250) {}
+
+    int duration;
+};
+
+class QQuickScriptActionPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickScriptAction)
+public:
+    QQuickScriptActionPrivate();
+
+    QQmlScriptString script;
+    QString name;
+    QQmlScriptString runScriptScript;
+    bool hasRunScriptScript;
+    bool reversing;
+
+    void execute();
+    QAbstractAnimationAction* createAction();
+    void debugAction(QDebug d, int indentLevel) const;
+    typedef QAnimationActionProxy<QQuickScriptActionPrivate,
+                                 &QQuickScriptActionPrivate::execute,
+                                 &QQuickScriptActionPrivate::debugAction> Proxy;
+};
+
+class QQuickPropertyActionPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickPropertyAction)
+public:
+    QQuickPropertyActionPrivate()
+    : QQuickAbstractAnimationPrivate(), target(nullptr) {}
+
+    QObject *target;
+    QString propertyName;
+    QString properties;
+    QList<QObject *> targets;
+    QList<QObject *> exclude;
+
+    QQmlNullableValue<QVariant> value;
+};
+
+class QQuickAnimationGroupPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickAnimationGroup)
+public:
+    QQuickAnimationGroupPrivate()
+    : QQuickAbstractAnimationPrivate(), animationDirty(false) {}
+
+    static void append_animation(QQmlListProperty<QQuickAbstractAnimation> *list, QQuickAbstractAnimation *role);
+    static QQuickAbstractAnimation *at_animation(QQmlListProperty<QQuickAbstractAnimation> *list, qsizetype index);
+    static qsizetype count_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
+    static void clear_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
+    static void replace_animation(QQmlListProperty<QQuickAbstractAnimation> *list, qsizetype index,
+                                  QQuickAbstractAnimation *role);
+    static void removeLast_animation(QQmlListProperty<QQuickAbstractAnimation> *list);
+    QList<QQuickAbstractAnimation *> animations;
+
+    void restartFromCurrentLoop();
+    void animationCurrentLoopChanged(QAbstractAnimationJob *job) override;
+    bool animationDirty: 1;
+};
+
+class Q_QUICK_EXPORT QQuickPropertyAnimationPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickPropertyAnimation)
+public:
+    QQuickPropertyAnimationPrivate()
+    : QQuickAbstractAnimationPrivate(), target(nullptr), fromIsDefined(false), toIsDefined(false), ourPropertiesDirty(false),
+      defaultToInterpolatorType(0), interpolatorType(0), interpolator(nullptr), duration(250), actions(nullptr) {}
+
+    void animationCurrentLoopChanged(QAbstractAnimationJob *job) override;
+
+    QVariant from;
+    QVariant to;
+
+    QObject *target;
+    QString propertyName;
+    QString properties;
+    QList<QPointer<QObject>> targets;
+    QList<QObject *> exclude;
+    QString defaultProperties;
+
+    bool fromIsDefined:1;
+    bool toIsDefined:1;
+    bool ourPropertiesDirty : 1;
+    bool defaultToInterpolatorType:1;
+    int interpolatorType;
+    QVariantAnimation::Interpolator interpolator;
+    int duration;
+    QEasingCurve easing;
+
+    // for animations that don't use the QQuickBulkValueAnimator
+    QQuickStateActions *actions;
+
+    static QVariant interpolateVariant(const QVariant &from, const QVariant &to, qreal progress);
+    static void convertVariant(QVariant &variant, QMetaType type);
+};
+
+class QQuickRotationAnimationPrivate : public QQuickPropertyAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickRotationAnimation)
+public:
+    QQuickRotationAnimationPrivate() : direction(QQuickRotationAnimation::Numerical) {}
+
+    QQuickRotationAnimation::RotationDirection direction;
+};
+
+class Q_AUTOTEST_EXPORT QQuickAnimationPropertyUpdater : public QQuickBulkValueUpdater
+{
+public:
+    QQuickAnimationPropertyUpdater() : interpolatorType(0), interpolator(nullptr), prevInterpolatorType(0), reverse(false), fromIsSourced(false), fromIsDefined(false), wasDeleted(nullptr) {}
+    ~QQuickAnimationPropertyUpdater() override;
+
+    void setValue(qreal v) override;
+
+    void debugUpdater(QDebug d, int indentLevel) const override;
+
+    QQuickStateActions actions;
+    int interpolatorType;       //for Number/ColorAnimation
+    QVariantAnimation::Interpolator interpolator;
+    int prevInterpolatorType;   //for generic
+    bool reverse;
+    bool fromIsSourced;
+    bool fromIsDefined;
+    bool *wasDeleted;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATION2_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimationcontroller_p.h

@@ -0,0 +1,63 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATIONCONTROLLER_H
+#define QQUICKANIMATIONCONTROLLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qqml.h>
+#include <private/qqmlfinalizer_p.h>
+#include "qquickanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAnimationControllerPrivate;
+class Q_QUICK_EXPORT QQuickAnimationController : public QObject, public QQmlFinalizerHook
+{
+    Q_OBJECT
+    Q_DISABLE_COPY_MOVE(QQuickAnimationController)
+    Q_INTERFACES(QQmlFinalizerHook)
+
+    Q_DECLARE_PRIVATE(QQuickAnimationController)
+    Q_CLASSINFO("DefaultProperty", "animation")
+    QML_NAMED_ELEMENT(AnimationController)
+    QML_ADDED_IN_VERSION(2, 0)
+
+    Q_PROPERTY(qreal progress READ progress WRITE setProgress NOTIFY progressChanged)
+    Q_PROPERTY(QQuickAbstractAnimation *animation READ animation WRITE setAnimation NOTIFY animationChanged)
+
+public:
+    QQuickAnimationController(QObject *parent=nullptr);
+    ~QQuickAnimationController();
+
+    qreal progress() const;
+    void setProgress(qreal progress);
+
+    QQuickAbstractAnimation *animation() const;
+    void setAnimation(QQuickAbstractAnimation *animation);
+
+    void componentFinalized() override;
+Q_SIGNALS:
+    void progressChanged();
+    void animationChanged();
+public Q_SLOTS:
+    void reload();
+    void completeToBeginning();
+    void completeToEnd();
+private Q_SLOTS:
+    void updateProgress();
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATIONCONTROLLER_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimator_p.h

@@ -0,0 +1,177 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATOR_P_H
+#define QQUICKANIMATOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+
+class QQuickAnimatorJob;
+class QQuickAnimatorPrivate;
+class Q_QUICK_EXPORT QQuickAnimator : public QQuickAbstractAnimation
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickAnimator)
+    Q_PROPERTY(QQuickItem *target READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
+    Q_PROPERTY(QEasingCurve easing READ easing WRITE setEasing NOTIFY easingChanged)
+    Q_PROPERTY(int duration READ duration WRITE setDuration NOTIFY durationChanged)
+    Q_PROPERTY(qreal to READ to WRITE setTo NOTIFY toChanged)
+    Q_PROPERTY(qreal from READ from WRITE setFrom NOTIFY fromChanged)
+
+    QML_NAMED_ELEMENT(Animator)
+    QML_ADDED_IN_VERSION(2, 2)
+    QML_UNCREATABLE("Animator is an abstract class")
+
+public:
+    QQuickItem *targetItem() const;
+    void setTargetItem(QQuickItem *target);
+
+    int duration() const;
+    void setDuration(int duration);
+
+    QEasingCurve easing() const;
+    void setEasing(const QEasingCurve & easing);
+
+    qreal to() const;
+    void setTo(qreal to);
+
+    qreal from() const;
+    void setFrom(qreal from);
+
+protected:
+    ThreadingModel threadingModel() const override { return RenderThread; }
+    virtual QQuickAnimatorJob *createJob() const = 0;
+    virtual QString propertyName() const = 0;
+    QAbstractAnimationJob *transition(QQuickStateActions &actions,
+                                      QQmlProperties &modified,
+                                      TransitionDirection,
+                                      QObject *) override;
+
+    QQuickAnimator(QQuickAnimatorPrivate &dd, QObject *parent = nullptr);
+    QQuickAnimator(QObject *parent = nullptr);
+
+Q_SIGNALS:
+    void targetItemChanged(QQuickItem *);
+    void durationChanged(int duration);
+    void easingChanged(const QEasingCurve &curve);
+    void toChanged(qreal to);
+    void fromChanged(qreal from);
+};
+
+class Q_QUICK_EXPORT QQuickScaleAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(ScaleAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+public:
+    QQuickScaleAnimator(QObject *parent = nullptr);
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override { return QStringLiteral("scale"); }
+};
+
+class Q_QUICK_EXPORT QQuickXAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(XAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+public:
+    QQuickXAnimator(QObject *parent = nullptr);
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override { return QStringLiteral("x"); }
+};
+
+class Q_QUICK_EXPORT QQuickYAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(YAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+public:
+    QQuickYAnimator(QObject *parent = nullptr);
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override { return QStringLiteral("y"); }
+};
+
+class Q_QUICK_EXPORT QQuickOpacityAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(OpacityAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+public:
+    QQuickOpacityAnimator(QObject *parent = nullptr);
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override { return QStringLiteral("opacity"); }
+};
+
+class QQuickRotationAnimatorPrivate;
+class Q_QUICK_EXPORT QQuickRotationAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickRotationAnimator)
+    Q_PROPERTY(RotationDirection direction READ direction WRITE setDirection NOTIFY directionChanged)
+    QML_NAMED_ELEMENT(RotationAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+
+public:
+    enum RotationDirection { Numerical, Shortest, Clockwise, Counterclockwise };
+    Q_ENUM(RotationDirection)
+
+    QQuickRotationAnimator(QObject *parent = nullptr);
+
+    void setDirection(RotationDirection dir);
+    RotationDirection direction() const;
+
+Q_SIGNALS:
+    void directionChanged(RotationDirection dir);
+
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override { return QStringLiteral("rotation"); }
+};
+
+#if QT_CONFIG(quick_shadereffect)
+class QQuickUniformAnimatorPrivate;
+class Q_QUICK_EXPORT QQuickUniformAnimator : public QQuickAnimator
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickUniformAnimator)
+    Q_PROPERTY(QString uniform READ uniform WRITE setUniform NOTIFY uniformChanged)
+    QML_NAMED_ELEMENT(UniformAnimator)
+    QML_ADDED_IN_VERSION(2, 2)
+
+public:
+    QQuickUniformAnimator(QObject *parent = nullptr);
+
+    QString uniform() const;
+    void setUniform(const QString &);
+
+Q_SIGNALS:
+    void uniformChanged(const QString &);
+
+protected:
+    QQuickAnimatorJob *createJob() const override;
+    QString propertyName() const override;
+};
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATOR_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimator_p_p.h

@@ -0,0 +1,74 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATOR_P_P_H
+#define QQUICKANIMATOR_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickanimator_p.h"
+#include "qquickanimation_p_p.h"
+#include <QtQuick/qquickitem.h>
+
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAnimatorJob;
+
+class QQuickAnimatorPrivate : public QQuickAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickAnimator)
+public:
+    QQuickAnimatorPrivate()
+        : target(0)
+        , duration(250)
+        , from(0)
+        , to(0)
+        , fromIsDefined(false)
+        , toIsDefined(false)
+    {
+    }
+
+    QPointer<QQuickItem> target;
+    int duration;
+    QEasingCurve easing;
+    qreal from;
+    qreal to;
+
+    uint fromIsDefined : 1;
+    uint toIsDefined : 1;
+
+    void apply(QQuickAnimatorJob *job, const QString &propertyName, QQuickStateActions &actions, QQmlProperties &modified, QObject *defaultTarget);
+};
+
+class QQuickRotationAnimatorPrivate : public QQuickAnimatorPrivate
+{
+public:
+    QQuickRotationAnimatorPrivate()
+        : direction(QQuickRotationAnimator::Numerical)
+    {
+    }
+    QQuickRotationAnimator::RotationDirection direction;
+};
+
+#if QT_CONFIG(quick_shadereffect)
+class QQuickUniformAnimatorPrivate : public QQuickAnimatorPrivate
+{
+public:
+    QString uniform;
+};
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATOR_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatorcontroller_p.h

@@ -0,0 +1,76 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATORCONTROLLER_P_H
+#define QQUICKANIMATORCONTROLLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickanimatorjob_p.h"
+#include <QtQuick/qsgnode.h>
+#include <QtQuick/qquickitem.h>
+
+#include <QtCore/qmutex.h>
+#include <QtCore/qthread.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickAnimatorController : public QObject, public QAnimationJobChangeListener
+{
+    Q_OBJECT
+
+public:
+    QQuickAnimatorController(QQuickWindow *window);
+    ~QQuickAnimatorController();
+
+    void advance();
+    void beforeNodeSync();
+    void afterNodeSync();
+
+    void animationFinished(QAbstractAnimationJob *job) override;
+    void animationStateChanged(QAbstractAnimationJob *job, QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override;
+
+    void requestSync();
+
+    // These are called from the GUI thread (the proxy)
+    void start(const QSharedPointer<QAbstractAnimationJob> &job);
+    void cancel(const QSharedPointer<QAbstractAnimationJob> &job);
+    bool isPendingStart(const QSharedPointer<QAbstractAnimationJob> &job) const { return m_rootsPendingStart.contains(job); }
+
+    void lock() { m_mutex.lock(); }
+    void unlock() { m_mutex.unlock(); }
+
+    void windowNodesDestroyed();
+
+    QQuickWindow *window() const { return m_window; }
+
+private:
+    friend class tst_Animators;
+
+    void start_helper(QAbstractAnimationJob *job);
+    void cancel_helper(QAbstractAnimationJob *job);
+
+    QSet<QQuickAnimatorJob * > m_runningAnimators;
+    QHash<QAbstractAnimationJob *, QSharedPointer<QAbstractAnimationJob> > m_animationRoots;
+    QSet<QSharedPointer<QAbstractAnimationJob> > m_rootsPendingStop;
+    QSet<QSharedPointer<QAbstractAnimationJob> > m_rootsPendingStart;
+
+    QQuickWindow *m_window;
+    QMutex m_mutex;
+};
+
+
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATORCONTROLLER_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickanimatorjob_p.h

@@ -0,0 +1,290 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKANIMATORJOB_P_H
+#define QQUICKANIMATORJOB_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qabstractanimationjob_p.h>
+#include <private/qquickanimator_p.h>
+#include <private/qtquickglobal_p.h>
+
+#include <QtQuick/qquickitem.h>
+
+#include <QtCore/qeasingcurve.h>
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAnimator;
+class QQuickWindow;
+class QQuickItem;
+class QQuickAbstractAnimation;
+
+class QQuickAnimatorController;
+
+class QSGOpacityNode;
+
+class Q_QUICK_EXPORT QQuickAnimatorProxyJob : public QObject, public QAbstractAnimationJob
+{
+    Q_OBJECT
+
+public:
+    QQuickAnimatorProxyJob(QAbstractAnimationJob *job, QQuickAbstractAnimation *animation);
+    ~QQuickAnimatorProxyJob();
+
+    int duration() const override { return m_duration; }
+
+    const QSharedPointer<QAbstractAnimationJob> &job() const { return m_job; }
+
+protected:
+    void updateCurrentTime(int) override;
+    void updateLoopCount(int) override;
+    void updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override;
+    void debugAnimation(QDebug d) const override;
+
+public Q_SLOTS:
+    void windowChanged(QQuickWindow *window);
+    void sceneGraphInitialized();
+
+private:
+    void syncBackCurrentValues();
+    void readyToAnimate();
+    void setWindow(QQuickWindow *window);
+    static QObject *findAnimationContext(QQuickAbstractAnimation *);
+
+    QPointer<QQuickAnimatorController> m_controller;
+    QSharedPointer<QAbstractAnimationJob> m_job;
+    int m_duration;
+
+    enum InternalState {
+        State_Starting, // Used when it should be running, but no we're still missing the controller.
+        State_Running,
+        State_Paused,
+        State_Stopped
+    };
+
+    InternalState m_internalState;
+};
+
+class Q_QUICK_EXPORT QQuickAnimatorJob : public QAbstractAnimationJob
+{
+public:
+    virtual void setTarget(QQuickItem *target);
+    QQuickItem *target() const { return m_target; }
+
+    void setFrom(qreal from) {
+        m_from = from;
+        boundValue();
+    }
+    qreal from() const { return m_from; }
+
+    void setTo(qreal to) {
+        m_to = to;
+        boundValue();
+    }
+    qreal to() const { return m_to; }
+
+    void setDuration(int duration) { m_duration = duration; }
+    int duration() const override { return m_duration; }
+
+    QEasingCurve easingCurve() const { return m_easing; }
+    void setEasingCurve(const QEasingCurve &curve) { m_easing = curve; }
+
+    // Initialize is called on the GUI thread just before it is started
+    // and taken over on the render thread.
+    virtual void initialize(QQuickAnimatorController *controller);
+
+    // Called on the render thread during SG shutdown.
+    virtual void invalidate() = 0;
+
+    // Called on the GUI thread after a complete render thread animation job
+    // has been completed to write back a given animator's result to the
+    // source item.
+    virtual void writeBack() = 0;
+
+    // Called before the SG sync on the render thread. The GUI thread is
+    // locked during this call.
+    virtual void preSync() { }
+
+    // Called after the SG sync on the render thread. The GUI thread is
+    // locked during this call.
+    virtual void postSync() { }
+
+    // Called after animations have ticked on the render thread. No locks are
+    // held at this time, so synchronization needs to be taken into account
+    // if applicable.
+    virtual void commit() { }
+
+    bool isTransform() const { return m_isTransform; }
+    bool isUniform() const { return m_isUniform; }
+
+    qreal value() const;
+
+    QQuickAnimatorController *controller() const { return m_controller; }
+
+protected:
+    QQuickAnimatorJob();
+    void debugAnimation(QDebug d) const override;
+
+    qreal progress(int time) const;
+    void boundValue();
+
+    QPointer<QQuickItem> m_target;
+    QQuickAnimatorController *m_controller;
+
+    qreal m_from;
+    qreal m_to;
+    qreal m_value;
+
+    QEasingCurve m_easing;
+
+    int m_duration;
+
+    uint m_isTransform : 1;
+    uint m_isUniform : 1;
+};
+
+class QQuickTransformAnimatorJob : public QQuickAnimatorJob
+{
+public:
+
+    struct Helper
+    {
+        Helper()
+            : ref(1)
+            , node(nullptr)
+            , ox(0)
+            , oy(0)
+            , dx(0)
+            , dy(0)
+            , scale(1)
+            , rotation(0)
+            , wasSynced(false)
+            , wasChanged(false)
+        {
+        }
+
+        void sync();
+        void commit();
+
+        int ref;
+        QQuickItem *item;
+        QSGTransformNode *node;
+
+        // Origin
+        float ox;
+        float oy;
+
+        float dx;
+        float dy;
+        float scale;
+        float rotation;
+
+        uint wasSynced : 1;
+        uint wasChanged : 1;
+    };
+
+    ~QQuickTransformAnimatorJob();
+
+    void commit() override;
+    void preSync() override;
+
+    void setTarget(QQuickItem *item) override;
+
+protected:
+    QQuickTransformAnimatorJob();
+    void invalidate() override;
+
+    Helper *m_helper;
+};
+
+class Q_QUICK_EXPORT QQuickScaleAnimatorJob : public QQuickTransformAnimatorJob
+{
+public:
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+};
+
+class Q_QUICK_EXPORT QQuickXAnimatorJob : public QQuickTransformAnimatorJob
+{
+public:
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+};
+
+class Q_QUICK_EXPORT QQuickYAnimatorJob : public QQuickTransformAnimatorJob
+{
+public:
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+};
+
+class Q_QUICK_EXPORT QQuickRotationAnimatorJob : public QQuickTransformAnimatorJob
+{
+public:
+    QQuickRotationAnimatorJob();
+
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+
+    void setDirection(QQuickRotationAnimator::RotationDirection direction) { m_direction = direction; }
+    QQuickRotationAnimator::RotationDirection direction() const { return m_direction; }
+
+private:
+    QQuickRotationAnimator::RotationDirection m_direction;
+};
+
+class Q_QUICK_EXPORT QQuickOpacityAnimatorJob : public QQuickAnimatorJob
+{
+public:
+    QQuickOpacityAnimatorJob();
+
+    void invalidate() override;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+    void postSync() override;
+
+private:
+    QSGOpacityNode *m_opacityNode;
+};
+
+#if QT_CONFIG(quick_shadereffect)
+class QQuickShaderEffect;
+
+class Q_QUICK_EXPORT QQuickUniformAnimatorJob : public QQuickAnimatorJob
+{
+public:
+    QQuickUniformAnimatorJob();
+
+    void setTarget(QQuickItem *target) override;
+
+    void setUniform(const QByteArray &uniform) { m_uniform = uniform; }
+    QByteArray uniform() const { return m_uniform; }
+
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+    void postSync() override;
+
+    void invalidate() override;
+
+private:
+    QByteArray m_uniform;
+    QPointer<QQuickShaderEffect> m_effect;
+};
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QQUICKANIMATORJOB_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickapplication_p.h

@@ -0,0 +1,77 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKAPPLICATION_P_H
+#define QQUICKAPPLICATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/private/qtquickglobal_p.h>
+#include <QtQuick/private/qquickscreen_p.h>
+
+#include <QtQml/qqml.h>
+#include <QtQml/private/qqmlglobal_p.h>
+
+#include <QtGui/qfont.h>
+#include <QtGui/qstylehints.h>
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickApplication : public QQmlApplication
+{
+    Q_OBJECT
+    Q_PROPERTY(bool active READ active NOTIFY activeChanged FINAL) // deprecated, use 'state' instead
+    Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection NOTIFY layoutDirectionChanged FINAL)
+    Q_PROPERTY(bool supportsMultipleWindows READ supportsMultipleWindows CONSTANT FINAL)
+    Q_PROPERTY(Qt::ApplicationState state READ state NOTIFY stateChanged FINAL)
+    Q_PROPERTY(QFont font READ font CONSTANT FINAL)
+    Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName NOTIFY displayNameChanged FINAL)
+    Q_PROPERTY(QQmlListProperty<QQuickScreenInfo> screens READ screens NOTIFY screensChanged FINAL)
+    Q_PROPERTY(QStyleHints *styleHints READ styleHints CONSTANT FINAL)
+
+    QML_NAMED_ELEMENT(Application)
+    QML_SINGLETON
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    explicit QQuickApplication(QObject *parent = nullptr);
+    virtual ~QQuickApplication();
+    bool active() const;
+    Qt::LayoutDirection layoutDirection() const;
+    bool supportsMultipleWindows() const;
+    Qt::ApplicationState state() const;
+    QFont font() const;
+    QQmlListProperty<QQuickScreenInfo> screens();
+    QString displayName() const;
+    void setDisplayName(const QString &displayName);
+    QStyleHints *styleHints();
+
+Q_SIGNALS:
+    void activeChanged();
+    void displayNameChanged();
+    void layoutDirectionChanged();
+    void stateChanged(Qt::ApplicationState state);
+    void screensChanged();
+
+private Q_SLOTS:
+    void updateScreens();
+
+private:
+    Q_DISABLE_COPY(QQuickApplication)
+    QVector<QQuickScreenInfo *> m_screens;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKAPPLICATION_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickbehavior_p.h

@@ -0,0 +1,73 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKBEHAVIOR_H
+#define QQUICKBEHAVIOR_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+#include <private/qqmlpropertyvalueinterceptor_p.h>
+#include <private/qqmlengine_p.h>
+#include <qqml.h>
+#include <private/qqmlfinalizer_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickAbstractAnimation;
+class QQuickBehaviorPrivate;
+class Q_QUICK_EXPORT QQuickBehavior : public QObject, public QQmlPropertyValueInterceptor, public QQmlFinalizerHook
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlFinalizerHook)
+    Q_DECLARE_PRIVATE(QQuickBehavior)
+
+    Q_INTERFACES(QQmlPropertyValueInterceptor)
+    Q_CLASSINFO("DefaultProperty", "animation")
+    Q_PROPERTY(QQuickAbstractAnimation *animation READ animation WRITE setAnimation)
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(QVariant targetValue READ targetValue NOTIFY targetValueChanged REVISION(2, 13))
+    Q_PROPERTY(QQmlProperty targetProperty READ targetProperty NOTIFY targetPropertyChanged REVISION(2, 15))
+    Q_CLASSINFO("DeferredPropertyNames", "animation")
+    QML_NAMED_ELEMENT(Behavior)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickBehavior(QObject *parent=nullptr);
+    ~QQuickBehavior();
+
+    void setTarget(const QQmlProperty &) override;
+    void write(const QVariant &value) override;
+    bool bindable(QUntypedBindable *untypedBindable, QUntypedBindable target) override;
+
+    QQuickAbstractAnimation *animation();
+    void setAnimation(QQuickAbstractAnimation *);
+
+    bool enabled() const;
+    void setEnabled(bool enabled);
+
+    QVariant targetValue() const;
+
+    QQmlProperty targetProperty() const;
+
+    void componentFinalized() override;
+
+Q_SIGNALS:
+    void enabledChanged();
+    void targetValueChanged();
+    void targetPropertyChanged();
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKBEHAVIOR_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickborderimage_p.h

@@ -0,0 +1,81 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKBORDERIMAGE_P_H
+#define QQUICKBORDERIMAGE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickimagebase_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickScaleGrid;
+class QQuickGridScaledImage;
+class QQuickBorderImagePrivate;
+class Q_QUICK_EXPORT QQuickBorderImage : public QQuickImageBase
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QQuickScaleGrid *border READ border CONSTANT)
+    Q_PROPERTY(TileMode horizontalTileMode READ horizontalTileMode WRITE setHorizontalTileMode NOTIFY horizontalTileModeChanged)
+    Q_PROPERTY(TileMode verticalTileMode READ verticalTileMode WRITE setVerticalTileMode NOTIFY verticalTileModeChanged)
+    // read-only for BorderImage
+    Q_PROPERTY(QSize sourceSize READ sourceSize NOTIFY sourceSizeChanged)
+    QML_NAMED_ELEMENT(BorderImage)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickBorderImage(QQuickItem *parent=nullptr);
+    ~QQuickBorderImage();
+
+    QQuickScaleGrid *border();
+
+    enum TileMode { Stretch = Qt::StretchTile, Repeat = Qt::RepeatTile, Round = Qt::RoundTile };
+    Q_ENUM(TileMode)
+
+    TileMode horizontalTileMode() const;
+    void setHorizontalTileMode(TileMode);
+
+    TileMode verticalTileMode() const;
+    void setVerticalTileMode(TileMode);
+
+    void setSource(const QUrl &url) override;
+
+Q_SIGNALS:
+    void horizontalTileModeChanged();
+    void verticalTileModeChanged();
+    void sourceSizeChanged();
+
+protected:
+    void load() override;
+    void pixmapChange() override;
+    QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;
+
+private:
+    void setGridScaledImage(const QQuickGridScaledImage& sci);
+
+private Q_SLOTS:
+    void doUpdate();
+    void requestFinished() override;
+#if QT_CONFIG(qml_network)
+    void sciRequestFinished();
+#endif
+
+private:
+    Q_DISABLE_COPY(QQuickBorderImage)
+    Q_DECLARE_PRIVATE(QQuickBorderImage)
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKBORDERIMAGE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickborderimage_p_p.h

@@ -0,0 +1,76 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKBORDERIMAGE_P_P_H
+#define QQUICKBORDERIMAGE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickimagebase_p_p.h"
+#include "qquickscalegrid_p_p.h"
+
+#include <private/qqmlglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#if QT_CONFIG(qml_network)
+class QNetworkReply;
+#endif
+class QQuickBorderImagePrivate : public QQuickImageBasePrivate
+{
+    Q_DECLARE_PUBLIC(QQuickBorderImage)
+
+public:
+    QQuickBorderImagePrivate()
+    {
+    }
+
+    ~QQuickBorderImagePrivate()
+    {
+    }
+
+    QQuickScaleGrid *getScaleGrid()
+    {
+        Q_Q(QQuickBorderImage);
+        if (!border) {
+            border = new QQuickScaleGrid(q);
+            qmlobject_connect(border, QQuickScaleGrid, SIGNAL(borderChanged()),
+                              q, QQuickBorderImage, SLOT(doUpdate()));
+        }
+        return border;
+    }
+
+    static void calculateRects(const QQuickScaleGrid *border,
+                               const QSize &sourceSize,
+                               const QSizeF &targetSize,
+                               int horizontalTileMode,
+                               int verticalTileMode,
+                               qreal devicePixelRatio,
+                               QRectF *targetRect,
+                               QRectF *innerTargetRect,
+                               QRectF *innerSourceRect,
+                               QRectF *subSourceRect);
+
+    QUrl sciurl;
+    QQuickScaleGrid *border = nullptr;
+    QQuickBorderImage::TileMode horizontalTileMode = QQuickBorderImage::Stretch;
+    QQuickBorderImage::TileMode verticalTileMode = QQuickBorderImage::Stretch;
+    bool pixmapChanged = false;
+
+#if QT_CONFIG(qml_network)
+    QNetworkReply *sciReply = nullptr;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKBORDERIMAGE_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcanvascontext_p.h

@@ -0,0 +1,62 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCANVASCONTEXT_P_H
+#define QQUICKCANVASCONTEXT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include <QtQuick/qquickitem.h>
+#include <QtQml/private/qv4staticvalue_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QV4 {
+    struct ExecutionEngine;
+}
+
+class QQuickCanvasItem;
+class QSGLayer;
+
+class QQuickCanvasContext : public QObject
+{
+    Q_OBJECT
+
+public:
+    QQuickCanvasContext(QObject *parent = nullptr);
+    ~QQuickCanvasContext();
+
+    virtual QStringList contextNames() const = 0;
+
+    // Init (ignore options if necessary)
+    virtual void init(QQuickCanvasItem *canvasItem, const QVariantMap &args) = 0;
+
+    virtual void prepare(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing);
+    virtual void flush();
+
+    virtual QV4::ExecutionEngine *v4Engine() const = 0;
+    virtual void setV4Engine(QV4::ExecutionEngine *engine) = 0;
+    virtual QV4::ReturnedValue v4value() const = 0;
+
+    virtual QImage toImage(const QRectF& bounds) = 0;
+
+Q_SIGNALS:
+    void textureChanged();
+};
+
+QT_END_NAMESPACE
+
+#endif //QQUICKCANVASCONTEXT_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcanvasitem_p.h

@@ -0,0 +1,188 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCANVASITEM_P_H
+#define QQUICKCANVASITEM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include <QtQuick/qquickitem.h>
+#include <private/qqmlrefcount_p.h>
+#include <QtCore/QThread>
+#include <QtCore/qmutex.h>
+#include <QtGui/QImage>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickCanvasContext;
+
+class QQuickCanvasItemPrivate;
+class QQuickPixmap;
+
+class QQuickCanvasPixmap final : public QQmlRefCounted<QQuickCanvasPixmap>
+{
+public:
+    QQuickCanvasPixmap(const QImage& image);
+    QQuickCanvasPixmap(QQuickPixmap *pixmap);
+    ~QQuickCanvasPixmap();
+
+    QImage image();
+
+    qreal width() const;
+    qreal height() const;
+    bool isValid() const;
+    QQuickPixmap *pixmap() const { return m_pixmap;}
+
+private:
+    QQuickPixmap *m_pixmap;
+    QImage m_image;
+};
+
+class QQuickCanvasItem : public QQuickItem
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool available READ isAvailable NOTIFY availableChanged)
+    Q_PROPERTY(QString contextType READ contextType WRITE setContextType NOTIFY contextTypeChanged)
+    Q_PROPERTY(QJSValue context READ context NOTIFY contextChanged)
+    Q_PROPERTY(QSizeF canvasSize READ canvasSize WRITE setCanvasSize NOTIFY canvasSizeChanged)
+    Q_PROPERTY(QSize tileSize READ tileSize WRITE setTileSize NOTIFY tileSizeChanged)
+    Q_PROPERTY(QRectF canvasWindow READ canvasWindow WRITE setCanvasWindow NOTIFY canvasWindowChanged)
+    Q_PROPERTY(RenderTarget renderTarget READ renderTarget WRITE setRenderTarget NOTIFY renderTargetChanged)
+    Q_PROPERTY(RenderStrategy renderStrategy READ renderStrategy WRITE setRenderStrategy NOTIFY renderStrategyChanged)
+    QML_NAMED_ELEMENT(Canvas)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    enum RenderTarget {
+        Image,
+        FramebufferObject
+    };
+    Q_ENUM(RenderTarget)
+
+    enum RenderStrategy {
+        Immediate,
+        Threaded,
+        Cooperative
+    };
+    Q_ENUM(RenderStrategy)
+
+    QQuickCanvasItem(QQuickItem *parent = nullptr);
+    ~QQuickCanvasItem();
+
+    bool isAvailable() const;
+
+    QString contextType() const;
+    void setContextType(const QString &contextType);
+
+    QJSValue context() const;
+
+    QSizeF canvasSize() const;
+    void setCanvasSize(const QSizeF &);
+
+    QSize tileSize() const;
+    void setTileSize(const QSize &);
+
+    QRectF canvasWindow() const;
+    void setCanvasWindow(const QRectF& rect);
+
+    RenderTarget renderTarget() const;
+    void setRenderTarget(RenderTarget target);
+
+    RenderStrategy renderStrategy() const;
+    void setRenderStrategy(RenderStrategy strategy);
+
+    QQuickCanvasContext *rawContext() const;
+
+    QImage toImage(const QRectF& rect = QRectF()) const;
+
+    Q_INVOKABLE void getContext(QQmlV4FunctionPtr args);
+
+    Q_INVOKABLE void requestAnimationFrame(QQmlV4FunctionPtr args);
+    Q_INVOKABLE void cancelRequestAnimationFrame(QQmlV4FunctionPtr args);
+
+    Q_INVOKABLE void requestPaint();
+    Q_INVOKABLE void markDirty(const QRectF& dirtyRect = QRectF());
+
+    Q_INVOKABLE bool save(const QString &filename, const QSizeF &imageSize = QSizeF()) const;
+    Q_INVOKABLE QString toDataURL(const QString& type = QLatin1String("image/png")) const;
+    QQmlRefPointer<QQuickCanvasPixmap> loadedPixmap(const QUrl& url, QSizeF sourceSize = QSizeF());
+
+    bool isTextureProvider() const override;
+    QSGTextureProvider *textureProvider() const override;
+
+Q_SIGNALS:
+    void paint(const QRect &region);
+    void painted();
+    void availableChanged();
+    void contextTypeChanged();
+    void contextChanged();
+    void canvasSizeChanged();
+    void tileSizeChanged();
+    void canvasWindowChanged();
+    void renderTargetChanged();
+    void renderStrategyChanged();
+    void imageLoaded();
+
+public Q_SLOTS:
+    void loadImage(const QUrl& url, QSizeF sourceSize = QSizeF());
+    void unloadImage(const QUrl& url);
+    bool isImageLoaded(const QUrl& url) const;
+    bool isImageLoading(const QUrl& url) const;
+    bool isImageError(const QUrl& url) const;
+
+private Q_SLOTS:
+    void sceneGraphInitialized();
+    void checkAnimationCallbacks();
+    void invalidateSceneGraph();
+    void schedulePolish();
+
+protected:
+    void componentComplete() override;
+    void itemChange(QQuickItem::ItemChange, const QQuickItem::ItemChangeData &) override;
+    void updatePolish() override;
+    QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;
+    void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;
+    void releaseResources() override;
+    bool event(QEvent *event) override;
+private:
+    Q_DECLARE_PRIVATE(QQuickCanvasItem)
+    Q_INVOKABLE void delayedCreate();
+    bool createContext(const QString &contextType);
+    void initializeContext(QQuickCanvasContext *context, const QVariantMap &args = QVariantMap());
+    static QRect tiledRect(const QRectF &window, const QSize &tileSize);
+    bool isPaintConnected();
+};
+
+class QQuickContext2DRenderThread : public QThread
+{
+    Q_OBJECT
+public:
+    QQuickContext2DRenderThread(QQmlEngine *eng);
+    ~QQuickContext2DRenderThread();
+
+    static QQuickContext2DRenderThread *instance(QQmlEngine *engine);
+
+private:
+    QQmlEngine *m_engine;
+    QObject *m_eventLoopQuitHack;
+    static QHash<QQmlEngine *,QQuickContext2DRenderThread*> renderThreads;
+    static QMutex renderThreadsMutex;
+};
+
+QT_END_NAMESPACE
+
+#endif //QQUICKCANVASITEM_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickclipnode_p.h

@@ -0,0 +1,49 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCLIPNODE_P_H
+#define QQUICKCLIPNODE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+#include <QtQuick/qsgnode.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDefaultClipNode : public QSGClipNode
+{
+public:
+    QQuickDefaultClipNode(const QRectF &);
+
+    void setRect(const QRectF &);
+    QRectF rect() const { return m_rect; }
+
+    void setRadius(qreal radius);
+    qreal radius() const { return m_radius; }
+
+    virtual void update();
+
+private:
+    void updateGeometry();
+    QRectF m_rect;
+    qreal m_radius;
+
+    uint m_dirty_geometry : 1;
+    uint m_reserved : 31;
+
+    QSGGeometry m_geometry;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKCLIPNODE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcolorgroup_p.h

@@ -0,0 +1,208 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef QQUICKCOLORGROUP_H
+#define QQUICKCOLORGROUP_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QQuickColorGroup. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpalette.h>
+
+#include <QtCore/private/qobject_p.h>
+
+#include <QtQuick/private/qtquickglobal_p.h>
+
+#include <QtQml/qqml.h>
+
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickPalette;
+class QQuickPaletteColorProvider;
+
+class Q_QUICK_EXPORT QQuickColorGroup : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QColor alternateBase   READ alternateBase   WRITE setAlternateBase   RESET resetAlternateBase   NOTIFY alternateBaseChanged   FINAL)
+    Q_PROPERTY(QColor base            READ base            WRITE setBase            RESET resetBase            NOTIFY baseChanged            FINAL)
+    Q_PROPERTY(QColor brightText      READ brightText      WRITE setBrightText      RESET resetBrightText      NOTIFY brightTextChanged      FINAL)
+    Q_PROPERTY(QColor button          READ button          WRITE setButton          RESET resetButton          NOTIFY buttonChanged          FINAL)
+    Q_PROPERTY(QColor buttonText      READ buttonText      WRITE setButtonText      RESET resetButtonText      NOTIFY buttonTextChanged      FINAL)
+    Q_PROPERTY(QColor dark            READ dark            WRITE setDark            RESET resetDark            NOTIFY darkChanged            FINAL)
+    Q_PROPERTY(QColor highlight       READ highlight       WRITE setHighlight       RESET resetHighlight       NOTIFY highlightChanged       FINAL)
+    Q_PROPERTY(QColor highlightedText READ highlightedText WRITE setHighlightedText RESET resetHighlightedText NOTIFY highlightedTextChanged FINAL)
+    Q_PROPERTY(QColor light           READ light           WRITE setLight           RESET resetLight           NOTIFY lightChanged           FINAL)
+    Q_PROPERTY(QColor link            READ link            WRITE setLink            RESET resetLink            NOTIFY linkChanged            FINAL)
+    Q_PROPERTY(QColor linkVisited     READ linkVisited     WRITE setLinkVisited     RESET resetLinkVisited     NOTIFY linkVisitedChanged     FINAL)
+    Q_PROPERTY(QColor mid             READ mid             WRITE setMid             RESET resetMid             NOTIFY midChanged             FINAL)
+    Q_PROPERTY(QColor midlight        READ midlight        WRITE setMidlight        RESET resetMidlight        NOTIFY midlightChanged        FINAL)
+    Q_PROPERTY(QColor shadow          READ shadow          WRITE setShadow          RESET resetShadow          NOTIFY shadowChanged          FINAL)
+    Q_PROPERTY(QColor text            READ text            WRITE setText            RESET resetText            NOTIFY textChanged            FINAL)
+    Q_PROPERTY(QColor toolTipBase     READ toolTipBase     WRITE setToolTipBase     RESET resetToolTipBase     NOTIFY toolTipBaseChanged     FINAL)
+    Q_PROPERTY(QColor toolTipText     READ toolTipText     WRITE setToolTipText     RESET resetToolTipText     NOTIFY toolTipTextChanged     FINAL)
+    Q_PROPERTY(QColor window          READ window          WRITE setWindow          RESET resetWindow          NOTIFY windowChanged          FINAL)
+    Q_PROPERTY(QColor windowText      READ windowText      WRITE setWindowText      RESET resetWindowText      NOTIFY windowTextChanged      FINAL)
+    Q_PROPERTY(QColor placeholderText READ placeholderText WRITE setPlaceholderText
+               RESET resetPlaceholderText NOTIFY placeholderTextChanged REVISION(6, 2) FINAL)
+    Q_PROPERTY(QColor accent READ accent WRITE setAccent RESET resetAccent NOTIFY accentChanged REVISION(6, 6) FINAL)
+
+    QML_NAMED_ELEMENT(ColorGroup)
+    QML_ADDED_IN_VERSION(6, 0)
+
+public: // Types
+    using GroupPtr = QPointer<QQuickColorGroup>;
+
+public:
+    Q_DISABLE_COPY_MOVE(QQuickColorGroup)
+
+    explicit QQuickColorGroup(QObject *parent = nullptr);
+
+    QColor alternateBase() const;
+    void setAlternateBase(const QColor &color);
+    void resetAlternateBase();
+
+    QColor base() const;
+    void setBase(const QColor &color);
+    void resetBase();
+
+    QColor brightText() const;
+    void setBrightText(const QColor &color);
+    void resetBrightText();
+
+    QColor button() const;
+    void setButton(const QColor &color);
+    void resetButton();
+
+    QColor buttonText() const;
+    void setButtonText(const QColor &color);
+    void resetButtonText();
+
+    QColor dark() const;
+    void setDark(const QColor &color);
+    void resetDark();
+
+    QColor highlight() const;
+    void setHighlight(const QColor &color);
+    void resetHighlight();
+
+    QColor highlightedText() const;
+    void setHighlightedText(const QColor &color);
+    void resetHighlightedText();
+
+    QColor light() const;
+    void setLight(const QColor &color);
+    void resetLight();
+
+    QColor link() const;
+    void setLink(const QColor &color);
+    void resetLink();
+
+    QColor linkVisited() const;
+    void setLinkVisited(const QColor &color);
+    void resetLinkVisited();
+
+    QColor mid() const;
+    void setMid(const QColor &color);
+    void resetMid();
+
+    QColor midlight() const;
+    void setMidlight(const QColor &color);
+    void resetMidlight();
+
+    QColor shadow() const;
+    void setShadow(const QColor &color);
+    void resetShadow();
+
+    QColor text() const;
+    void setText(const QColor &color);
+    void resetText();
+
+    QColor toolTipBase() const;
+    void setToolTipBase(const QColor &color);
+    void resetToolTipBase();
+
+    QColor toolTipText() const;
+    void setToolTipText(const QColor &color);
+    void resetToolTipText();
+
+    QColor window() const;
+    void setWindow(const QColor &color);
+    void resetWindow();
+
+    QColor windowText() const;
+    void setWindowText(const QColor &color);
+    void resetWindowText();
+
+    QColor placeholderText() const;
+    void setPlaceholderText(const QColor &color);
+    void resetPlaceholderText();
+
+    QColor accent() const;
+    void setAccent(const QColor &color);
+    void resetAccent();
+
+    QPalette::ColorGroup groupTag() const;
+    void setGroupTag(QPalette::ColorGroup tag);
+
+    const QQuickPaletteColorProvider &colorProvider() const;
+    QQuickPaletteColorProvider &colorProvider();
+
+    static QQuickColorGroup* createWithParent(QQuickPalette &parent);
+
+Q_SIGNALS:
+    void alternateBaseChanged();
+    void baseChanged();
+    void brightTextChanged();
+    void buttonChanged();
+    void buttonTextChanged();
+    void darkChanged();
+    void highlightChanged();
+    void highlightedTextChanged();
+    void lightChanged();
+    void linkChanged();
+    void linkVisitedChanged();
+    void midChanged();
+    void midlightChanged();
+    void shadowChanged();
+    void textChanged();
+    void toolTipBaseChanged();
+    void toolTipTextChanged();
+    void windowChanged();
+    void windowTextChanged();
+    Q_REVISION(6, 2) void placeholderTextChanged();
+    Q_REVISION(6, 6) void accentChanged();
+
+    void changed();
+
+protected:
+    explicit QQuickColorGroup(QQuickPalette &parent);
+
+    static constexpr QPalette::ColorGroup defaultGroupTag() { return QPalette::All; }
+
+    virtual QPalette::ColorGroup currentColorGroup() const;
+
+private:
+    using Notifier = void (QQuickColorGroup::* )();
+
+    QColor color(QPalette::ColorRole role) const;
+    void setColor(QPalette::ColorRole role, QColor color, Notifier notifier);
+    void resetColor(QPalette::ColorRole role, Notifier notifier);
+
+private:
+    QPalette::ColorGroup m_groupTag;
+    std::shared_ptr<QQuickPaletteColorProvider> m_colorProvider;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKCOLORGROUP_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcontext2d_p.h

@@ -0,0 +1,244 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCONTEXT2D_P_H
+#define QQUICKCONTEXT2D_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include <QtQml/qqml.h>
+#include <QtQml/qqmlcomponent.h>
+#include <private/qquickcanvascontext_p.h>
+#include <private/qquickcanvasitem_p.h>
+#include <QtGui/qpainter.h>
+#include <QtGui/qpainterpath.h>
+#include <QtGui/qoffscreensurface.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstack.h>
+#include <QtCore/qqueue.h>
+#include <QtCore/QWaitCondition>
+
+#include <private/qv4persistent_p.h>
+
+//#define QQUICKCONTEXT2D_DEBUG //enable this for just DEBUG purpose!
+
+#ifdef QQUICKCONTEXT2D_DEBUG
+#include <QElapsedTimer>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+namespace QV4 {
+    struct ExecutionEngine;
+}
+
+class QQuickContext2DCommandBuffer;
+class QQuickContext2DTexture;
+class QQuickPixmap;
+class QSGTexture;
+class QSurface;
+
+class QQuickContext2D : public QQuickCanvasContext
+{
+    Q_OBJECT
+
+public:
+    Q_DISABLE_COPY(QQuickContext2D)
+
+    enum TextBaseLineType { Alphabetic=0, Top, Middle, Bottom, Hanging};
+    enum TextAlignType { Start=0, End, Left, Right, Center};
+    enum PaintCommand {
+        Invalid = 0,
+        UpdateMatrix,
+        ClearRect,
+        FillRect,
+        StrokeRect,
+        Fill,
+        Stroke,
+        Clip,
+        UpdateBrush,
+        GlobalAlpha,
+        GlobalCompositeOperation,
+        StrokeStyle,
+        FillStyle,
+        LineWidth,
+        LineCap,
+        LineJoin,
+        LineDash,
+        LineDashOffset,
+        MiterLimit,
+        ShadowOffsetX,
+        ShadowOffsetY,
+        ShadowBlur,
+        ShadowColor,
+        Font,
+        TextBaseline,
+        TextAlign,
+        FillText,
+        StrokeText,
+        DrawImage,
+        DrawPixmap,
+        GetImageData
+    };
+
+    struct State {
+        State()
+            : strokeStyle(QColor(Qt::black))
+            , fillStyle(QColor(Qt::black))
+            , fillPatternRepeatX(false)
+            , fillPatternRepeatY(false)
+            , strokePatternRepeatX(false)
+            , strokePatternRepeatY(false)
+            , invertibleCTM(true)
+            , clip(false)
+            , fillRule(Qt::WindingFill)
+            , globalAlpha(1.0)
+            , lineWidth(1)
+            , lineCap(Qt::FlatCap)
+            , lineJoin(Qt::MiterJoin)
+            , lineDashOffset(0)
+            , miterLimit(10)
+            , shadowOffsetX(0)
+            , shadowOffsetY(0)
+            , shadowBlur(0)
+            , shadowColor(qRgba(0, 0, 0, 0))
+            , globalCompositeOperation(QPainter::CompositionMode_SourceOver)
+            , font(QFont(QLatin1String("sans-serif")))
+            , textAlign(QQuickContext2D::Start)
+            , textBaseline(QQuickContext2D::Alphabetic)
+        {
+            font.setPixelSize(10);
+        }
+
+        QTransform matrix;
+        QPainterPath clipPath;
+        QBrush strokeStyle;
+        QBrush fillStyle;
+        bool fillPatternRepeatX:1;
+        bool fillPatternRepeatY:1;
+        bool strokePatternRepeatX:1;
+        bool strokePatternRepeatY:1;
+        bool invertibleCTM:1;
+        bool clip:1;
+        Qt::FillRule fillRule;
+        qreal globalAlpha;
+        qreal lineWidth;
+        Qt::PenCapStyle lineCap;
+        Qt::PenJoinStyle lineJoin;
+        QVector<qreal> lineDash;
+        qreal lineDashOffset;
+        qreal miterLimit;
+        qreal shadowOffsetX;
+        qreal shadowOffsetY;
+        qreal shadowBlur;
+        QColor shadowColor;
+        QPainter::CompositionMode globalCompositeOperation;
+        QFont font;
+        QQuickContext2D::TextAlignType textAlign;
+        QQuickContext2D::TextBaseLineType textBaseline;
+    };
+
+    QQuickContext2D(QObject *parent = nullptr);
+    ~QQuickContext2D();
+
+    QStringList contextNames() const override;
+    void init(QQuickCanvasItem *canvasItem, const QVariantMap &args) override;
+    void prepare(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing) override;
+    void flush() override;
+    void sync();
+    QThread *thread() const { return m_thread; }
+    QQuickContext2DTexture *texture() const;
+    QImage toImage(const QRectF& bounds) override;
+
+    QV4::ReturnedValue v4value() const override;
+    QV4::ExecutionEngine *v4Engine() const override;
+    void setV4Engine(QV4::ExecutionEngine *eng) override;
+
+    QQuickCanvasItem* canvas() const { return m_canvas; }
+    QQuickContext2DCommandBuffer* buffer() const { return m_buffer; }
+
+    bool bufferValid() const { return m_buffer != nullptr; }
+    void popState();
+    void pushState();
+    void reset();
+
+    void fill();
+    void clip();
+    void stroke();
+    void fillRect(qreal x, qreal y, qreal w, qreal h);
+    void strokeRect(qreal x, qreal y, qreal w, qreal h);
+    void clearRect(qreal x, qreal y, qreal w, qreal h);
+    void drawText(const QString& text, qreal x, qreal y, bool fill);
+
+    //Transform APIs
+    void scale(qreal x,  qreal y);
+    void rotate(qreal angle);
+    void shear(qreal h, qreal v);
+    void translate(qreal x, qreal y);
+    void transform(qreal a, qreal b, qreal c, qreal d, qreal e, qreal f);
+    void setTransform(qreal a, qreal b, qreal c, qreal d, qreal e, qreal f);
+
+    // Path APIs
+    void beginPath();
+    void closePath();
+    void moveTo(qreal x, qreal y);
+    void lineTo(qreal x, qreal y);
+    void quadraticCurveTo(qreal cpx, qreal cpy, qreal x, qreal y);
+    void bezierCurveTo(qreal cp1x, qreal cp1y,
+                       qreal cp2x, qreal cp2y, qreal x, qreal y);
+    void arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius);
+    void rect(qreal x, qreal y, qreal w, qreal h);
+    void roundedRect(qreal x, qreal y,qreal w, qreal h, qreal xr, qreal yr);
+    void ellipse(qreal x, qreal y,qreal w, qreal h);
+    void text(const QString& str, qreal x, qreal y);
+    void arc(qreal x, qreal y, qreal radius,
+             qreal startAngle, qreal endAngle,
+             bool anticlockwise);
+    void addArcTo(const QPointF& p1, const QPointF& p2, qreal radius);
+
+    bool isPointInPath(qreal x, qreal y) const;
+
+    QPainterPath createTextGlyphs(qreal x, qreal y, const QString& text);
+    QQmlRefPointer<QQuickCanvasPixmap> createPixmap(const QUrl& url, QSizeF sourceSize = QSizeF());
+
+    QSurface *surface() const { return m_surface.data(); }
+    void setGrabbedImage(const QImage& grab);
+
+    State state;
+    QStack<QQuickContext2D::State> m_stateStack;
+    QQuickCanvasItem* m_canvas;
+    QQuickContext2DCommandBuffer* m_buffer;
+    QPainterPath m_path;
+    QV4::PersistentValue m_fillStyle;
+    QV4::PersistentValue m_strokeStyle;
+    QV4::PersistentValue m_v4path;
+    QV4::ExecutionEngine *m_v4engine;
+    QScopedPointer<QOffscreenSurface> m_surface;
+    QV4::PersistentValue m_v4value;
+    QQuickContext2DTexture *m_texture;
+    QQuickCanvasItem::RenderTarget m_renderTarget;
+    QQuickCanvasItem::RenderStrategy m_renderStrategy;
+    QQueue<QQuickContext2DCommandBuffer*> m_bufferQueue;
+    QThread *m_thread;
+    QImage m_grabbedImage;
+    bool m_grabbed:1;
+
+    static QMutex mutex;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKCONTEXT2D_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcontext2dcommandbuffer_p.h

@@ -0,0 +1,260 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCONTEXT2DCOMMANDBUFFER_P_H
+#define QQUICKCONTEXT2DCOMMANDBUFFER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include <QtCore/qmutex.h>
+#include "qquickcontext2d_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickCanvasItem;
+class QMutex;
+
+class QQuickContext2DCommandBuffer
+{
+public:
+    QQuickContext2DCommandBuffer();
+    ~QQuickContext2DCommandBuffer();
+    void reset();
+    void clear();
+
+    inline int size() const { return commands.size(); }
+    inline bool isEmpty() const {return commands.isEmpty(); }
+    inline bool hasNext() const {return cmdIdx < commands.size(); }
+    inline QQuickContext2D::PaintCommand takeNextCommand() { return commands.at(cmdIdx++); }
+
+    inline qreal takeGlobalAlpha() { return takeReal(); }
+    inline QPainter::CompositionMode takeGlobalCompositeOperation(){ return static_cast<QPainter::CompositionMode>(takeInt()); }
+    inline QBrush takeStrokeStyle() { return takeBrush(); }
+    inline QBrush takeFillStyle() { return takeBrush(); }
+
+    inline qreal takeLineWidth() { return takeReal(); }
+    inline Qt::PenCapStyle takeLineCap() { return static_cast<Qt::PenCapStyle>(takeInt());}
+    inline Qt::PenJoinStyle takeLineJoin(){ return static_cast<Qt::PenJoinStyle>(takeInt());}
+    inline qreal takeMiterLimit() { return takeReal(); }
+
+    inline void setGlobalAlpha( qreal alpha)
+    {
+        commands << QQuickContext2D::GlobalAlpha;
+        reals << alpha;
+    }
+
+    inline void setGlobalCompositeOperation(QPainter::CompositionMode cm)
+    {
+        commands << QQuickContext2D::GlobalCompositeOperation;
+        ints << cm;
+    }
+
+    inline void setStrokeStyle(const QBrush &style, bool repeatX = false, bool repeatY = false)
+    {
+        commands << QQuickContext2D::StrokeStyle;
+        brushes << style;
+        bools << repeatX << repeatY;
+    }
+
+    inline void drawImage(const QImage& image,  const QRectF& sr, const QRectF& dr)
+    {
+        commands << QQuickContext2D::DrawImage;
+        images << image;
+        rects << sr << dr;
+    }
+
+    inline void drawPixmap(QQmlRefPointer<QQuickCanvasPixmap> pixmap, const QRectF& sr, const QRectF& dr)
+    {
+        commands << QQuickContext2D::DrawPixmap;
+        pixmaps << pixmap;
+        rects << sr << dr;
+    }
+
+    inline qreal takeShadowOffsetX() { return takeReal(); }
+    inline qreal takeShadowOffsetY() { return takeReal(); }
+    inline qreal takeShadowBlur() { return takeReal(); }
+    inline QColor takeShadowColor() { return takeColor(); }
+
+
+    inline void updateMatrix(const QTransform& matrix)
+    {
+        commands << QQuickContext2D::UpdateMatrix;
+        matrixes << matrix;
+    }
+
+    inline void clearRect(const QRectF& r)
+    {
+        commands << QQuickContext2D::ClearRect;
+        rects << r;
+    }
+
+    inline void fillRect(const QRectF& r)
+    {
+        commands << QQuickContext2D::FillRect;
+        rects << r;
+    }
+
+    inline void strokeRect(const QRectF& r)
+    {
+        QPainterPath p;
+        p.addRect(r);
+
+        commands << QQuickContext2D::Stroke;
+        pathes << p;
+    }
+
+
+    inline void fill(const QPainterPath& path)
+    {
+        commands << QQuickContext2D::Fill;
+        pathes << path;
+
+    }
+
+    inline void stroke(const QPainterPath& path)
+    {
+        commands << QQuickContext2D::Stroke;
+        pathes << path;
+    }
+
+    inline void clip(bool enabled, const QPainterPath& path)
+    {
+        commands << QQuickContext2D::Clip;
+        bools << enabled;
+        pathes << path;
+    }
+
+
+
+    inline void setFillStyle(const QBrush &style, bool repeatX = false, bool repeatY = false)
+    {
+        commands << QQuickContext2D::FillStyle;
+        brushes << style;
+        bools << repeatX << repeatY;
+    }
+
+
+    inline void setLineWidth( qreal w)
+    {
+        commands << QQuickContext2D::LineWidth;
+        reals << w;
+    }
+
+    inline void setLineCap(Qt::PenCapStyle  cap)
+    {
+        commands << QQuickContext2D::LineCap;
+        ints << cap;
+    }
+
+    inline void setLineJoin(Qt::PenJoinStyle join)
+    {
+        commands << QQuickContext2D::LineJoin;
+        ints << join;
+    }
+
+    inline void setLineDash(const QVector<qreal> &pattern)
+    {
+        commands << QQuickContext2D::LineDash;
+        reals << pattern.size();
+        for (qreal r : pattern)
+            reals << r;
+    }
+
+    inline void setLineDashOffset( qreal offset)
+    {
+        commands << QQuickContext2D::LineDashOffset;
+        reals << offset;
+    }
+
+    inline void setMiterLimit( qreal limit)
+    {
+        commands << QQuickContext2D::MiterLimit;
+        reals << limit;
+    }
+
+    inline void setShadowOffsetX( qreal x)
+    {
+        commands << QQuickContext2D::ShadowOffsetX;
+        reals << x;
+    }
+
+    inline void setShadowOffsetY( qreal y)
+    {
+        commands << QQuickContext2D::ShadowOffsetY;
+        reals << y;
+    }
+
+    inline void setShadowBlur( qreal b)
+    {
+        commands << QQuickContext2D::ShadowBlur;
+        reals << b;
+    }
+
+    inline void setShadowColor(const QColor &color)
+    {
+        commands << QQuickContext2D::ShadowColor;
+        colors << color;
+    }
+
+    inline QTransform takeMatrix() { return matrixes.at(matrixIdx++); }
+
+    inline QRectF takeRect() { return rects.at(rectIdx++); }
+
+    inline QPainterPath takePath() { return pathes.at(pathIdx++); }
+
+    inline const QImage& takeImage() { return images.at(imageIdx++); }
+    inline QQmlRefPointer<QQuickCanvasPixmap> takePixmap() { return pixmaps.at(pixmapIdx++); }
+
+    inline int takeInt() { return ints.at(intIdx++); }
+    inline bool takeBool() {return bools.at(boolIdx++); }
+    inline qreal takeReal() { return reals.at(realIdx++); }
+    inline QColor takeColor() { return colors.at(colorIdx++); }
+    inline QBrush takeBrush() { return brushes.at(brushIdx++); }
+
+    void replay(QPainter* painter, QQuickContext2D::State& state, const QVector2D &scaleFactor);
+
+private:
+    static QPen makePen(const QQuickContext2D::State& state);
+    void setPainterState(QPainter* painter, const QQuickContext2D::State& state, const QPen& pen);
+    int cmdIdx;
+    int intIdx;
+    int boolIdx;
+    int realIdx;
+    int rectIdx;
+    int colorIdx;
+    int matrixIdx;
+    int brushIdx;
+    int pathIdx;
+    int imageIdx;
+    int pixmapIdx;
+    QVector<QQuickContext2D::PaintCommand> commands;
+
+    QVector<int> ints;
+    QVector<bool> bools;
+    QVector<qreal> reals;
+    QVector<QRectF> rects;
+    QVector<QColor> colors;
+    QVector<QTransform> matrixes;
+    QVector<QBrush> brushes;
+    QVector<QPainterPath> pathes;
+    QVector<QImage> images;
+    QVector<QQmlRefPointer<QQuickCanvasPixmap> > pixmaps;
+    QMutex queueLock;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKCONTEXT2DCOMMANDBUFFER_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcontext2dtexture_p.h

@@ -0,0 +1,165 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCONTEXT2DTEXTURE_P_H
+#define QQUICKCONTEXT2DTEXTURE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include <QtQuick/qsgtexture.h>
+#include "qquickcanvasitem_p.h"
+#include "qquickcontext2d_p.h"
+#include <QtCore/QMutex>
+#include <QtCore/QWaitCondition>
+#include <QtCore/QThread>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickContext2DTile;
+class QQuickContext2DCommandBuffer;
+
+class QQuickContext2DTexture : public QObject
+{
+    Q_OBJECT
+public:
+    class PaintEvent : public QEvent {
+    public:
+        PaintEvent(QQuickContext2DCommandBuffer *b) : QEvent(QEvent::Type(QEvent::User + 1)), buffer(b) {}
+        QQuickContext2DCommandBuffer *buffer;
+    };
+
+    class CanvasChangeEvent : public QEvent {
+    public:
+        CanvasChangeEvent(const QSize &cSize,
+                          const QSize &tSize,
+                          const QRect &cWindow,
+                          const QRect &dRect,
+                          bool sm,
+                          bool aa)
+            : QEvent(QEvent::Type(QEvent::User + 2))
+            , canvasSize(cSize)
+            , tileSize(tSize)
+            , canvasWindow(cWindow)
+            , dirtyRect(dRect)
+            , smooth(sm)
+            , antialiasing(aa)
+        {
+        }
+        QSize canvasSize;
+        QSize tileSize;
+        QRect canvasWindow;
+        QRect dirtyRect;
+        bool smooth;
+        bool antialiasing;
+    };
+
+    QQuickContext2DTexture();
+    ~QQuickContext2DTexture();
+
+    virtual QQuickCanvasItem::RenderTarget renderTarget() const = 0;
+    static QRect tiledRect(const QRectF& window, const QSize& tileSize);
+
+    bool setCanvasSize(const QSize &size);
+    bool setTileSize(const QSize &size);
+    bool setCanvasWindow(const QRect& canvasWindow);
+    void setSmooth(bool smooth);
+    void setAntialiasing(bool antialiasing);
+    bool setDirtyRect(const QRect &dirtyRect);
+    bool canvasDestroyed();
+    void setOnCustomThread(bool is) { m_onCustomThread = is; }
+    bool isOnCustomThread() const { return m_onCustomThread; }
+
+    // Called during sync() on the scene graph thread while GUI is blocked.
+    virtual QSGTexture *textureForNextFrame(QSGTexture *lastFrame, QQuickWindow *window) = 0;
+    bool event(QEvent *e) override;
+
+Q_SIGNALS:
+    void textureChanged();
+
+public Q_SLOTS:
+    void canvasChanged(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing);
+    void paint(QQuickContext2DCommandBuffer *ccb);
+    void markDirtyTexture();
+    void setItem(QQuickCanvasItem* item);
+    virtual void grabImage(const QRectF& region = QRectF()) = 0;
+
+protected:
+    virtual QVector2D scaleFactor() const { return QVector2D(1, 1); }
+
+    void paintWithoutTiles(QQuickContext2DCommandBuffer *ccb);
+    virtual QPaintDevice* beginPainting() {m_painting = true; return nullptr; }
+    virtual void endPainting() {m_painting = false;}
+    virtual QQuickContext2DTile* createTile() const = 0;
+    virtual void compositeTile(QQuickContext2DTile* tile) = 0;
+
+    void clearTiles();
+    virtual QSize adjustedTileSize(const QSize &ts);
+    QRect createTiles(const QRect& window);
+
+    QList<QQuickContext2DTile*> m_tiles;
+    QQuickContext2D *m_context;
+    QSurface *m_surface;
+
+    QQuickContext2D::State m_state;
+
+    QQuickCanvasItem* m_item;
+    QSize m_canvasSize;
+    QSize m_tileSize;
+    QRect m_canvasWindow;
+    qreal m_canvasDevicePixelRatio;
+
+    QMutex m_mutex;
+    QWaitCondition m_condition;
+
+    uint m_canvasWindowChanged : 1;
+    uint m_dirtyTexture : 1;
+    uint m_smooth : 1;
+    uint m_antialiasing : 1;
+    uint m_tiledCanvas : 1;
+    uint m_painting : 1;
+    uint m_onCustomThread : 1; // Not GUI and not SGRender
+};
+
+class QSGPlainTexture;
+class QQuickContext2DImageTexture : public QQuickContext2DTexture
+{
+    Q_OBJECT
+
+public:
+    QQuickContext2DImageTexture();
+    ~QQuickContext2DImageTexture();
+
+    QQuickCanvasItem::RenderTarget renderTarget() const override;
+
+    QQuickContext2DTile* createTile() const override;
+    QPaintDevice* beginPainting() override;
+    void endPainting() override;
+    void compositeTile(QQuickContext2DTile* tile) override;
+
+    QSGTexture *textureForNextFrame(QSGTexture *lastFrame, QQuickWindow *window) override;
+
+public Q_SLOTS:
+    void grabImage(const QRectF& region = QRectF()) override;
+
+private:
+    QImage m_image;
+    QImage m_displayImage;
+    QPainter m_painter;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKCONTEXT2DTEXTURE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickcontext2dtile_p.h

@@ -0,0 +1,63 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKCONTEXT2DTILE_P_H
+#define QQUICKCONTEXT2DTILE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+QT_REQUIRE_CONFIG(quick_canvas);
+
+#include "qquickcontext2d_p.h"
+QT_BEGIN_NAMESPACE
+
+class QQuickContext2DTexture;
+class QQuickContext2DCommandBuffer;
+
+class QQuickContext2DTile
+{
+public:
+    QQuickContext2DTile();
+    virtual ~QQuickContext2DTile();
+
+    bool dirty() const {return m_dirty;}
+    void markDirty(bool dirty) {m_dirty = dirty;}
+
+    QRect rect() const {return m_rect;}
+
+    virtual void setRect(const QRect& r) = 0;
+    virtual QPainter* createPainter(bool smooth, bool antialiasing);
+    virtual void drawFinished() {}
+
+protected:
+    virtual void aboutToDraw() {}
+    uint m_dirty : 1;
+    QRect m_rect;
+    QPaintDevice* m_device;
+    QPainter m_painter;
+};
+
+class QQuickContext2DImageTile : public QQuickContext2DTile
+{
+public:
+    QQuickContext2DImageTile();
+    ~QQuickContext2DImageTile();
+    void setRect(const QRect& r) override;
+    const QImage& image() const {return m_image;}
+private:
+    QImage m_image;
+};
+QT_END_NAMESPACE
+
+#endif // QQUICKCONTEXT2DTILE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdeliveryagent_p.h

@@ -0,0 +1,64 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDELIVERYAGENT_P_H
+#define QQUICKDELIVERYAGENT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/private/qtquickglobal_p.h>
+
+#include <QtQml/qqml.h>
+#include <QtQml/private/qqmlglobal_p.h>
+
+#include <QtCore/qobject.h>
+#include <QtGui/qevent.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QQuickDeliveryAgentPrivate;
+
+class Q_QUICK_EXPORT QQuickDeliveryAgent : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickDeliveryAgent)
+
+public:
+    struct Q_QUICK_EXPORT Transform
+    {
+        virtual ~Transform();
+        virtual QPointF map(const QPointF &point) = 0;
+    };
+
+    explicit QQuickDeliveryAgent(QQuickItem *rootItem);
+    virtual ~QQuickDeliveryAgent();
+
+    QQuickItem *rootItem() const;
+
+    Transform *sceneTransform() const;
+    void setSceneTransform(Transform *transform);
+    bool event(QEvent *ev) override;
+
+Q_SIGNALS:
+
+private:
+    Q_DISABLE_COPY(QQuickDeliveryAgent)
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug Q_QUICK_EXPORT operator<<(QDebug debug, const QQuickDeliveryAgent *da);
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QQUICKDELIVERYAGENT_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdeliveryagent_p_p.h

@@ -0,0 +1,204 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDELIVERYAGENT_P_P_H
+#define QQUICKDELIVERYAGENT_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/private/qquickdeliveryagent_p.h>
+#include <QtGui/qevent.h>
+#include <QtCore/qstack.h>
+
+#include <private/qevent_p.h>
+#include <private/qpointingdevice_p.h>
+
+#include <QtCore/qpointer.h>
+#include <private/qobject_p.h>
+
+#include <memory>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickDragGrabber;
+class QQuickItem;
+class QQuickPointerHandler;
+class QQuickWindow;
+
+/*! \internal
+    Extra device-specific data to be stored in QInputDevicePrivate::qqExtra
+*/
+struct QQuickPointingDeviceExtra {
+    // used in QQuickPointerHandlerPrivate::deviceDeliveryTargets
+    QVector<QObject *> deliveryTargets;
+};
+
+class Q_QUICK_EXPORT QQuickDeliveryAgentPrivate : public QObjectPrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QQuickDeliveryAgent)
+    QQuickDeliveryAgentPrivate(QQuickItem *root);
+    ~QQuickDeliveryAgentPrivate();
+
+    QQuickItem *rootItem = nullptr;
+
+    QQuickItem *activeFocusItem = nullptr;
+
+    void deliverKeyEvent(QKeyEvent *e);
+
+    enum FocusOption {
+        DontChangeFocusProperty = 0x01,
+        DontChangeSubFocusItem  = 0x02
+    };
+    Q_DECLARE_FLAGS(FocusOptions, FocusOption)
+
+    void setFocusInScope(QQuickItem *scope, QQuickItem *item, Qt::FocusReason reason, FocusOptions = { });
+    void clearFocusInScope(QQuickItem *scope, QQuickItem *item, Qt::FocusReason reason, FocusOptions = { });
+    static void notifyFocusChangesRecur(QQuickItem **item, int remaining, Qt::FocusReason reason);
+    void clearFocusObject();
+    void updateFocusItemTransform();
+
+    QQuickItem *focusTargetItem() const;
+
+    // Keeps track of the item currently receiving mouse events
+#if QT_CONFIG(quick_draganddrop)
+    QQuickDragGrabber *dragGrabber = nullptr;
+#endif
+    QQuickItem *lastUngrabbed = nullptr;
+    QStack<QPointerEvent *> eventsInDelivery;
+    QFlatMap<QPointer<QQuickItem>, uint> hoverItems;
+    QVector<QQuickItem *> hasFiltered; // during event delivery to a single receiver, the filtering parents for which childMouseEventFilter was already called
+    QVector<QQuickItem *> skipDelivery; // during delivery of one event to all receivers, Items to which we know delivery is no longer necessary
+
+    std::unique_ptr<QMutableTouchEvent> delayedTouch;
+    QList<const QPointingDevice *> knownPointingDevices;
+
+    uint currentHoverId = 0;
+#if QT_CONFIG(wheelevent)
+    uint lastWheelEventAccepted = 0;
+#endif
+    uchar compressedTouchCount = 0;
+    bool allowChildEventFiltering = true;
+    bool frameSynchronousHoverEnabled = true;
+    bool hoveredLeafItemFound = false;
+
+    bool isSubsceneAgent = false;
+    static bool subsceneAgentsExist;
+    // QQuickDeliveryAgent::event() sets this to the one that's currently (trying to) handle the event
+    static QQuickDeliveryAgent *currentEventDeliveryAgent;
+    static QQuickDeliveryAgent *currentOrItemDeliveryAgent(const QQuickItem *item);
+
+    Qt::FocusReason lastFocusReason = Qt::OtherFocusReason;
+    int pointerEventRecursionGuard = 0;
+
+    int touchMouseId = -1; // only for obsolete stuff like QQuickItem::grabMouse()
+    // TODO get rid of these
+    const QPointingDevice *touchMouseDevice = nullptr;
+    ulong touchMousePressTimestamp = 0;
+    QPoint touchMousePressPos;      // in screen coordinates
+
+    QQuickDeliveryAgent::Transform *sceneTransform = nullptr;
+
+    bool isDeliveringTouchAsMouse() const { return touchMouseId != -1 && touchMouseDevice; }
+    void cancelTouchMouseSynthesis();
+
+    bool checkIfDoubleTapped(ulong newPressEventTimestamp, const QPoint &newPressPos);
+    void resetIfDoubleTapPrevented(const QEventPoint &pressedPoint);
+    QPointingDevicePrivate::EventPointData *mousePointData();
+    QPointerEvent *eventInDelivery() const;
+
+    // Mouse positions are saved in widget coordinates
+    QPointF lastMousePosition;
+    bool deliverTouchAsMouse(QQuickItem *item, QTouchEvent *pointerEvent);
+    void translateTouchEvent(QTouchEvent *touchEvent);
+    void removeGrabber(QQuickItem *grabber, bool mouse = true, bool touch = true, bool cancel = false);
+    void clearGrabbers(QPointerEvent *pointerEvent);
+    void onGrabChanged(QObject *grabber, QPointingDevice::GrabTransition transition, const QPointerEvent *event, const QEventPoint &point);
+    static QPointerEvent *clonePointerEvent(QPointerEvent *event, std::optional<QPointF> transformedLocalPos = std::nullopt);
+    void deliverToPassiveGrabbers(const QVector<QPointer<QObject> > &passiveGrabbers, QPointerEvent *pointerEvent);
+    bool sendFilteredMouseEvent(QEvent *event, QQuickItem *receiver, QQuickItem *filteringParent);
+    bool sendFilteredPointerEvent(QPointerEvent *event, QQuickItem *receiver, QQuickItem *filteringParent = nullptr);
+    bool sendFilteredPointerEventImpl(QPointerEvent *event, QQuickItem *receiver, QQuickItem *filteringParent);
+    bool deliverSinglePointEventUntilAccepted(QPointerEvent *);
+
+    // entry point of events to the window
+    void handleTouchEvent(QTouchEvent *);
+    void handleMouseEvent(QMouseEvent *);
+    bool compressTouchEvent(QTouchEvent *);
+    void flushFrameSynchronousEvents(QQuickWindow *win);
+    void deliverDelayedTouchEvent();
+    void handleWindowDeactivate(QQuickWindow *win);
+    void handleWindowHidden(QQuickWindow *win);
+
+    // utility functions that used to be in QQuickPointerEvent et al.
+    bool allUpdatedPointsAccepted(const QPointerEvent *ev);
+    static void localizePointerEvent(QPointerEvent *ev, const QQuickItem *dest);
+    QList<QObject *> exclusiveGrabbers(QPointerEvent *ev);
+    static bool anyPointGrabbed(const QPointerEvent *ev);
+    static bool allPointsGrabbed(const QPointerEvent *ev);
+    static bool isMouseEvent(const QPointerEvent *ev);
+    static bool isMouseOrWheelEvent(const QPointerEvent *ev);
+    static bool isHoverEvent(const QPointerEvent *ev);
+    static bool isTouchEvent(const QPointerEvent *ev);
+    static bool isTabletEvent(const QPointerEvent *ev);
+    static bool isEventFromMouseOrTouchpad(const QPointerEvent *ev);
+    static bool isSynthMouse(const QPointerEvent *ev);
+    static bool isWithinDoubleClickInterval(ulong timeInterval);
+    static bool isWithinDoubleTapDistance(const QPoint &distanceBetweenPresses);
+    static bool isSinglePointDevice(const QInputDevice *dev);
+    static QQuickPointingDeviceExtra *deviceExtra(const QInputDevice *device);
+
+    // delivery of pointer events:
+    void touchToMouseEvent(QEvent::Type type, const QEventPoint &p, const QTouchEvent *touchEvent, QMutableSinglePointEvent *mouseEvent);
+    void ensureDeviceConnected(const QPointingDevice *dev);
+    void deliverPointerEvent(QPointerEvent *);
+    bool deliverTouchCancelEvent(QTouchEvent *);
+    bool deliverPressOrReleaseEvent(QPointerEvent *, bool handlersOnly = false);
+    void deliverUpdatedPoints(QPointerEvent *event);
+    void deliverMatchingPointsToItem(QQuickItem *item, bool isGrabber, QPointerEvent *pointerEvent, bool handlersOnly = false);
+
+    QVector<QQuickItem *> pointerTargets(QQuickItem *, const QPointerEvent *event, const QEventPoint &point,
+                                         bool checkMouseButtons, bool checkAcceptsTouch) const;
+    QVector<QQuickItem *> mergePointerTargets(const QVector<QQuickItem *> &list1, const QVector<QQuickItem *> &list2) const;
+
+    // hover delivery
+    enum class HoverChange : uint8_t {
+        Clear,
+        Set,
+    };
+    bool deliverHoverEvent(const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, ulong timestamp);
+    bool deliverHoverEventRecursive(QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, ulong timestamp);
+    bool deliverHoverEventToItem(QQuickItem *item, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, ulong timestamp,
+                                 HoverChange hoverChange);
+    bool sendHoverEvent(QEvent::Type, QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos,
+                        Qt::KeyboardModifiers modifiers, ulong timestamp);
+    bool clearHover(ulong timestamp = 0);
+
+#if QT_CONFIG(quick_draganddrop)
+    void deliverDragEvent(QQuickDragGrabber *, QEvent *);
+    bool deliverDragEvent(QQuickDragGrabber *, QQuickItem *, QDragMoveEvent *,
+                          QVarLengthArray<QQuickItem *, 64> *currentGrabItems = nullptr,
+                          QObject *formerTarget = nullptr);
+#endif
+
+    static bool dragOverThreshold(qreal d, Qt::Axis axis, QMouseEvent *event, int startDragThreshold = -1);
+
+    static bool dragOverThreshold(qreal d, Qt::Axis axis, const QEventPoint &tp, int startDragThreshold = -1);
+
+    static bool dragOverThreshold(QVector2D delta);
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickDeliveryAgentPrivate::FocusOptions)
+
+QT_END_NAMESPACE
+
+#endif // QQUICKDELIVERYAGENT_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignercustomobjectdata_p.h

@@ -0,0 +1,70 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERCUSTOMOBJECTDATA_H
+#define DESIGNERCUSTOMOBJECTDATA_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QHash>
+#include <QObject>
+#include <QVariant>
+
+#include <private/qqmlanybinding_p.h>
+
+QT_BEGIN_NAMESPACE
+class QQmlContext;
+
+class QQuickDesignerCustomObjectData
+{
+public:
+    static void registerData(QObject *object);
+    static QQuickDesignerCustomObjectData *get(QObject *object);
+    static QVariant getResetValue(QObject *object, const QQuickDesignerSupport::PropertyName &propertyName);
+    static void doResetProperty(QObject *object, QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName);
+    static bool hasValidResetBinding(QObject *object, const QQuickDesignerSupport::PropertyName &propertyName);
+    static bool hasBindingForProperty(QObject *object,
+                                      QQmlContext *context,
+                                      const QQuickDesignerSupport::PropertyName &propertyName,
+                                      bool *hasChanged);
+    static void setPropertyBinding(QObject *object,
+                                   QQmlContext *context,
+                                   const QQuickDesignerSupport::PropertyName &propertyName,
+                                   const QString &expression);
+    static void keepBindingFromGettingDeleted(QObject *object,
+                                              QQmlContext *context,
+                                              const QQuickDesignerSupport::PropertyName &propertyName);
+    void handleDestroyed();
+
+private:
+    QQuickDesignerCustomObjectData(QObject *object);
+    void populateResetHashes();
+    QObject *object() const;
+    QVariant getResetValue(const QQuickDesignerSupport::PropertyName &propertyName) const;
+    void doResetProperty(QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName);
+    bool hasValidResetBinding(const QQuickDesignerSupport::PropertyName &propertyName) const;
+    QQmlAnyBinding getResetBinding(const QQuickDesignerSupport::PropertyName &propertyName) const;
+    bool hasBindingForProperty(QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName, bool *hasChanged) const;
+    void setPropertyBinding(QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName, const QString &expression);
+    void keepBindingFromGettingDeleted(QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName);
+
+    QObject *m_object;
+    QHash<QQuickDesignerSupport::PropertyName, QVariant> m_resetValueHash;
+    QHash<QQuickDesignerSupport::PropertyName, QQmlAnyBinding> m_resetBindingHash;
+    mutable QHash<QQuickDesignerSupport::PropertyName, bool> m_hasBindingHash;
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERCUSTOMOBJECTDATA_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignercustomparserobject_p.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QUICKDESIGNERCUSTOMPARSEROBJECT_H
+#define QUICKDESIGNERCUSTOMPARSEROBJECT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QObject>
+#include <private/qqmlcustomparser_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickDesignerCustomParserObject : public QObject
+{
+    Q_OBJECT
+
+public:
+    QQuickDesignerCustomParserObject();
+};
+
+class QQuickDesignerCustomParser : public QQmlCustomParser
+{
+public:
+    QQuickDesignerCustomParser()
+    : QQmlCustomParser(AcceptsAttachedProperties | AcceptsSignalHandlers) {}
+
+    void verifyBindings(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, const QList<const QV4::CompiledData::Binding *> &props) override;
+    void applyBindings(QObject *obj, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, const QList<const QV4::CompiledData::Binding *> &bindings) override;
+};
+
+QT_END_NAMESPACE
+
+#endif // QUICKDESIGNERCUSTOMPARSEROBJECT_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupport_p.h

@@ -0,0 +1,134 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORT_H
+#define DESIGNERSUPPORT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qtquickglobal.h>
+#include <QtCore/QtGlobal>
+#include <QtCore/QHash>
+#include <QtCore/QRectF>
+#include <QtCore/private/qglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QSGLayer;
+class QImage;
+class QTransform;
+class QQmlContext;
+class QQuickView;
+class QObject;
+class QQuickWindow;
+
+class Q_QUICK_EXPORT QQuickDesignerSupport
+{
+public:
+    typedef QByteArray PropertyName;
+    typedef QList<PropertyName> PropertyNameList;
+    typedef QByteArray TypeName;
+
+    enum DirtyType {
+        TransformOrigin         = 0x00000001,
+        Transform               = 0x00000002,
+        BasicTransform          = 0x00000004,
+        Position                = 0x00000008,
+        Size                    = 0x00000010,
+
+        ZValue                  = 0x00000020,
+        Content                 = 0x00000040,
+        Smooth                  = 0x00000080,
+        OpacityValue            = 0x00000100,
+        ChildrenChanged         = 0x00000200,
+        ChildrenStackingChanged = 0x00000400,
+        ParentChanged           = 0x00000800,
+
+        Clip                    = 0x00001000,
+        Window                  = 0x00002000,
+
+        EffectReference         = 0x00008000,
+        Visible                 = 0x00010000,
+        HideReference           = 0x00020000,
+
+        TransformUpdateMask     = TransformOrigin | Transform | BasicTransform | Position | Size | Window,
+        ComplexTransformUpdateMask     = Transform | Window,
+        ContentUpdateMask       = Size | Content | Smooth | Window,
+        ChildrenUpdateMask      = ChildrenChanged | ChildrenStackingChanged | EffectReference | Window,
+        AllMask                 = TransformUpdateMask | ContentUpdateMask | ChildrenUpdateMask
+    };
+
+
+    QQuickDesignerSupport();
+    ~QQuickDesignerSupport();
+
+    void refFromEffectItem(QQuickItem *referencedItem, bool hide = true);
+    void derefFromEffectItem(QQuickItem *referencedItem, bool unhide = true);
+
+    QImage renderImageForItem(QQuickItem *referencedItem, const QRectF &boundingRect, const QSize &imageSize);
+
+    static bool isDirty(QQuickItem *referencedItem, DirtyType dirtyType);
+    static void addDirty(QQuickItem *referencedItem, DirtyType dirtyType);
+    static void resetDirty(QQuickItem *referencedItem);
+
+    static QTransform windowTransform(QQuickItem *referencedItem);
+    static QTransform parentTransform(QQuickItem *referencedItem);
+
+    static bool isAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem);
+    static bool areChildrenAnchoredTo(QQuickItem *fromItem, QQuickItem *toItem);
+    static bool hasAnchor(QQuickItem *item, const QString &name);
+    static QQuickItem *anchorFillTargetItem(QQuickItem *item);
+    static QQuickItem *anchorCenterInTargetItem(QQuickItem *item);
+    static QPair<QString, QObject*> anchorLineTarget(QQuickItem *item, const QString &name, QQmlContext *context);
+    static void resetAnchor(QQuickItem *item, const QString &name);
+    static void emitComponentCompleteSignalForAttachedProperty(QObject *item);
+
+    static QList<QObject*> statesForItem(QQuickItem *item);
+
+    static bool isComponentComplete(QQuickItem *item);
+
+    static int borderWidth(QQuickItem *item);
+
+    static void refreshExpressions(QQmlContext *context);
+
+    static void setRootItem(QQuickView *view, QQuickItem *item);
+
+    static bool isValidWidth(QQuickItem *item);
+    static bool isValidHeight(QQuickItem *item);
+
+    static void updateDirtyNode(QQuickItem *item);
+
+    static void activateDesignerMode();
+
+    static void disableComponentComplete();
+    static void enableComponentComplete();
+
+    static void polishItems(QQuickWindow *window);
+
+private:
+    QHash<QQuickItem*, QSGLayer*> m_itemTextureHash;
+};
+
+class Q_QUICK_EXPORT ComponentCompleteDisabler
+{
+public:
+    ComponentCompleteDisabler();
+
+    ~ComponentCompleteDisabler();
+};
+
+typedef QQuickDesignerSupport DesignerSupport;
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORT_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupportitems_p.h

@@ -0,0 +1,48 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORTITEM_H
+#define DESIGNERSUPPORTITEM_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QObject>
+#include <QString>
+#include <QVariant>
+#include <QList>
+#include <QByteArray>
+#include <QTypeRevision>
+#include <QQmlContext>
+#include <QQmlListReference>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDesignerSupportItems
+{
+public:
+    static QObject *createPrimitive(const QString &typeName, QTypeRevision version, QQmlContext *context);
+    static QObject *createComponent(const QUrl &componentUrl, QQmlContext *context);
+    static void tweakObjects(QObject *object);
+    static bool objectWasDeleted(QObject *object);
+    static void disableNativeTextRendering(QQuickItem *item);
+    static void disableTextCursor(QQuickItem *item);
+    static void disableTransition(QObject *object);
+    static void disableBehaivour(QObject *object);
+    static void stopUnifiedTimer();
+    static void registerFixResourcePathsForObjectCallBack(void (*callback)(QObject *));
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORTITEM_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupportmetainfo_p.h

@@ -0,0 +1,35 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORTMETAINFO_H
+#define DESIGNERSUPPORTMETAINFO_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QObject>
+#include <QByteArray>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDesignerSupportMetaInfo
+{
+public:
+    static bool isSubclassOf(QObject *object, const QByteArray &superTypeName);
+    static void registerNotifyPropertyChangeCallBack(void (*callback)(QObject *, const QQuickDesignerSupport::PropertyName &));
+    static void registerMockupObject(const char *uri, int versionMajor, int versionMinor, const char *qmlName);
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORTMETAINFO_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupportproperties_p.h

@@ -0,0 +1,67 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORTPROPERTIES_H
+#define DESIGNERSUPPORTPROPERTIES_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QObject>
+#include <QString>
+#include <QVariant>
+#include <QList>
+#include <QByteArray>
+#include <QQmlContext>
+#include <QQmlListReference>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDesignerSupportProperties
+{
+public:
+    static void createNewDynamicProperty(QObject *object, QQmlEngine *engine, const QString &name);
+    static void registerNodeInstanceMetaObject(QObject *object, QQmlEngine *engine);
+    static void registerCustomData(QObject *object);
+    static QVariant getResetValue(QObject *object, const QQuickDesignerSupport::PropertyName &propertyName);
+    static void doResetProperty(QObject *object, QQmlContext *context, const QQuickDesignerSupport::PropertyName &propertyName);
+    static bool hasValidResetBinding(QObject *object, const QQuickDesignerSupport::PropertyName &propertyName);
+
+    static bool hasBindingForProperty(QObject *object,
+                                      QQmlContext *context,
+                                      const QQuickDesignerSupport::PropertyName &propertyName,
+                                      bool *hasChanged);
+    static void setPropertyBinding(QObject *object,
+                                   QQmlContext *context,
+                                   const QQuickDesignerSupport::PropertyName &propertyName,
+                                   const QString &expression);
+    static void keepBindingFromGettingDeleted(QObject *object,
+                                              QQmlContext *context,
+                                              const QQuickDesignerSupport::PropertyName &propertyName);
+
+    static bool isPropertyQObject(const QMetaProperty &metaProperty);
+    static QObject *readQObjectProperty(const QMetaProperty &metaProperty, QObject *object);
+
+    static void getPropertyCache(QObject *object);
+    static bool isPropertyBlackListed(const QQuickDesignerSupport::PropertyName &propertyName);
+    static QQuickDesignerSupport::PropertyNameList propertyNameListForWritableProperties(QObject *object);
+    static QQuickDesignerSupport::PropertyNameList allPropertyNames(QObject *object,
+                                             const QQuickDesignerSupport::PropertyName &baseName = QQuickDesignerSupport::PropertyName(),
+                                             QObjectList *inspectedObjects = nullptr,
+                                             int depth = 0);
+    static bool hasFullImplementedListInterface(const QQmlListReference &list);
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORTPROPERTIES_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupportpropertychanges_p.h

@@ -0,0 +1,40 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORTPROPERTYCHANGES_H
+#define DESIGNERSUPPORTPROPERTYCHANGES_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDesignerSupportPropertyChanges
+{
+public:
+    static void detachFromState(QObject *propertyChanges);
+    static void attachToState(QObject *propertyChanges);
+    static QObject *targetObject(QObject *propertyChanges);
+    static void removeProperty(QObject *propertyChanges, const QQuickDesignerSupport::PropertyName &propertyName);
+    static QVariant getProperty(QObject *propertyChanges, const QQuickDesignerSupport::PropertyName &propertyName);
+    static void changeValue(QObject *propertyChanges, const QQuickDesignerSupport::PropertyName &propertyName, const QVariant &value);
+    static void changeExpression(QObject *propertyChanges, const QQuickDesignerSupport::PropertyName &propertyName, const QString &expression);
+    static QObject *stateObject(QObject *propertyChanges);
+    static bool isNormalProperty(const QQuickDesignerSupport::PropertyName &propertyName);
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORTPROPERTYCHANGES_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdesignersupportstates_p.h

@@ -0,0 +1,46 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef DESIGNERSUPPORTSTATES_H
+#define DESIGNERSUPPORTSTATES_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdesignersupport_p.h"
+
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QQuickDesignerSupportStates
+{
+public:
+    static bool isStateActive(QObject *object, QQmlContext *context);
+    static void activateState(QObject *object, QQmlContext *context);
+    static void deactivateState(QObject *object);
+    static bool changeValueInRevertList(QObject *state,
+                                        QObject *target,
+                                        const QQuickDesignerSupport::PropertyName &propertyName,
+                                        const QVariant &value);
+
+    static bool updateStateBinding(QObject *state, QObject *target,
+                                   const QQuickDesignerSupport::PropertyName &propertyName,
+                                   const QString &expression);
+
+    static bool resetStateProperty(QObject *state, QObject *target,
+                                   const QQuickDesignerSupport::PropertyName &propertyName,
+                                   const QVariant &);
+};
+
+QT_END_NAMESPACE
+
+#endif // DESIGNERSUPPORTSTATES_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdrag_p.h

@@ -0,0 +1,299 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDRAG_P_H
+#define QQUICKDRAG_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qquickitem.h>
+
+#include <private/qintrusivelist_p.h>
+#include <private/qqmlguard_p.h>
+#include <private/qtquickglobal_p.h>
+
+#include <QtCore/qmimedata.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qurl.h>
+
+QT_REQUIRE_CONFIG(quick_draganddrop);
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QQuickDrag;
+
+class QQuickDragGrabber
+{
+    class Item : public QQmlGuard<QQuickItem>
+    {
+    public:
+        Item(QQuickItem *item) : QQmlGuard<QQuickItem>(Item::objectDestroyedImpl, item) {}
+
+        QIntrusiveListNode node;
+    private:
+        static void objectDestroyedImpl(QQmlGuardImpl *guard) { delete static_cast<Item *>(guard); }
+    };
+
+    typedef QIntrusiveList<Item, &Item::node> ItemList;
+
+public:
+    QQuickDragGrabber() : m_target(nullptr) {}
+    ~QQuickDragGrabber() { while (!m_items.isEmpty()) delete m_items.first(); }
+
+
+    QObject *target() const
+    {
+        if (m_target)
+            return m_target;
+        else if (!m_items.isEmpty())
+            return *m_items.first();
+        else
+            return nullptr;
+    }
+    void setTarget(QObject *target) { m_target = target; }
+    void resetTarget() { m_target = nullptr; }
+
+    bool isEmpty() const { return m_items.isEmpty(); }
+
+    typedef ItemList::iterator iterator;
+    iterator begin() { return m_items.begin(); }
+    iterator end() { return m_items.end(); }
+
+    void grab(QQuickItem *item) { m_items.insert(new Item(item)); }
+    iterator release(iterator at) { Item *item = *at; at = at.erase(); delete item; return at; }
+
+    auto& ignoreList() { return m_ignoreDragItems; }
+
+private:
+
+    ItemList m_items;
+    QVarLengthArray<QQuickItem *, 4> m_ignoreDragItems;
+    QObject *m_target;
+};
+
+class QQuickDropEventEx : public QDropEvent
+{
+public:
+    void setProposedAction(Qt::DropAction action) { m_defaultAction = action; m_dropAction = action; }
+
+    static void setProposedAction(QDropEvent *event, Qt::DropAction action) {
+        static_cast<QQuickDropEventEx *>(event)->setProposedAction(action);
+    }
+
+    void copyActions(const QDropEvent &from) {
+        m_defaultAction = from.proposedAction(); m_dropAction = from.dropAction(); }
+
+    static void copyActions(QDropEvent *to, const QDropEvent &from) {
+        static_cast<QQuickDropEventEx *>(to)->copyActions(from);
+    }
+};
+
+class QQuickDragMimeData : public QMimeData
+{
+    Q_OBJECT
+public:
+    QQuickDragMimeData()
+        : m_source(nullptr)
+    {
+    }
+
+    QStringList keys() const { return m_keys; }
+    QObject *source() const { return m_source; }
+
+private:
+    QObject *m_source;
+    Qt::DropActions m_supportedActions;
+    QStringList m_keys;
+
+    friend class QQuickDragAttached;
+    friend class QQuickDragAttachedPrivate;
+};
+
+class QQuickDragAttached;
+class Q_QUICK_EXPORT QQuickDrag : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QQuickItem *target READ target WRITE setTarget NOTIFY targetChanged RESET resetTarget FINAL)
+    Q_PROPERTY(Axis axis READ axis WRITE setAxis NOTIFY axisChanged FINAL FINAL)
+    Q_PROPERTY(qreal minimumX READ xmin WRITE setXmin NOTIFY minimumXChanged FINAL)
+    Q_PROPERTY(qreal maximumX READ xmax WRITE setXmax NOTIFY maximumXChanged FINAL)
+    Q_PROPERTY(qreal minimumY READ ymin WRITE setYmin NOTIFY minimumYChanged FINAL)
+    Q_PROPERTY(qreal maximumY READ ymax WRITE setYmax NOTIFY maximumYChanged FINAL)
+    Q_PROPERTY(bool active READ active NOTIFY activeChanged FINAL)
+    Q_PROPERTY(bool filterChildren READ filterChildren WRITE setFilterChildren NOTIFY filterChildrenChanged FINAL)
+    Q_PROPERTY(bool smoothed READ smoothed WRITE setSmoothed NOTIFY smoothedChanged FINAL)
+    // Note, threshold was added in QtQuick 2.2 but REVISION is not supported (or needed) for grouped
+    // properties See QTBUG-33179
+    Q_PROPERTY(qreal threshold READ threshold WRITE setThreshold NOTIFY thresholdChanged RESET resetThreshold FINAL)
+    //### consider drag and drop
+
+    QML_NAMED_ELEMENT(Drag)
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_UNCREATABLE("Drag is only available via attached properties.")
+    QML_ATTACHED(QQuickDragAttached)
+
+public:
+    QQuickDrag(QObject *parent=nullptr);
+    ~QQuickDrag();
+
+    enum DragType { None, Automatic, Internal };
+    Q_ENUM(DragType)
+
+    QQuickItem *target() const;
+    void setTarget(QQuickItem *target);
+    void resetTarget();
+
+    enum Axis { XAxis=0x01, YAxis=0x02, XAndYAxis=0x03, XandYAxis=XAndYAxis };
+    Q_ENUM(Axis)
+    Axis axis() const;
+    void setAxis(Axis);
+
+    qreal xmin() const;
+    void setXmin(qreal);
+    qreal xmax() const;
+    void setXmax(qreal);
+    qreal ymin() const;
+    void setYmin(qreal);
+    qreal ymax() const;
+    void setYmax(qreal);
+
+    bool smoothed() const;
+    void setSmoothed(bool smooth);
+
+    qreal threshold() const;
+    void setThreshold(qreal);
+    void resetThreshold();
+
+    bool active() const;
+    void setActive(bool);
+
+    bool filterChildren() const;
+    void setFilterChildren(bool);
+
+    static QQuickDragAttached *qmlAttachedProperties(QObject *obj);
+
+Q_SIGNALS:
+    void targetChanged();
+    void axisChanged();
+    void minimumXChanged();
+    void maximumXChanged();
+    void minimumYChanged();
+    void maximumYChanged();
+    void activeChanged();
+    void filterChildrenChanged();
+    void smoothedChanged();
+    void thresholdChanged();
+
+private:
+    QQuickItem *_target;
+    Axis _axis;
+    qreal _xmin;
+    qreal _xmax;
+    qreal _ymin;
+    qreal _ymax;
+    bool _active : 1;
+    bool _filterChildren: 1;
+    bool _smoothed : 1;
+    qreal _threshold;
+    Q_DISABLE_COPY(QQuickDrag)
+};
+
+class QQuickDragAttachedPrivate;
+class Q_QUICK_EXPORT QQuickDragAttached : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickDragAttached)
+
+    Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged FINAL)
+    Q_PROPERTY(QObject *source READ source WRITE setSource NOTIFY sourceChanged RESET resetSource FINAL)
+    Q_PROPERTY(QObject *target READ target NOTIFY targetChanged FINAL)
+    Q_PROPERTY(QPointF hotSpot READ hotSpot WRITE setHotSpot NOTIFY hotSpotChanged FINAL)
+    Q_PROPERTY(QUrl imageSource READ imageSource WRITE setImageSource NOTIFY imageSourceChanged FINAL)
+    // imageSourceSize is new in Qt 6.8; revision omitted because of QTBUG-33179
+    Q_PROPERTY(QSize imageSourceSize READ imageSourceSize WRITE setImageSourceSize NOTIFY imageSourceSizeChanged FINAL)
+    Q_PROPERTY(QStringList keys READ keys WRITE setKeys NOTIFY keysChanged FINAL)
+    Q_PROPERTY(QVariantMap mimeData READ mimeData WRITE setMimeData NOTIFY mimeDataChanged FINAL)
+    Q_PROPERTY(Qt::DropActions supportedActions READ supportedActions WRITE setSupportedActions NOTIFY supportedActionsChanged FINAL)
+    Q_PROPERTY(Qt::DropAction proposedAction READ proposedAction WRITE setProposedAction NOTIFY proposedActionChanged FINAL)
+    Q_PROPERTY(QQuickDrag::DragType dragType READ dragType WRITE setDragType NOTIFY dragTypeChanged FINAL)
+
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickDragAttached(QObject *parent);
+    ~QQuickDragAttached();
+
+    bool isActive() const;
+    void setActive(bool active);
+
+    QObject *source() const;
+    void setSource(QObject *item);
+    void resetSource();
+
+    QObject *target() const;
+
+    QPointF hotSpot() const;
+    void setHotSpot(const QPointF &hotSpot);
+
+    QUrl imageSource() const;
+    void setImageSource(const QUrl &url);
+
+    QSize imageSourceSize() const;
+    void setImageSourceSize(const QSize &size);
+
+    QStringList keys() const;
+    void setKeys(const QStringList &keys);
+
+    QVariantMap mimeData() const;
+    void setMimeData(const QVariantMap &mimeData);
+
+    Qt::DropActions supportedActions() const;
+    void setSupportedActions(Qt::DropActions actions);
+
+    Qt::DropAction proposedAction() const;
+    void setProposedAction(Qt::DropAction action);
+
+    QQuickDrag::DragType dragType() const;
+    void setDragType(QQuickDrag::DragType dragType);
+
+    Q_INVOKABLE int drop();
+
+    bool event(QEvent *event) override;
+
+public Q_SLOTS:
+    void start(QQmlV4FunctionPtr);
+    void startDrag(QQmlV4FunctionPtr);
+    void cancel();
+
+Q_SIGNALS:
+    void dragStarted();
+    void dragFinished(Qt::DropAction dropAction);
+
+    void activeChanged();
+    void sourceChanged();
+    void targetChanged();
+    void hotSpotChanged();
+    void imageSourceChanged();
+    void imageSourceSizeChanged(); // new in Qt 6.8
+    void keysChanged();
+    void mimeDataChanged();
+    void supportedActionsChanged();
+    void proposedActionChanged();
+    void dragTypeChanged();
+};
+
+QT_END_NAMESPACE
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdrag_p_p.h

@@ -0,0 +1,99 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDRAG_P_P_H
+#define QQUICKDRAG_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickdrag_p.h"
+
+#include <QtCore/qobject.h>
+#include <QtCore/private/qobject_p.h>
+#include <QtCore/qpointer.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qvariant.h>
+
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/private/qquickitemchangelistener_p.h>
+#include <QtQuick/private/qquickpixmap_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickDragAttachedPrivate : public QObjectPrivate, public QQuickItemChangeListener
+{
+    Q_DECLARE_PUBLIC(QQuickDragAttached)
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    static QQuickDragAttachedPrivate *get(QQuickDragAttached *attached) {
+        return static_cast<QQuickDragAttachedPrivate *>(QObjectPrivate::get(attached)); }
+
+    QQuickDragAttachedPrivate()
+        : attachedItem(nullptr)
+        , mimeData(nullptr)
+        , proposedAction(Qt::MoveAction)
+        , supportedActions(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction)
+        , active(false)
+        , listening(false)
+        , inEvent(false)
+        , dragRestarted(false)
+        , itemMoved(false)
+        , eventQueued(false)
+        , overrideActions(false)
+        , dragType(QQuickDrag::Internal)
+    {
+    }
+
+    void itemGeometryChanged(QQuickItem *, QQuickGeometryChange, const QRectF &) override;
+    void itemParentChanged(QQuickItem *, QQuickItem *parent) override;
+    void updatePosition();
+    void restartDrag();
+    void deliverEnterEvent();
+    void deliverMoveEvent();
+    void deliverLeaveEvent();
+    void deliverEvent(QQuickWindow *window, QEvent *event);
+    void start(Qt::DropActions supportedActions);
+    Qt::DropAction startDrag(Qt::DropActions supportedActions);
+    void setTarget(QQuickItem *item);
+    QMimeData *createMimeData() const;
+    void loadPixmap();
+
+    QQuickDragGrabber dragGrabber;
+
+    QPointer<QObject> source;
+    QPointer<QObject> target;
+    QPointer<QQuickWindow> window;
+    QQuickItem *attachedItem;
+    QQuickDragMimeData *mimeData;
+    Qt::DropAction proposedAction;
+    Qt::DropActions supportedActions;
+    bool active : 1;
+    bool listening : 1;
+    bool inEvent : 1;
+    bool dragRestarted : 1;
+    bool itemMoved : 1;
+    bool eventQueued : 1;
+    bool overrideActions : 1;
+    QPointF hotSpot;
+    QUrl imageSource;
+    QSize imageSourceSize;
+    QQuickPixmap pixmapLoader;
+    QStringList keys;
+    QVariantMap externalMimeData;
+    QQuickDrag::DragType dragType;
+};
+
+QT_END_NAMESPACE
+
+#endif

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdragaxis_p.h

@@ -0,0 +1,81 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDRAGAXIS_P_H
+#define QQUICKDRAGAXIS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQml/qqml.h>
+#include <QtQml/qqmlproperty.h>
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickItem;
+class QQuickPointerHandler;
+
+class Q_QUICK_EXPORT QQuickDragAxis : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal minimum READ minimum WRITE setMinimum NOTIFY minimumChanged)
+    Q_PROPERTY(qreal maximum READ maximum WRITE setMaximum NOTIFY maximumChanged)
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(qreal activeValue READ activeValue NOTIFY activeValueChanged REVISION(6, 5))
+    QML_NAMED_ELEMENT(DragAxis)
+    QML_ADDED_IN_VERSION(2, 12)
+    QML_UNCREATABLE("DragAxis is only available as a grouped property of DragHandler or PinchHandler.")
+
+public:
+    QQuickDragAxis(QQuickPointerHandler *handler, const QString &propertyName,
+                   qreal initValue = 0);
+
+    qreal minimum() const { return m_minimum; }
+    void setMinimum(qreal minimum);
+
+    qreal maximum() const { return m_maximum; }
+    void setMaximum(qreal maximum);
+
+    bool enabled() const { return m_enabled; }
+    void setEnabled(bool enabled);
+
+    qreal activeValue() const { return m_activeValue; }
+
+    qreal persistentValue() const { return m_accumulatedValue; }
+
+protected:
+    void onActiveChanged(bool active, qreal initActiveValue);
+    qreal targetValue();
+    void updateValue(qreal activeValue, qreal accumulatedValue, qreal delta = 0);
+
+Q_SIGNALS:
+    void minimumChanged();
+    void maximumChanged();
+    void enabledChanged();
+    Q_REVISION(6, 5) void activeValueChanged(qreal delta);
+
+private:
+    qreal m_minimum = std::numeric_limits<qreal>::lowest();
+    qreal m_maximum = std::numeric_limits<qreal>::max();
+    qreal m_startValue = 0;
+    qreal m_activeValue = 0;
+    qreal m_accumulatedValue = 0;
+    QString m_propertyName;
+    bool m_enabled = true;
+
+    friend class QQuickDragHandler;
+    friend class QQuickPinchHandler;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKDRAGAXIS_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdraghandler_p.h

@@ -0,0 +1,94 @@
+// Copyright (C) 2018 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDRAGHANDLER_H
+#define QQUICKDRAGHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickmultipointhandler_p.h"
+#include "qquickdragaxis_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt::StringLiterals;
+
+class Q_QUICK_EXPORT QQuickDragHandler : public QQuickMultiPointHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(QQuickDragAxis * xAxis READ xAxis CONSTANT)
+    Q_PROPERTY(QQuickDragAxis * yAxis READ yAxis CONSTANT)
+#if QT_DEPRECATED_SINCE(6, 2)
+    Q_PROPERTY(QVector2D translation READ translation NOTIFY translationChanged)
+#endif
+    Q_PROPERTY(QVector2D activeTranslation READ activeTranslation NOTIFY translationChanged REVISION(6, 2))
+    Q_PROPERTY(QVector2D persistentTranslation READ persistentTranslation WRITE setPersistentTranslation NOTIFY translationChanged REVISION(6, 2))
+    Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged REVISION(2, 14))
+    QML_NAMED_ELEMENT(DragHandler)
+    QML_ADDED_IN_VERSION(2, 12)
+
+public:
+    enum SnapMode {
+        NoSnap = 0,
+        SnapAuto,
+        SnapIfPressedOutsideTarget,
+        SnapAlways
+    };
+    Q_ENUM(SnapMode)
+
+    explicit QQuickDragHandler(QQuickItem *parent = nullptr);
+
+    void handlePointerEventImpl(QPointerEvent *event) override;
+
+    QQuickDragAxis *xAxis() { return &m_xAxis; }
+    QQuickDragAxis *yAxis() { return &m_yAxis; }
+
+#if QT_DEPRECATED_SINCE(6, 2)
+    QVector2D translation() const { return activeTranslation(); }
+#endif
+    QVector2D activeTranslation() const { return QVector2D(QPointF(m_xAxis.activeValue(), m_yAxis.activeValue())); }
+    void setActiveTranslation(const QVector2D &trans);
+    QVector2D persistentTranslation() const { return QVector2D(QPointF(m_xAxis.persistentValue(), m_yAxis.persistentValue())); }
+    void setPersistentTranslation(const QVector2D &trans);
+    QQuickDragHandler::SnapMode snapMode() const;
+    void setSnapMode(QQuickDragHandler::SnapMode mode);
+
+Q_SIGNALS:
+    void translationChanged(QVector2D delta);
+    Q_REVISION(2, 14) void snapModeChanged();
+
+protected:
+    bool wantsPointerEvent(QPointerEvent *event) override;
+    void onActiveChanged() override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QPointingDevice::GrabTransition transition, QPointerEvent *event, QEventPoint &point) override;
+
+private:
+    void ungrab();
+    void enforceAxisConstraints(QPointF *localPos);
+    QPointF targetCentroidPosition();
+
+private:
+    QPointF m_pressTargetPos;   // We must also store the local targetPos, because we cannot deduce
+                                // the press target pos from the scene pos in case there was e.g a
+                                // flick in one of the ancestors during the drag.
+
+    QQuickDragAxis m_xAxis = {this, u"x"_s};
+    QQuickDragAxis m_yAxis = {this, u"y"_s};
+    QQuickDragHandler::SnapMode m_snapMode = SnapAuto;
+    bool m_pressedInsideTarget = false;
+
+    friend class QQuickDragAxis;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKDRAGHANDLER_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickdroparea_p.h

@@ -0,0 +1,164 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKDROPAREA_P_H
+#define QQUICKDROPAREA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+
+#include <QtQuick/qquickitem.h>
+
+#include <QtGui/qevent.h>
+
+QT_REQUIRE_CONFIG(quick_draganddrop);
+
+QT_BEGIN_NAMESPACE
+
+class QQuickDropAreaPrivate;
+class QQuickDragEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x FINAL)
+    Q_PROPERTY(qreal y READ y FINAL)
+    Q_PROPERTY(QObject *source READ source FINAL)
+    Q_PROPERTY(QStringList keys READ keys FINAL)
+    Q_PROPERTY(Qt::DropActions supportedActions READ supportedActions FINAL)
+    Q_PROPERTY(Qt::DropActions proposedAction READ proposedAction FINAL)
+    Q_PROPERTY(Qt::DropAction action READ action WRITE setAction RESET resetAction FINAL)
+    Q_PROPERTY(bool accepted READ accepted WRITE setAccepted FINAL)
+    Q_PROPERTY(bool hasColor READ hasColor FINAL)
+    Q_PROPERTY(bool hasHtml READ hasHtml FINAL)
+    Q_PROPERTY(bool hasText READ hasText FINAL)
+    Q_PROPERTY(bool hasUrls READ hasUrls FINAL)
+    Q_PROPERTY(QVariant colorData READ colorData FINAL)
+    Q_PROPERTY(QString html READ html FINAL)
+    Q_PROPERTY(QString text READ text FINAL)
+    Q_PROPERTY(QList<QUrl> urls READ urls FINAL)
+    Q_PROPERTY(QStringList formats READ formats FINAL)
+    QML_NAMED_ELEMENT(DragEvent)
+    QML_UNCREATABLE("DragEvent is only meant to be created by DropArea")
+    QML_ADDED_IN_VERSION(2, 0)
+public:
+    QQuickDragEvent(QQuickDropAreaPrivate *d, QDropEvent *event) : d(d), event(event) {}
+
+    qreal x() const { return event->position().x(); }
+    qreal y() const { return event->position().y(); }
+
+    QObject *source() const;
+
+    Qt::DropActions supportedActions() const { return event->possibleActions(); }
+    Qt::DropActions proposedAction() const { return event->proposedAction(); }
+    Qt::DropAction action() const { return event->dropAction(); }
+    void setAction(Qt::DropAction action) { event->setDropAction(action); }
+    void resetAction() { event->setDropAction(event->proposedAction()); }
+
+    QStringList keys() const;
+
+    bool accepted() const { return event->isAccepted(); }
+    void setAccepted(bool accepted) { event->setAccepted(accepted); }
+
+    bool hasColor() const;
+    bool hasHtml() const;
+    bool hasText() const;
+    bool hasUrls() const;
+    QVariant colorData() const;
+    QString html() const;
+    QString text() const;
+    QList<QUrl> urls() const;
+    QStringList formats() const;
+
+    Q_INVOKABLE QString getDataAsString(const QString &format) const;
+    Q_INVOKABLE QByteArray getDataAsArrayBuffer(const QString &format) const;
+    Q_INVOKABLE void acceptProposedAction();
+    Q_INVOKABLE void accept();
+    Q_INVOKABLE void accept(Qt::DropAction action);
+
+private:
+    QQuickDropAreaPrivate *d;
+    QDropEvent *event;
+};
+
+class QQuickDropAreaDrag : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x NOTIFY positionChanged FINAL)
+    Q_PROPERTY(qreal y READ y NOTIFY positionChanged FINAL)
+    Q_PROPERTY(QObject *source READ source NOTIFY sourceChanged FINAL)
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+public:
+    QQuickDropAreaDrag(QQuickDropAreaPrivate *d, QObject *parent = nullptr);
+    ~QQuickDropAreaDrag();
+
+    qreal x() const;
+    qreal y() const;
+    QObject *source() const;
+
+Q_SIGNALS:
+    void positionChanged();
+    void sourceChanged();
+
+private:
+    QQuickDropAreaPrivate *d;
+
+    friend class QQuickDropArea;
+    friend class QQuickDropAreaPrivate;
+};
+
+class QQuickDropAreaPrivate;
+class Q_QUICK_EXPORT QQuickDropArea : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY(bool containsDrag READ containsDrag NOTIFY containsDragChanged)
+    Q_PROPERTY(QStringList keys READ keys WRITE setKeys NOTIFY keysChanged)
+    Q_PROPERTY(QQuickDropAreaDrag *drag READ drag CONSTANT)
+    QML_NAMED_ELEMENT(DropArea)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickDropArea(QQuickItem *parent=0);
+    ~QQuickDropArea();
+
+    bool containsDrag() const;
+    void setContainsDrag(bool drag);
+
+    QStringList keys() const;
+    void setKeys(const QStringList &keys);
+
+    QQuickDropAreaDrag *drag();
+
+Q_SIGNALS:
+    void containsDragChanged();
+    void keysChanged();
+    void sourceChanged();
+
+    void entered(QQuickDragEvent *drag);
+    void exited();
+    void positionChanged(QQuickDragEvent *drag);
+    void dropped(QQuickDragEvent *drop);
+
+protected:
+    void dragMoveEvent(QDragMoveEvent *event) override;
+    void dragEnterEvent(QDragEnterEvent *event) override;
+    void dragLeaveEvent(QDragLeaveEvent *event) override;
+    void dropEvent(QDropEvent *event) override;
+
+private:
+    Q_DISABLE_COPY(QQuickDropArea)
+    Q_DECLARE_PRIVATE(QQuickDropArea)
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKDROPAREA_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickevents_p_p.h

@@ -0,0 +1,262 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKEVENTS_P_P_H
+#define QQUICKEVENTS_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qtquickglobal_p.h>
+#include <qqml.h>
+
+#include <QtCore/qobject.h>
+#include <QtCore/qpointer.h>
+#include <QtGui/qevent.h>
+#include <QtGui/qpointingdevice.h>
+#include <QtGui/qvector2d.h>
+#include <QtQuick/qquickitem.h>
+
+#if QT_CONFIG(shortcut)
+#  include <QtGui/qkeysequence.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QPointingDevice;
+class QPointerEvent;
+class QMouseEvent;
+class QQuickPointerHandler;
+
+class Q_QUICK_EXPORT QQuickKeyEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int key READ key CONSTANT FINAL)
+    Q_PROPERTY(QString text READ text CONSTANT FINAL)
+    Q_PROPERTY(int modifiers READ modifiers CONSTANT FINAL)
+    Q_PROPERTY(bool isAutoRepeat READ isAutoRepeat CONSTANT FINAL)
+    Q_PROPERTY(int count READ count CONSTANT FINAL)
+    Q_PROPERTY(quint32 nativeScanCode READ nativeScanCode CONSTANT FINAL)
+    Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted FINAL)
+    QML_NAMED_ELEMENT(KeyEvent)
+    QML_UNCREATABLE("Should only be used by signal handlers in the Keys attached property")
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickKeyEvent()
+    {}
+
+    void reset(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
+               const QString &text = QString(), bool autorep = false, ushort count = 1)
+    {
+        m_type = type;
+        m_key = key;
+        m_modifiers = modifiers;
+        m_text = text;
+        m_autoRepeat = autorep;
+        m_count = count;
+        setAccepted(false);
+    }
+
+    void reset(const QKeyEvent &ke)
+    {
+        m_type = ke.type();
+        m_key = ke.key();
+        m_modifiers = ke.modifiers();
+        m_text = ke.text();
+        m_autoRepeat = ke.isAutoRepeat();
+        m_count = ke.count();
+        m_nativeScanCode = ke.nativeScanCode();
+        setAccepted(false);
+    }
+
+    int key() const { return m_key; }
+    QString text() const { return m_text; }
+    int modifiers() const { return m_modifiers; }
+    bool isAutoRepeat() const { return m_autoRepeat; }
+    int count() const { return m_count; }
+    quint32 nativeScanCode() const { return m_nativeScanCode; }
+
+    bool isAccepted() { return m_accepted; }
+    void setAccepted(bool accepted) { m_accepted = accepted; }
+
+#if QT_CONFIG(shortcut)
+    Q_REVISION(2, 2) Q_INVOKABLE bool matches(QKeySequence::StandardKey key) const;
+#endif
+
+private:
+    QString m_text;
+    quint32 m_nativeScanCode = 0;
+    QEvent::Type m_type = QEvent::None;
+    int m_key = 0;
+    int m_modifiers = 0;
+    int m_count = 0;
+    bool m_accepted = false;
+    bool m_autoRepeat = false;
+};
+
+class Q_QUICK_EXPORT QQuickMouseEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal x READ x CONSTANT FINAL)
+    Q_PROPERTY(qreal y READ y CONSTANT FINAL)
+    Q_PROPERTY(int button READ button CONSTANT FINAL)
+    Q_PROPERTY(int buttons READ buttons CONSTANT FINAL)
+    Q_PROPERTY(int modifiers READ modifiers CONSTANT FINAL)
+#if QT_DEPRECATED_SINCE(6, 6)
+    Q_PROPERTY(int source READ source CONSTANT REVISION(2, 7) FINAL)
+#endif
+    Q_PROPERTY(bool isClick READ isClick CONSTANT FINAL)
+    Q_PROPERTY(bool wasHeld READ wasHeld CONSTANT FINAL)
+    Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted FINAL)
+    Q_PROPERTY(int flags READ flags CONSTANT REVISION(2, 11) FINAL)
+    QML_NAMED_ELEMENT(MouseEvent)
+    QML_UNCREATABLE("Should only be used by mouse event signal handlers, for example in MouseArea")
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickMouseEvent()
+      : _wasHeld(false), _isClick(false), _accepted(false)
+    {}
+
+    void reset(qreal x, qreal y, Qt::MouseButton button, Qt::MouseButtons buttons,
+               Qt::KeyboardModifiers modifiers, bool isClick = false, bool wasHeld = false,
+               Qt::MouseEventFlags flags = { })
+    {
+        _x = x;
+        _y = y;
+        _button = button;
+        _buttons = buttons;
+        _modifiers = modifiers;
+        _source = Qt::MouseEventNotSynthesized;
+        _wasHeld = wasHeld;
+        _isClick = isClick;
+        _accepted = true;
+        _flags = flags;
+    }
+
+    qreal x() const { return _x; }
+    qreal y() const { return _y; }
+    int button() const { return _button; }
+    int buttons() const { return _buttons; }
+    int modifiers() const { return _modifiers; }
+#if QT_DEPRECATED_SINCE(6, 6)
+    int source() const { return _source; }
+#endif
+    bool wasHeld() const { return _wasHeld; }
+    bool isClick() const { return _isClick; }
+
+    // only for internal usage
+    void setX(qreal x) { _x = x; }
+    void setY(qreal y) { _y = y; }
+    void setPosition(const QPointF &point) { _x = point.x(); _y = point.y(); }
+#if QT_DEPRECATED_SINCE(6, 6)
+    void setSource(Qt::MouseEventSource s) { _source = s; }
+#endif
+
+    bool isAccepted() { return _accepted; }
+    void setAccepted(bool accepted) { _accepted = accepted; }
+    int flags() const { return _flags; }
+private:
+    qreal _x = 0;
+    qreal _y = 0;
+    Qt::MouseButton _button = Qt::NoButton;
+    Qt::MouseButtons _buttons = Qt::NoButton;
+    Qt::KeyboardModifiers _modifiers = Qt::NoModifier;
+    Qt::MouseEventSource _source = Qt::MouseEventNotSynthesized;
+    bool _wasHeld : 1;
+    bool _isClick : 1;
+    bool _accepted : 1;
+    Qt::MouseEventFlags _flags = Qt::NoMouseEventFlag;
+};
+
+#if QT_CONFIG(wheelevent)
+class Q_QUICK_EXPORT QQuickWheelEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(const QPointingDevice *device READ pointingDevice CONSTANT FINAL)
+    Q_PROPERTY(qreal x READ x CONSTANT FINAL)
+    Q_PROPERTY(qreal y READ y CONSTANT FINAL)
+    Q_PROPERTY(QPoint angleDelta READ angleDelta CONSTANT FINAL)
+    Q_PROPERTY(QPoint pixelDelta READ pixelDelta CONSTANT FINAL)
+    Q_PROPERTY(Qt::ScrollPhase phase READ phase CONSTANT FINAL)
+    Q_PROPERTY(int buttons READ buttons CONSTANT FINAL)
+    Q_PROPERTY(int modifiers READ modifiers CONSTANT FINAL)
+    Q_PROPERTY(bool inverted READ inverted CONSTANT FINAL)
+    Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted FINAL)
+    QML_NAMED_ELEMENT(WheelEvent)
+    QML_UNCREATABLE("Should only be used by wheel event signal handlers, for example in MouseArea")
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickWheelEvent() = default;
+
+    void reset(const QWheelEvent *event)
+    {
+        _device = event->pointingDevice();
+        _x = event->position().x();
+        _y = event->position().y();
+        _angleDelta = event->angleDelta();
+        _pixelDelta = event->pixelDelta();
+        _buttons = event->buttons();
+        _modifiers = event->modifiers();
+        _accepted = true;
+        _inverted = event->inverted();
+        _phase = event->phase();
+    }
+
+    const QPointingDevice *pointingDevice() const { return _device; }
+    qreal x() const { return _x; }
+    qreal y() const { return _y; }
+    QPoint angleDelta() const { return _angleDelta; }
+    QPoint pixelDelta() const { return _pixelDelta; }
+    int buttons() const { return _buttons; }
+    int modifiers() const { return _modifiers; }
+    Qt::ScrollPhase phase() const { return _phase; }
+    bool inverted() const { return _inverted; }
+    bool isAccepted() { return _accepted; }
+    void setAccepted(bool accepted) { _accepted = accepted; }
+
+private:
+    const QPointingDevice *_device = nullptr;
+    qreal _x = 0;
+    qreal _y = 0;
+    QPoint _angleDelta;
+    QPoint _pixelDelta;
+    Qt::MouseButtons _buttons = Qt::NoButton;
+    Qt::KeyboardModifiers _modifiers = Qt::NoModifier;
+    Qt::ScrollPhase _phase = Qt::NoScrollPhase;
+    bool _inverted = false;
+    bool _accepted = false;
+};
+#endif
+
+class Q_QUICK_EXPORT QQuickCloseEvent : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted FINAL)
+    QML_NAMED_ELEMENT(CloseEvent)
+    QML_UNCREATABLE("Should only be used by Window's closing signal")
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickCloseEvent() {}
+
+    bool isAccepted() { return _accepted; }
+    void setAccepted(bool accepted) { _accepted = accepted; }
+
+private:
+    bool _accepted = true;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKEVENTS_P_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickflickable_p.h

@@ -0,0 +1,290 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKFLICKABLE_P_H
+#define QQUICKFLICKABLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickitem.h"
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickFlickablePrivate;
+class QQuickFlickableVisibleArea;
+class Q_QUICK_EXPORT QQuickFlickable : public QQuickItem
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth NOTIFY contentWidthChanged)
+    Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged)
+    Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)
+    Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)
+    Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT)
+
+    Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin NOTIFY topMarginChanged)
+    Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin NOTIFY bottomMarginChanged)
+    Q_PROPERTY(qreal originY READ originY NOTIFY originYChanged)
+
+    Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)
+    Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin NOTIFY rightMarginChanged)
+    Q_PROPERTY(qreal originX READ originX NOTIFY originXChanged)
+
+    Q_PROPERTY(qreal horizontalVelocity READ horizontalVelocity NOTIFY horizontalVelocityChanged)
+    Q_PROPERTY(qreal verticalVelocity READ verticalVelocity NOTIFY verticalVelocityChanged)
+
+    Q_PROPERTY(BoundsBehavior boundsBehavior READ boundsBehavior WRITE setBoundsBehavior NOTIFY boundsBehaviorChanged)
+    Q_PROPERTY(BoundsMovement boundsMovement READ boundsMovement WRITE setBoundsMovement NOTIFY boundsMovementChanged REVISION(2, 10))
+    Q_PROPERTY(QQuickTransition *rebound READ rebound WRITE setRebound NOTIFY reboundChanged)
+    Q_PROPERTY(qreal maximumFlickVelocity READ maximumFlickVelocity WRITE setMaximumFlickVelocity NOTIFY maximumFlickVelocityChanged)
+    Q_PROPERTY(qreal flickDeceleration READ flickDeceleration WRITE setFlickDeceleration NOTIFY flickDecelerationChanged)
+    Q_PROPERTY(bool moving READ isMoving NOTIFY movingChanged)
+    Q_PROPERTY(bool movingHorizontally READ isMovingHorizontally NOTIFY movingHorizontallyChanged)
+    Q_PROPERTY(bool movingVertically READ isMovingVertically NOTIFY movingVerticallyChanged)
+    Q_PROPERTY(bool flicking READ isFlicking NOTIFY flickingChanged)
+    Q_PROPERTY(bool flickingHorizontally READ isFlickingHorizontally NOTIFY flickingHorizontallyChanged)
+    Q_PROPERTY(bool flickingVertically READ isFlickingVertically NOTIFY flickingVerticallyChanged)
+    Q_PROPERTY(bool dragging READ isDragging NOTIFY draggingChanged)
+    Q_PROPERTY(bool draggingHorizontally READ isDraggingHorizontally NOTIFY draggingHorizontallyChanged)
+    Q_PROPERTY(bool draggingVertically READ isDraggingVertically NOTIFY draggingVerticallyChanged)
+    Q_PROPERTY(FlickableDirection flickableDirection READ flickableDirection WRITE setFlickableDirection NOTIFY flickableDirectionChanged)
+
+    Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive NOTIFY interactiveChanged)
+    Q_PROPERTY(int pressDelay READ pressDelay WRITE setPressDelay NOTIFY pressDelayChanged)
+
+    Q_PROPERTY(bool atXEnd READ isAtXEnd NOTIFY atXEndChanged)
+    Q_PROPERTY(bool atYEnd READ isAtYEnd NOTIFY atYEndChanged)
+    Q_PROPERTY(bool atXBeginning READ isAtXBeginning NOTIFY atXBeginningChanged)
+    Q_PROPERTY(bool atYBeginning READ isAtYBeginning NOTIFY atYBeginningChanged)
+
+    Q_PROPERTY(QQuickFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)
+
+    Q_PROPERTY(bool pixelAligned READ pixelAligned WRITE setPixelAligned NOTIFY pixelAlignedChanged)
+    Q_PROPERTY(bool synchronousDrag READ synchronousDrag WRITE setSynchronousDrag NOTIFY synchronousDragChanged REVISION(2, 12))
+
+    Q_PROPERTY(qreal horizontalOvershoot READ horizontalOvershoot NOTIFY horizontalOvershootChanged REVISION(2, 9))
+    Q_PROPERTY(qreal verticalOvershoot READ verticalOvershoot NOTIFY verticalOvershootChanged REVISION(2, 9))
+
+    Q_PROPERTY(QQmlListProperty<QObject> flickableData READ flickableData)
+    Q_PROPERTY(QQmlListProperty<QQuickItem> flickableChildren READ flickableChildren)
+    Q_CLASSINFO("DefaultProperty", "flickableData")
+    QML_NAMED_ELEMENT(Flickable)
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickFlickable(QQuickItem *parent=nullptr);
+    ~QQuickFlickable() override;
+
+    QQmlListProperty<QObject> flickableData();
+    QQmlListProperty<QQuickItem> flickableChildren();
+
+    enum BoundsBehaviorFlag {
+        StopAtBounds = 0x0,
+        DragOverBounds = 0x1,
+        OvershootBounds = 0x2,
+        DragAndOvershootBounds = DragOverBounds | OvershootBounds
+    };
+    Q_DECLARE_FLAGS(BoundsBehavior, BoundsBehaviorFlag)
+    Q_FLAG(BoundsBehavior)
+
+    BoundsBehavior boundsBehavior() const;
+    void setBoundsBehavior(BoundsBehavior);
+
+    enum BoundsMovement {
+        // StopAtBounds = 0x0,
+        FollowBoundsBehavior = 0x1
+    };
+    Q_ENUM(BoundsMovement)
+
+    BoundsMovement boundsMovement() const;
+    void setBoundsMovement(BoundsMovement movement);
+
+    QQuickTransition *rebound() const;
+    void setRebound(QQuickTransition *transition);
+
+    qreal contentWidth() const;
+    void setContentWidth(qreal);
+
+    qreal contentHeight() const;
+    void setContentHeight(qreal);
+
+    qreal contentX() const;
+    virtual void setContentX(qreal pos);
+
+    qreal contentY() const;
+    virtual void setContentY(qreal pos);
+
+    qreal topMargin() const;
+    void setTopMargin(qreal m);
+
+    qreal bottomMargin() const;
+    void setBottomMargin(qreal m);
+
+    qreal leftMargin() const;
+    void setLeftMargin(qreal m);
+
+    qreal rightMargin() const;
+    void setRightMargin(qreal m);
+
+    virtual qreal originY() const;
+    virtual qreal originX() const;
+
+    bool isMoving() const;
+    bool isMovingHorizontally() const;
+    bool isMovingVertically() const;
+    bool isFlicking() const;
+    bool isFlickingHorizontally() const;
+    bool isFlickingVertically() const;
+    bool isDragging() const;
+    bool isDraggingHorizontally() const;
+    bool isDraggingVertically() const;
+
+    int pressDelay() const;
+    void setPressDelay(int delay);
+
+    qreal maximumFlickVelocity() const;
+    void setMaximumFlickVelocity(qreal);
+
+    qreal flickDeceleration() const;
+    void setFlickDeceleration(qreal);
+
+    bool isInteractive() const;
+    void setInteractive(bool);
+
+    qreal horizontalVelocity() const;
+    qreal verticalVelocity() const;
+
+    bool isAtXEnd() const;
+    bool isAtXBeginning() const;
+    bool isAtYEnd() const;
+    bool isAtYBeginning() const;
+
+    QQuickItem *contentItem() const;
+
+    enum FlickableDirection { AutoFlickDirection=0x0, HorizontalFlick=0x1, VerticalFlick=0x2, HorizontalAndVerticalFlick=0x3,
+                              AutoFlickIfNeeded=0xc };
+    Q_ENUM(FlickableDirection)
+    FlickableDirection flickableDirection() const;
+    void setFlickableDirection(FlickableDirection);
+
+    bool pixelAligned() const;
+    void setPixelAligned(bool align);
+
+    bool synchronousDrag() const;
+    void setSynchronousDrag(bool v);
+
+    qreal horizontalOvershoot() const;
+    qreal verticalOvershoot() const;
+
+    Q_INVOKABLE void resizeContent(qreal w, qreal h, QPointF center);
+    Q_INVOKABLE void returnToBounds();
+    Q_INVOKABLE void flick(qreal xVelocity, qreal yVelocity);
+    Q_INVOKABLE void cancelFlick();
+
+Q_SIGNALS:
+    void contentWidthChanged();
+    void contentHeightChanged();
+    void contentXChanged();
+    void contentYChanged();
+    void topMarginChanged();
+    void bottomMarginChanged();
+    void leftMarginChanged();
+    void rightMarginChanged();
+    void originYChanged();
+    void originXChanged();
+    void movingChanged();
+    void movingHorizontallyChanged();
+    void movingVerticallyChanged();
+    void flickingChanged();
+    void flickingHorizontallyChanged();
+    void flickingVerticallyChanged();
+    void draggingChanged();
+    void draggingHorizontallyChanged();
+    void draggingVerticallyChanged();
+    void horizontalVelocityChanged();
+    void verticalVelocityChanged();
+    void isAtBoundaryChanged();
+    void flickableDirectionChanged();
+    void interactiveChanged();
+    void boundsBehaviorChanged();
+    Q_REVISION(2, 10) void boundsMovementChanged();
+    void reboundChanged();
+    void maximumFlickVelocityChanged();
+    void flickDecelerationChanged();
+    void pressDelayChanged();
+    void movementStarted();
+    void movementEnded();
+    void flickStarted();
+    void flickEnded();
+    void dragStarted();
+    void dragEnded();
+    void pixelAlignedChanged();
+    Q_REVISION(2, 12) void synchronousDragChanged();
+    Q_REVISION(2, 9) void horizontalOvershootChanged();
+    Q_REVISION(2, 9) void verticalOvershootChanged();
+
+    // The next four signals should be marked as Q_REVISION(2, 12). See QTBUG-71243
+    void atXEndChanged();
+    void atYEndChanged();
+    void atXBeginningChanged();
+    void atYBeginningChanged();
+
+protected:
+    bool childMouseEventFilter(QQuickItem *, QEvent *) override;
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+    void touchEvent(QTouchEvent *event) override;
+#if QT_CONFIG(wheelevent)
+    void wheelEvent(QWheelEvent *event) override;
+#endif
+    void timerEvent(QTimerEvent *event) override;
+
+    QQuickFlickableVisibleArea *visibleArea();
+
+protected Q_SLOTS:
+    void movementStarting();
+    void movementEnding();
+    void movementEnding(bool hMovementEnding, bool vMovementEnding);
+    void velocityTimelineCompleted();
+    void timelineCompleted();
+
+protected:
+    virtual qreal minXExtent() const;
+    virtual qreal minYExtent() const;
+    virtual qreal maxXExtent() const;
+    virtual qreal maxYExtent() const;
+    qreal vWidth() const;
+    qreal vHeight() const;
+    void componentComplete() override;
+    virtual void viewportMoved(Qt::Orientations orient);
+    void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;
+    void mouseUngrabEvent() override;
+    bool filterPointerEvent(QQuickItem *receiver, QPointerEvent *event);
+
+    bool xflick() const;
+    bool yflick() const;
+
+protected:
+    QQuickFlickable(QQuickFlickablePrivate &dd, QQuickItem *parent);
+
+private:
+    Q_DISABLE_COPY(QQuickFlickable)
+    Q_DECLARE_PRIVATE(QQuickFlickable)
+    friend class QQuickFlickableVisibleArea;
+    friend class QQuickFlickableReboundTransition;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKFLICKABLE_P_H

qt/6.8.1/msvc2022_64/include/QtQuick/6.8.1/QtQuick/private/qquickflickable_p_p.h

@@ -0,0 +1,287 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQUICKFLICKABLE_P_P_H
+#define QQUICKFLICKABLE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickflickable_p.h"
+#include "qquickitem_p.h"
+#include "qquickitemchangelistener_p.h"
+
+#include <QtQml/qqml.h>
+#include <QtCore/qdatetime.h>
+#include "qplatformdefs.h"
+
+#include <private/qquicktimeline_p_p.h>
+#include <private/qquickanimation_p_p.h>
+#include <private/qquicktransitionmanager_p_p.h>
+#include <private/qpodvector_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickFlickableVisibleArea;
+class QQuickTransition;
+class QQuickFlickableReboundTransition;
+
+class Q_QUICK_EXPORT QQuickFlickablePrivate : public QQuickItemPrivate, public QQuickItemChangeListener
+{
+    Q_DECLARE_PUBLIC(QQuickFlickable)
+
+public:
+    static inline QQuickFlickablePrivate *get(QQuickFlickable *o) { return o->d_func(); }
+
+    QQuickFlickablePrivate();
+    void init();
+
+    struct Velocity : public QQuickTimeLineValue
+    {
+        Velocity(QQuickFlickablePrivate *p)
+            : parent(p) {}
+        void setValue(qreal v) override {
+            if (v != value()) {
+                QQuickTimeLineValue::setValue(v);
+                parent->updateVelocity();
+            }
+        }
+        QQuickFlickablePrivate *parent;
+    };
+
+    enum MovementReason { Other, SetIndex, Mouse };
+
+    struct AxisData {
+        AxisData(QQuickFlickablePrivate *fp, void (QQuickFlickablePrivate::*func)(qreal))
+            : move(fp, func)
+            , smoothVelocity(fp), atEnd(false), atBeginning(true)
+            , transitionToSet(false)
+            , fixingUp(false), inOvershoot(false), inRebound(false), moving(false), flicking(false)
+            , flickingWhenDragBegan(false), dragging(false), extentsChanged(false)
+            , explicitValue(false), contentPositionChangedExternallyDuringDrag(false)
+            , minExtentDirty(true), maxExtentDirty(true)
+        {}
+
+        ~AxisData();
+
+        void reset() {
+            velocityBuffer.clear();
+            dragStartOffset = 0;
+            fixingUp = false;
+            inOvershoot = false;
+            contentPositionChangedExternallyDuringDrag = false;
+        }
+
+        void markExtentsDirty() {
+            minExtentDirty = true;
+            maxExtentDirty = true;
+            extentsChanged = true;
+        }
+
+        void resetTransitionTo() {
+            transitionTo = 0;
+            transitionToSet = false;
+        }
+
+        void addVelocitySample(qreal v, qreal maxVelocity);
+        void updateVelocity();
+
+        QQuickTimeLineValueProxy<QQuickFlickablePrivate> move;
+        QQuickFlickableReboundTransition *transitionToBounds = nullptr;
+        qreal viewSize = -1;
+        qreal pressPos = 0;
+        qreal lastPos = 0;
+        qreal dragStartOffset = 0;
+        qreal dragMinBound = 0;
+        qreal dragMaxBound = 0;
+        qreal previousDragDelta = 0;
+        qreal velocity = 0;
+        qreal flickTarget = 0;
+        qreal startMargin = 0;
+        qreal endMargin = 0;
+        qreal origin = 0;
+        qreal overshoot = 0;
+        qreal transitionTo = 0;
+        qreal continuousFlickVelocity = 0;
+        QElapsedTimer velocityTime;
+        int vTime = 0;
+        QQuickFlickablePrivate::Velocity smoothVelocity;
+        QPODVector<qreal,10> velocityBuffer;
+        // bitfield
+        uint atEnd : 1;
+        uint atBeginning : 1;
+        uint transitionToSet : 1;
+        uint fixingUp : 1;
+        uint inOvershoot : 1;
+        uint inRebound : 1;
+        uint moving : 1;
+        uint flicking : 1;
+        uint flickingWhenDragBegan : 1;
+        uint dragging : 1;
+        uint extentsChanged : 1;
+        uint explicitValue : 1;
+        uint contentPositionChangedExternallyDuringDrag : 1;
+        // mutable portion of bitfield
+        mutable uint minExtentDirty : 1;
+        mutable uint maxExtentDirty : 1;
+        // end bitfield
+    };
+
+    bool flickX(QEvent::Type eventType, qreal velocity);
+    bool flickY(QEvent::Type eventType, qreal velocity);
+    virtual bool flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+                       QQuickTimeLineCallback::Callback fixupCallback,
+                       QEvent::Type eventType, qreal velocity);
+    void flickingStarted(bool flickingH, bool flickingV);
+
+    void fixupX();
+    void fixupY();
+    virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
+    void adjustContentPos(AxisData &data, qreal toPos);
+    void resetTimeline(AxisData &data);
+    void clearTimeline();
+
+    void updateBeginningEnd();
+
+    bool isInnermostPressDelay(QQuickItem *item) const;
+    void captureDelayedPress(QQuickItem *item, QPointerEvent *event);
+    void clearDelayedPress();
+    void replayDelayedPress();
+
+    void setViewportX(qreal x);
+    void setViewportY(qreal y);
+
+    qreal overShootDistance(qreal velocity) const;
+
+    void itemGeometryChanged(QQuickItem *, QQuickGeometryChange, const QRectF &) override;
+
+    void draggingStarting();
+    void draggingEnding();
+
+    bool isViewMoving() const;
+
+    void cancelInteraction();
+
+    void addPointerHandler(QQuickPointerHandler *h) override;
+
+    virtual bool wantsPointerEvent(const QPointerEvent *) { return true; }
+
+public:
+    QQuickItem *contentItem;
+
+    AxisData hData;
+    AxisData vData;
+
+    MovementReason moveReason = Other;
+
+    QQuickTimeLine timeline;
+    bool hMoved : 1;
+    bool vMoved : 1;
+    bool stealMouse : 1;
+    bool pressed : 1;
+    bool scrollingPhase : 1;
+    bool interactive : 1;
+    bool calcVelocity : 1;
+    bool pixelAligned : 1;
+    bool syncDrag : 1;
+    QElapsedTimer timer;
+    qint64 lastPosTime;
+    qint64 lastPressTime;
+    QPointF lastPos;
+    QPointF pressPos;
+    QVector2D accumulatedWheelPixelDelta;
+    qreal deceleration;
+    qreal wheelDeceleration;
+    qreal maxVelocity;
+    QPointerEvent *delayedPressEvent;
+    QBasicTimer delayedPressTimer;
+    int pressDelay;
+    int fixupDuration;
+    qreal flickBoost;
+    qreal initialWheelFlickDistance;
+
+    enum FixupMode { Normal, Immediate, ExtentChanged };
+    FixupMode fixupMode;
+
+    static void fixupY_callback(void *);
+    static void fixupX_callback(void *);
+
+    void updateVelocity();
+    int vTime;
+    QQuickTimeLine velocityTimeline;
+    QQuickFlickableVisibleArea *visibleArea;
+    QQuickFlickable::FlickableDirection flickableDirection;
+    QQuickFlickable::BoundsBehavior boundsBehavior;
+    QQuickFlickable::BoundsMovement boundsMovement;
+    QQuickTransition *rebound;
+
+    void viewportAxisMoved(AxisData &data, qreal minExtent, qreal maxExtent,
+                       QQuickTimeLineCallback::Callback fixupCallback);
+
+    void handlePressEvent(QPointerEvent *);
+    void handleMoveEvent(QPointerEvent *);
+    void handleReleaseEvent(QPointerEvent *);
+
+    void maybeBeginDrag(qint64 currentTimestamp, const QPointF &pressPosn,
+                        Qt::MouseButtons buttons = Qt::NoButton);
+    void drag(qint64 currentTimestamp, QEvent::Type eventType, const QPointF &localPos,
+              const QVector2D &deltas, bool overThreshold, bool momentum,
+              bool velocitySensitiveOverBounds, const QVector2D &velocity);
+
+    QVector2D firstPointLocalVelocity(QPointerEvent *event);
+    qint64 computeCurrentTime(QInputEvent *event) const;
+    qreal devicePixelRatio() const;
+
+    // flickableData property
+    static void data_append(QQmlListProperty<QObject> *, QObject *);
+    static qsizetype data_count(QQmlListProperty<QObject> *);
+    static QObject *data_at(QQmlListProperty<QObject> *, qsizetype);
+    static void data_clear(QQmlListProperty<QObject> *);
+};
+
+class Q_QUICK_EXPORT QQuickFlickableVisibleArea : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qreal xPosition READ xPosition NOTIFY xPositionChanged FINAL)
+    Q_PROPERTY(qreal yPosition READ yPosition NOTIFY yPositionChanged FINAL)
+    Q_PROPERTY(qreal widthRatio READ widthRatio NOTIFY widthRatioChanged FINAL)
+    Q_PROPERTY(qreal heightRatio READ heightRatio NOTIFY heightRatioChanged FINAL)
+    QML_ANONYMOUS
+    QML_ADDED_IN_VERSION(2, 0)
+
+public:
+    QQuickFlickableVisibleArea(QQuickFlickable *parent=nullptr);
+
+    qreal xPosition() const;
+    qreal widthRatio() const;
+    qreal yPosition() const;
+    qreal heightRatio() const;
+
+    void updateVisible();
+
+Q_SIGNALS:
+    void xPositionChanged(qreal xPosition);
+    void yPositionChanged(qreal yPosition);
+    void widthRatioChanged(qreal widthRatio);
+    void heightRatioChanged(qreal heightRatio);
+
+private:
+    QQuickFlickable *flickable;
+    qreal m_xPosition;
+    qreal m_widthRatio;
+    qreal m_yPosition;
+    qreal m_heightRatio;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKFLICKABLE_P_P_H