6 files changed, 854 insertions, 0 deletions
diff --git a/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
new file mode 100644
index 000000000..f6acf9d60
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
@@ -0,0 +1,346 @@
+// 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
+
+#include "core_snippets_p.h"
+#include "qtcorehelper.h"
+#include "pysideqobject.h"
+
+#include "shiboken.h"
+#ifndef Py_LIMITED_API
+#  include <datetime.h>
+#endif
+#include "basewrapper.h"
+#include "autodecref.h"
+#include "pysideutils.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+#include <QtCore/QMetaType>
+#include <QtCore/QObject>
+#include <QtCore/QRegularExpression>
+#include <QtCore/QStack>
+#include <QtCore/QVariant>
+
+// Helpers for QVariant conversion
+
+QMetaType QVariant_resolveMetaType(PyTypeObject *type)
+{
+    if (!PyObject_TypeCheck(type, SbkObjectType_TypeF()))
+        return {};
+    const char *typeName = Shiboken::ObjectType::getOriginalName(type);
+    if (!typeName)
+        return {};
+    const bool valueType = '*' != typeName[qstrlen(typeName) - 1];
+    // Do not convert user type of value
+    if (valueType && Shiboken::ObjectType::isUserType(type))
+        return {};
+    QMetaType metaType = QMetaType::fromName(typeName);
+    if (metaType.isValid())
+        return metaType;
+    // Do not resolve types to value type
+    if (valueType)
+        return {};
+    // Find in base types. First check tp_bases, and only after check tp_base, because
+    // tp_base does not always point to the first base class, but rather to the first
+    // that has added any python fields or slots to its object layout.
+    // See https://mail.python.org/pipermail/python-list/2009-January/520733.html
+    if (type->tp_bases) {
+        for (Py_ssize_t i = 0, size = PyTuple_GET_SIZE(type->tp_bases); i < size; ++i) {
+            auto baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(type->tp_bases, i));
+            const QMetaType derived = QVariant_resolveMetaType(baseType);
+            if (derived.isValid())
+                return derived;
+        }
+    } else if (type->tp_base) {
+        return QVariant_resolveMetaType(type->tp_base);
+    }
+    return {};
+}
+
+QVariant QVariant_convertToValueList(PyObject *list)
+{
+    if (PySequence_Size(list) < 0) {
+        // clear the error if < 0 which means no length at all
+        PyErr_Clear();
+        return {};
+    }
+
+    Shiboken::AutoDecRef element(PySequence_GetItem(list, 0));
+
+    auto *type = reinterpret_cast<PyTypeObject *>(element.object());
+    QMetaType metaType = QVariant_resolveMetaType(type);
+    if (!metaType.isValid())
+        return {};
+
+    const QByteArray listTypeName = QByteArrayLiteral("QList<") + metaType.name() + '>';
+    metaType = QMetaType::fromName(listTypeName);
+    if (!metaType.isValid())
+        return {};
+
+    Shiboken::Conversions::SpecificConverter converter(listTypeName);
+    if (!converter) {
+        qWarning("Type converter for: %s not registered.", listTypeName.constData());
+        return {};
+    }
+
+    QVariant var(metaType);
+    converter.toCpp(list, &var);
+    return var;
+}
+
+bool QVariant_isStringList(PyObject *list)
+{
+    if (!PySequence_Check(list)) {
+        // If it is not a list or a derived list class
+        // we assume that will not be a String list neither.
+        return false;
+    }
+
+    if (PySequence_Size(list) < 0) {
+        // clear the error if < 0 which means no length at all
+        PyErr_Clear();
+        return false;
+    }
+
+    Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList"));
+    const Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object());
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        PyObject *item = PySequence_Fast_GET_ITEM(fast.object(), i);
+        if (PyUnicode_Check(item) == 0)
+            return false;
+    }
+    return true;
+}
+
+// Helpers for qAddPostRoutine
+
+namespace PySide {
+
+static QStack<PyObject *> globalPostRoutineFunctions;
+
+void globalPostRoutineCallback()
+{
+    Shiboken::GilState state;
+    for (auto *callback : globalPostRoutineFunctions) {
+        Shiboken::AutoDecRef result(PyObject_CallObject(callback, nullptr));
+        Py_DECREF(callback);
+    }
+    globalPostRoutineFunctions.clear();
+}
+
+void addPostRoutine(PyObject *callback)
+{
+    if (PyCallable_Check(callback)) {
+        globalPostRoutineFunctions << callback;
+        Py_INCREF(callback);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "qAddPostRoutine: The argument must be a callable object.");
+    }
+}
+} // namespace PySide
+
+// Helpers for QObject::findChild(ren)()
+
+static bool _findChildTypeMatch(const QObject *child, PyTypeObject *desiredType)
+{
+    auto *pyChildType = PySide::getTypeForQObject(child);
+    return pyChildType != nullptr && PyType_IsSubtype(pyChildType, desiredType);
+}
+
+static inline bool _findChildrenComparator(const QObject *child,
+                                           const QRegularExpression &name)
+{
+    return name.match(child->objectName()).hasMatch();
+}
+
+static inline bool _findChildrenComparator(const QObject *child,
+                                           const QString &name)
+{
+    return name.isNull() || name == child->objectName();
+}
+
+QObject *qObjectFindChild(const QObject *parent, const QString &name,
+                          PyTypeObject *desiredType, Qt::FindChildOptions options)
+{
+    for (auto *child : parent->children()) {
+        if (_findChildrenComparator(child, name)
+            && _findChildTypeMatch(child, desiredType)) {
+            return child;
+        }
+    }
+
+    if (options.testFlag(Qt::FindChildrenRecursively)) {
+        for (auto *child : parent->children()) {
+            if (auto *obj = qObjectFindChild(child, name, desiredType, options))
+                return obj;
+        }
+    }
+    return nullptr;
+}
+
+template<typename T> // QString/QRegularExpression
+static void _findChildrenHelper(const QObject *parent, const T& name, PyTypeObject *desiredType,
+                                Qt::FindChildOptions options, FindChildHandler handler)
+{
+    for (auto *child : parent->children()) {
+        if (_findChildrenComparator(child, name) && _findChildTypeMatch(child, desiredType))
+            handler(child);
+        if (options.testFlag(Qt::FindChildrenRecursively))
+            _findChildrenHelper(child, name, desiredType, options, handler);
+    }
+}
+
+void qObjectFindChildren(const QObject *parent, const QString &name,
+                         PyTypeObject *desiredType, Qt::FindChildOptions options,
+                         FindChildHandler handler)
+{
+    _findChildrenHelper(parent, name, desiredType, options, handler);
+}
+
+void qObjectFindChildren(const QObject *parent, const QRegularExpression &pattern,
+                         PyTypeObject *desiredType, Qt::FindChildOptions options,
+                         FindChildHandler handler)
+{
+    _findChildrenHelper(parent, pattern, desiredType, options, handler);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Helpers for translation:
+// PYSIDE-131: Use the class name as context where the calling function is
+//             living. Derived Python classes have the wrong context.
+//
+// The original patch uses Python introspection to look up the current
+// function (from the frame stack) in the class __dict__ along the mro.
+//
+// The problem is that looking into the frame stack works for Python
+// functions, only. For including builtin function callers, the following
+// approach turned out to be much simpler:
+//
+// Walk the __mro__
+// - translate the string
+// - if the translated string is changed:
+//   - return the translation.
+
+QString qObjectTr(PyTypeObject *type, const char *sourceText, const char *disambiguation, int n)
+{
+    PyObject *mro = type->tp_mro;
+    auto len = PyTuple_GET_SIZE(mro);
+    QString result = QString::fromUtf8(sourceText);
+    QString oldResult = result;
+    static auto *sbkObjectType = reinterpret_cast<PyTypeObject *>(SbkObject_TypeF());
+    for (Py_ssize_t idx = 0; idx < len - 1; ++idx) {
+        // Skip the last class which is `object`.
+        auto *type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        if (type == sbkObjectType)
+            continue;
+        const char *context = type->tp_name;
+        const char *dotpos = strrchr(context, '.');
+        if (dotpos != nullptr)
+            context = dotpos + 1;
+        result = QCoreApplication::translate(context, sourceText, disambiguation, n);
+        if (result != oldResult)
+            break;
+    }
+    return result;
+}
+
+bool PyDate_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyDate_Check(pyIn);
+}
+
+bool PyDateTime_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyDateTime_Check(pyIn);
+}
+
+bool PyTime_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyTime_Check(pyIn);
+}
+
+PyObject *invokeMetaMethod(const InvokeMetaMethodFunc &f,
+                           const QtCoreHelper::QGenericArgumentHolder &a0,
+                           const QtCoreHelper::QGenericArgumentHolder &a1,
+                           const QtCoreHelper::QGenericArgumentHolder &a2,
+                           const QtCoreHelper::QGenericArgumentHolder &a3,
+                           const QtCoreHelper::QGenericArgumentHolder &a4,
+                           const QtCoreHelper::QGenericArgumentHolder &a5,
+                           const QtCoreHelper::QGenericArgumentHolder &a6,
+                           const QtCoreHelper::QGenericArgumentHolder &a7,
+                           const QtCoreHelper::QGenericArgumentHolder &a8,
+                           const QtCoreHelper::QGenericArgumentHolder &a9)
+{
+    PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
+    const bool resultB = f(a0.toGenericArgument(), a1.toGenericArgument(), a2.toGenericArgument(),
+                           a3.toGenericArgument(), a4.toGenericArgument(), a5.toGenericArgument(),
+                           a6.toGenericArgument(), a7.toGenericArgument(), a8.toGenericArgument(),
+                           a9.toGenericArgument());
+    PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
+    PyObject *result = resultB ? Py_True : Py_False;
+    Py_INCREF(result);
+    return result;
+}
+
+// Convert a QGenericReturnArgument to Python for QMetaObject::invokeMethod
+static PyObject *convertGenericReturnArgument(const void *retData, QMetaType metaType)
+{
+    PyObject *result = nullptr;
+    switch (metaType.id()) {
+    case QMetaType::Bool:
+        result = *reinterpret_cast<const bool *>(retData) ? Py_True : Py_False;
+        Py_INCREF(result);
+        break;
+    case QMetaType::Int:
+        result = PyLong_FromLong(*reinterpret_cast<const int *>(retData));
+        break;
+    case QMetaType::Double:
+        result = PyFloat_FromDouble(*reinterpret_cast<const double *>(retData));
+        break;
+    case QMetaType::QString:
+        result = PySide::qStringToPyUnicode(*reinterpret_cast<const QString *>(retData));
+        break;
+    default: {
+        Shiboken::Conversions::SpecificConverter converter(metaType.name());
+        const auto type = converter.conversionType();
+        if (type == Shiboken::Conversions::SpecificConverter::InvalidConversion) {
+            PyErr_Format(PyExc_RuntimeError, "%s: Unable to find converter for \"%s\".",
+                         __FUNCTION__, metaType.name());
+            return nullptr;
+        }
+        result = converter.toPython(retData);
+    }
+    }
+    return result;
+}
+
+PyObject *invokeMetaMethodWithReturn(const InvokeMetaMethodFuncWithReturn &f,
+                                     const QtCoreHelper::QGenericReturnArgumentHolder &r,
+                                     const QtCoreHelper::QGenericArgumentHolder &a0,
+                                     const QtCoreHelper::QGenericArgumentHolder &a1,
+                                     const QtCoreHelper::QGenericArgumentHolder &a2,
+                                     const QtCoreHelper::QGenericArgumentHolder &a3,
+                                     const QtCoreHelper::QGenericArgumentHolder &a4,
+                                     const QtCoreHelper::QGenericArgumentHolder &a5,
+                                     const QtCoreHelper::QGenericArgumentHolder &a6,
+                                     const QtCoreHelper::QGenericArgumentHolder &a7,
+                                     const QtCoreHelper::QGenericArgumentHolder &a8,
+                                     const QtCoreHelper::QGenericArgumentHolder &a9)
+{
+    PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
+    const bool callResult = f(r.toGenericReturnArgument(),
+                              a0.toGenericArgument(), a1.toGenericArgument(), a2.toGenericArgument(),
+                              a3.toGenericArgument(), a4.toGenericArgument(), a5.toGenericArgument(),
+                              a6.toGenericArgument(), a7.toGenericArgument(), a8.toGenericArgument(),
+                              a9.toGenericArgument());
+    PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
+    if (!callResult)
+        return PyErr_Format(PyExc_RuntimeError, "QMetaMethod invocation failed.");
+    return convertGenericReturnArgument(r.data(), r.metaType());
+}
diff --git a/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h b/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h
new file mode 100644
index 000000000..11e84b291
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h
@@ -0,0 +1,105 @@
+// 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 CORE_SNIPPETS_P_H
+#define CORE_SNIPPETS_P_H
+
+#include "pysidemacros.h"
+
+#include <sbkpython.h>
+
+#include <QtCore/qnamespace.h>
+
+#include <functional>
+
+QT_FORWARD_DECLARE_CLASS(QGenericArgument)
+QT_FORWARD_DECLARE_CLASS(QGenericReturnArgument)
+QT_FORWARD_DECLARE_CLASS(QMetaType)
+QT_FORWARD_DECLARE_CLASS(QObject)
+QT_FORWARD_DECLARE_CLASS(QRegularExpression)
+QT_FORWARD_DECLARE_CLASS(QVariant);
+
+QT_BEGIN_NAMESPACE
+namespace QtCoreHelper {
+class QGenericArgumentHolder;
+class QGenericReturnArgumentHolder;
+}
+QT_END_NAMESPACE
+
+// Helpers for QVariant conversion
+
+QMetaType QVariant_resolveMetaType(PyTypeObject *type);
+
+QVariant QVariant_convertToValueList(PyObject *list);
+
+bool QVariant_isStringList(PyObject *list);
+
+// Helpers for qAddPostRoutine
+namespace PySide {
+void globalPostRoutineCallback();
+void addPostRoutine(PyObject *callback);
+}
+
+// Helpers for QObject::findChild(ren)()
+QObject *qObjectFindChild(const QObject *parent, const QString &name,
+                          PyTypeObject *desiredType, Qt::FindChildOptions options);
+
+using FindChildHandler = std::function<void(QObject *)>;
+
+void qObjectFindChildren(const QObject *parent, const QString &name,
+                         PyTypeObject *desiredType, Qt::FindChildOptions options,
+                         FindChildHandler handler);
+
+void qObjectFindChildren(const QObject *parent, const QRegularExpression &pattern,
+                         PyTypeObject *desiredType, Qt::FindChildOptions options,
+                         FindChildHandler handler);
+
+// Helpers for translation
+QString qObjectTr(PyTypeObject *type, const char *sourceText, const char *disambiguation, int n);
+
+bool PyDate_ImportAndCheck(PyObject *pyIn);
+bool PyDateTime_ImportAndCheck(PyObject *pyIn);
+bool PyTime_ImportAndCheck(PyObject *pyIn);
+
+// Helpers for QMetaObject::invokeMethod(), QMetaMethod::invoke(). The std::function
+// serves to abstract from QMetaObject/QMetaMethod invocation parameters.
+using InvokeMetaMethodFunc =
+    std::function<bool(QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument)>;
+
+using InvokeMetaMethodFuncWithReturn =
+    std::function<bool(QGenericReturnArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument)>;
+
+// Call a void meta method from Python passing the argument holder helpers.
+PyObject *invokeMetaMethod(const InvokeMetaMethodFunc &f,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &);
+
+// Call a meta method with a return value from Python passing the argument holder
+// helpers.
+PyObject *invokeMetaMethodWithReturn(const InvokeMetaMethodFuncWithReturn &f,
+                                     const QtCoreHelper::QGenericReturnArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &);
+
+#endif // CORE_SNIPPETS_P_H
diff --git a/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.cpp b/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.cpp
new file mode 100644
index 000000000..e154b932a
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.cpp
@@ -0,0 +1,123 @@
+// 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
+
+#include <sbkpython.h>
+#include <shiboken.h>
+#include <pysideweakref.h>
+
+#include <QtCore/QEasingCurve>
+
+#include "glue/qeasingcurve_glue.h"
+
+#define MAX_CUSTOM_FUNCTIONS    10
+
+static void deleteData(void *data);
+
+struct CustomFunctionsData
+{
+    static CustomFunctionsData m_list[MAX_CUSTOM_FUNCTIONS];
+
+    PySideEasingCurveFunctor *m_obj;
+    QEasingCurve::EasingFunction m_func;
+};
+
+CustomFunctionsData CustomFunctionsData::m_list[MAX_CUSTOM_FUNCTIONS];
+
+template<int N>
+struct CustomFunctions
+{
+    static void init()
+    {
+        CustomFunctionsData data;
+        data.m_obj = 0;
+        data.m_func = &CustomFunctions<N>::callback;
+        CustomFunctionsData::m_list[N] = data;
+
+        CustomFunctions<N-1>::init();
+    }
+
+    static qreal callback(qreal v)
+    {
+        return (*CustomFunctionsData::m_list[N].m_obj)(v);
+    }
+};
+
+template<>
+struct CustomFunctions<0>
+{
+    static void init()
+    {
+        CustomFunctionsData data;
+        data.m_obj = 0;
+        data.m_func = &CustomFunctions<0>::callback;
+        CustomFunctionsData::m_list[0] = data;
+    }
+
+    static qreal callback(qreal v)
+    {
+        return (*CustomFunctionsData::m_list[0].m_obj)(v);
+    }
+};
+
+void deleteData(void *data)
+{
+    delete (PySideEasingCurveFunctor *)(data);
+}
+
+void PySideEasingCurveFunctor::init()
+{
+    CustomFunctions<MAX_CUSTOM_FUNCTIONS-1>::init();
+}
+
+QEasingCurve::EasingFunction PySideEasingCurveFunctor::createCustomFuntion(PyObject *parent, PyObject *pyFunc)
+{
+    for(int i=0; i < MAX_CUSTOM_FUNCTIONS; i++) {
+        CustomFunctionsData &data = CustomFunctionsData::m_list[i];
+        if (data.m_obj == 0) {
+            data.m_obj = new PySideEasingCurveFunctor(i, parent, pyFunc);
+            return data.m_func;
+        }
+    }
+    //PyErr_Format(PyExc_RuntimeError, "PySide only supports %d custom functions simultaneously.", MAX_CUSTOM_FUNCTIONS);
+    return 0;
+}
+
+PySideEasingCurveFunctor::~PySideEasingCurveFunctor()
+{
+
+    CustomFunctionsData::m_list[m_index].m_obj = 0;
+    PyObject_SetAttr(m_parent, Shiboken::PyMagicName::ecf(), Py_None);
+}
+
+qreal PySideEasingCurveFunctor::operator()(qreal progress)
+{
+    Shiboken::GilState state;
+    PyObject *args = Py_BuildValue("(f)", progress);
+    PyObject *result = PyObject_CallObject(m_func, args);
+    qreal cppResult = 0.0;
+    if (result) {
+        Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), result, &cppResult);
+        Py_DECREF(result);
+    }
+    Py_DECREF(args);
+    return cppResult;
+}
+
+PyObject *PySideEasingCurveFunctor::callable()
+{
+    Py_INCREF(m_func);
+    return m_func;
+}
+
+PyObject *PySideEasingCurveFunctor::callable(PyObject *parent)
+{
+    return PyObject_GetAttr(parent, Shiboken::PyMagicName::ecf());
+}
+
+PySideEasingCurveFunctor::PySideEasingCurveFunctor(int index, PyObject *parent, PyObject *pyFunc)
+    : m_parent(parent), m_func(pyFunc), m_index(index)
+{
+    PyObject_SetAttr(m_parent, Shiboken::PyMagicName::ecf(), m_func);
+    PySide::WeakRef::create(m_parent, deleteData, this);
+}
+
diff --git a/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.h b/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.h
new file mode 100644
index 000000000..78adaae2e
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/qeasingcurve_glue.h
@@ -0,0 +1,30 @@
+// 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 __QEASINGCURVE_GLUE__
+#define __QEASINGCURVE_GLUE__
+
+#include <sbkpython.h>
+#include <QtCore/QEasingCurve>
+
+class PySideEasingCurveFunctor
+{
+    public:
+        static void init();
+        static QEasingCurve::EasingFunction createCustomFuntion(PyObject *parent, PyObject *pyFunc);
+
+        qreal operator()(qreal progress);
+
+        PyObject *callable(); //Return New reference
+        static PyObject *callable(PyObject *parent); //Return New reference
+
+        ~PySideEasingCurveFunctor();
+    private:
+        PyObject *m_parent;
+        PyObject *m_func;
+        int m_index;
+
+        PySideEasingCurveFunctor(int index, PyObject *parent, PyObject *pyFunc);
+};
+
+#endif
diff --git a/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp b/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp
new file mode 100644
index 000000000..6799c0f32
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp
@@ -0,0 +1,142 @@
+// Copyright (C) 2024 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
+
+#include "qiopipe.h"
+
+#include <QtCore/private/qobject_p.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qpointer.h>
+
+#include <memory>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtCoreHelper
+{
+
+class QPipeEndPoint : public QIODevice
+{
+    Q_OBJECT
+
+public:
+    bool isSequential() const override;
+    qint64 bytesAvailable() const override;
+
+    void setRemoteEndPoint(QPipeEndPoint *other);
+
+protected:
+    qint64 readData(char *data, qint64 maxlen) override;
+    qint64 writeData(const char *data, qint64 len) override;
+
+private:
+    QByteArray m_buffer;
+    QPointer<QPipeEndPoint> m_remoteEndPoint;
+};
+
+class QIOPipePrivate final : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QIOPipe)
+public:
+    QIOPipePrivate();
+    ~QIOPipePrivate() {};
+
+    std::unique_ptr<QPipeEndPoint> end1;
+    std::unique_ptr<QPipeEndPoint> end2;
+};
+
+QIOPipe::QIOPipe(QObject *parent) : QObject(*(new QIOPipePrivate()), parent) { }
+
+bool QIOPipe::open(QIODevice::OpenMode mode)
+{
+    Q_D(QIOPipe);
+
+    if (!d->end1->open(mode))
+        return false;
+    switch (mode & QIODevice::ReadWrite) {
+    case QIODevice::WriteOnly:
+    case QIODevice::ReadOnly:
+        return d->end2->open(mode ^ QIODevice::ReadWrite);
+    default:
+        return d->end2->open(mode);
+    }
+}
+
+QIODevice *QIOPipe::end1() const
+{
+    Q_D(const QIOPipe);
+    return d->end1.get();
+}
+
+QIODevice *QIOPipe::end2() const
+{
+    Q_D(const QIOPipe);
+    return d->end2.get();
+}
+
+QIOPipePrivate::QIOPipePrivate() : end1(std::make_unique<QPipeEndPoint>()),
+                                   end2(std::make_unique<QPipeEndPoint>())
+{
+    end1->setRemoteEndPoint(end2.get());
+    end2->setRemoteEndPoint(end1.get());
+}
+
+bool QPipeEndPoint::isSequential() const
+{
+    return true;
+}
+
+qint64 QPipeEndPoint::bytesAvailable() const
+{
+    return m_buffer.size() + QIODevice::bytesAvailable();
+}
+
+void QPipeEndPoint::setRemoteEndPoint(QPipeEndPoint *other)
+{
+    m_remoteEndPoint = other;
+}
+
+qint64 QPipeEndPoint::readData(char *data, qint64 maxlen)
+{
+    maxlen = qMin(maxlen, static_cast<qint64>(m_buffer.size()));
+    if (maxlen <= 0)
+        return 0;
+
+    Q_ASSERT(maxlen > 0);
+    memcpy(data, m_buffer.data(), static_cast<size_t>(maxlen));
+    m_buffer = m_buffer.mid(maxlen);
+    return maxlen;
+}
+
+qint64 QPipeEndPoint::writeData(const char *data, qint64 len)
+{
+    if (!m_remoteEndPoint)
+        return -1;
+
+    if (len <= 0)
+        return 0;
+
+    QByteArray &buffer = m_remoteEndPoint->m_buffer;
+    const qint64 prevLen = buffer.size();
+    Q_ASSERT(prevLen >= 0);
+    len = qMin(len, std::numeric_limits<int>::max() - prevLen);
+
+    if (len == 0)
+        return 0;
+
+    Q_ASSERT(len > 0);
+    Q_ASSERT(prevLen + len > 0);
+    Q_ASSERT(prevLen + len <= std::numeric_limits<int>::max());
+
+    buffer.resize(prevLen + len);
+    memcpy(buffer.data() + prevLen, data, static_cast<size_t>(len));
+    Q_EMIT bytesWritten(len);
+    Q_EMIT m_remoteEndPoint->readyRead();
+    return len;
+}
+
+} // namespace QtCoreHelper
+
+QT_END_NAMESPACE
+
+#include "qiopipe.moc"
diff --git a/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp b/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp
new file mode 100644
index 000000000..948c0ce5c
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp
@@ -0,0 +1,108 @@
+// 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
+
+#include <qtcorehelper.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtCoreHelper {
+
+// Data classes for the generic argument data classes. The argument is freed
+// via QMetaType
+class QGenericArgumentData
+{
+public:
+    explicit QGenericArgumentData(const QMetaType &type, const void *aData) :
+        m_type(type), m_argument(m_type.name(), aData)
+    {
+    }
+
+    ~QGenericArgumentData()
+    {
+        if (m_type.isValid())
+            m_type.destroy(m_argument.data());
+    }
+
+    const QMetaType m_type;
+    const QGenericArgument m_argument;
+};
+
+class QGenericReturnArgumentData
+{
+public:
+    explicit QGenericReturnArgumentData(const QMetaType &type, void *aData) :
+          m_type(type), m_argument(m_type.name(), aData)
+    {
+    }
+
+    ~QGenericReturnArgumentData()
+    {
+        if (m_type.isValid())
+            m_type.destroy(m_argument.data());
+    }
+
+    const QMetaType m_type;
+    const QGenericReturnArgument m_argument;
+};
+
+QGenericArgumentHolder::QGenericArgumentHolder()
+{
+}
+
+QGenericArgumentHolder::QGenericArgumentHolder(const QMetaType &type, const void *aData) :
+    d(std::make_shared<QGenericArgumentData>(type, aData))
+{
+}
+
+QGenericArgumentHolder::QGenericArgumentHolder(const QGenericArgumentHolder &) = default;
+QGenericArgumentHolder::QGenericArgumentHolder(QGenericArgumentHolder &&) = default;
+QGenericArgumentHolder &QGenericArgumentHolder::operator=(const QGenericArgumentHolder &) = default;
+QGenericArgumentHolder &QGenericArgumentHolder::operator=(QGenericArgumentHolder &&) = default;
+QGenericArgumentHolder::~QGenericArgumentHolder() = default;
+
+QGenericArgument QGenericArgumentHolder::toGenericArgument() const
+{
+    return d ? d->m_argument : QGenericArgument{};
+}
+
+QMetaType QGenericArgumentHolder::metaType() const
+{
+    return d ? d->m_type : QMetaType{};
+}
+
+const void *QGenericArgumentHolder::data() const
+{
+    return d ? d->m_argument.data() : nullptr;
+}
+
+QGenericReturnArgumentHolder::QGenericReturnArgumentHolder(const QMetaType &type, void *aData) :
+      d(std::make_shared<QGenericReturnArgumentData>(type, aData))
+{
+}
+
+QGenericReturnArgumentHolder::QGenericReturnArgumentHolder(const QGenericReturnArgumentHolder &) = default;
+QGenericReturnArgumentHolder::QGenericReturnArgumentHolder(QGenericReturnArgumentHolder &&) = default;
+QGenericReturnArgumentHolder &QGenericReturnArgumentHolder::operator=(const QGenericReturnArgumentHolder &) = default;
+QGenericReturnArgumentHolder &QGenericReturnArgumentHolder::operator=(QGenericReturnArgumentHolder &&) = default;
+QGenericReturnArgumentHolder::~QGenericReturnArgumentHolder() = default;
+
+QGenericReturnArgument QGenericReturnArgumentHolder::toGenericReturnArgument() const
+{
+    return d->m_argument;
+}
+
+QMetaType QGenericReturnArgumentHolder::metaType() const
+{
+    return d->m_type;
+}
+
+const void *QGenericReturnArgumentHolder::data() const
+{
+    return d->m_argument.data();
+}
+
+} // namespace QtCoreHelper
+
+QT_END_NAMESPACE