diff options
Diffstat (limited to 'sources/pyside6/PySide6/QtQml')
9 files changed, 699 insertions, 441 deletions
diff --git a/sources/pyside6/PySide6/QtQml/CMakeLists.txt b/sources/pyside6/PySide6/QtQml/CMakeLists.txt index 2fd253b25..fdc501c25 100644 --- a/sources/pyside6/PySide6/QtQml/CMakeLists.txt +++ b/sources/pyside6/PySide6/QtQml/CMakeLists.txt @@ -1,6 +1,8 @@ project(QtQml) -set(QtQml_registerType "${QtQml_SOURCE_DIR}/pysideqmlregistertype.cpp") +set(QtQml_static_sources "${QtQml_SOURCE_DIR}/pysideqmlregistertype.cpp" + "${QtQml_SOURCE_DIR}/pysideqmllistproperty.cpp" + "${QtQml_SOURCE_DIR}/pysideqmlvolatilebool.cpp") set(QtQml_SRC ${QtQml_GEN_DIR}/qjsengine_wrapper.cpp @@ -58,4 +60,4 @@ create_pyside_module(NAME QtQml DEPS QtQml_deps TYPESYSTEM_PATH QtQml_SOURCE_DIR SOURCES QtQml_SRC - STATIC_SOURCES QtQml_registerType) + STATIC_SOURCES QtQml_static_sources) diff --git a/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.cpp b/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.cpp new file mode 100644 index 000000000..f817d26b5 --- /dev/null +++ b/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.cpp @@ -0,0 +1,319 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "pysideqmllistproperty.h" +#include "pysideqmlregistertype_p.h" + +#include <shiboken.h> +#include <signature.h> + +#include <pysideproperty.h> + +#include <QtCore/QObject> +#include <QtQml/QQmlListProperty> + +// Forward declarations. +static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, + void **args); + +extern "C" +{ + +// This is the user data we store in the property. +struct QmlListProperty +{ + PyTypeObject *type; + PyObject *append; + PyObject *count; + PyObject *at; + PyObject *clear; + PyObject *replace; + PyObject *removeLast; +}; + +static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds) +{ + static const char *kwlist[] = {"type", "append", "count", "at", "clear", "replace", "removeLast", 0}; + PySideProperty *pySelf = reinterpret_cast<PySideProperty *>(self); + QmlListProperty *data = new QmlListProperty; + memset(data, 0, sizeof(QmlListProperty)); + + if (!PyArg_ParseTupleAndKeywords(args, kwds, + "O|OOOOOO:QtQml.ListProperty", (char **) kwlist, + &data->type, + &data->append, + &data->count, + &data->at, + &data->clear, + &data->replace, + &data->removeLast)) { + delete data; + return -1; + } + + PyTypeObject *qobjectType = qObjectType(); + + if (!PySequence_Contains(data->type->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) { + PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.", + qobjectType->tp_name, data->type->tp_name); + delete data; + return -1; + } + + if ((data->append && data->append != Py_None && !PyCallable_Check(data->append)) || + (data->count && data->count != Py_None && !PyCallable_Check(data->count)) || + (data->at && data->at != Py_None && !PyCallable_Check(data->at)) || + (data->clear && data->clear != Py_None && !PyCallable_Check(data->clear)) || + (data->replace && data->replace != Py_None && !PyCallable_Check(data->replace)) || + (data->removeLast && data->removeLast != Py_None && !PyCallable_Check(data->removeLast))) { + PyErr_Format(PyExc_TypeError, "Non-callable parameter given"); + delete data; + return -1; + } + + PySide::Property::setMetaCallHandler(pySelf, &propListMetaCall); + PySide::Property::setTypeName(pySelf, "QQmlListProperty<QObject>"); + PySide::Property::setUserData(pySelf, data); + + return 0; +} + +void propListTpFree(void *self) +{ + auto pySelf = reinterpret_cast<PySideProperty *>(self); + delete reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pySelf)); + // calls base type constructor + Py_TYPE(pySelf)->tp_base->tp_free(self); +} + +static PyType_Slot PropertyListType_slots[] = { + {Py_tp_init, reinterpret_cast<void *>(propListTpInit)}, + {Py_tp_free, reinterpret_cast<void *>(propListTpFree)}, + {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)}, + {0, nullptr} +}; +static PyType_Spec PropertyListType_spec = { + "2:PySide6.QtQml.ListProperty", + sizeof(PySideProperty), + 0, + Py_TPFLAGS_DEFAULT, + PropertyListType_slots, +}; + + +PyTypeObject *PropertyListTypeF(void) +{ + static Shiboken::AutoDecRef bases(Py_BuildValue("(O)", PySidePropertyTypeF())); + static auto *type = SbkType_FromSpecWithBases(&PropertyListType_spec, bases); + return type; +} + +} // extern "C" + +// Implementation of QQmlListProperty<T>::AppendFunction callback +void propListAppender(QQmlListProperty<QObject> *propList, QObject *item) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(2)); + PyTypeObject *qobjectType = qObjectType(); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); + PyTuple_SET_ITEM(args, 1, + Shiboken::Conversions::pointerToPython(qobjectType, item)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->append, args)); + + if (PyErr_Occurred()) + PyErr_Print(); +} + +// Implementation of QQmlListProperty<T>::CountFunction callback +qsizetype propListCount(QQmlListProperty<QObject> *propList) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qObjectType(), propList->object)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->count, args)); + + // Check return type + if (PyErr_Occurred()) { + PyErr_Print(); + return 0; + } + + int cppResult = 0; + auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(); + if (auto *pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(converter, retVal)) + pythonToCpp(retVal, &cppResult); + return cppResult; +} + +// Implementation of QQmlListProperty<T>::AtFunction callback +QObject *propListAt(QQmlListProperty<QObject> *propList, qsizetype index) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(2)); + PyTypeObject *qobjectType = qObjectType(); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); + auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(); + PyTuple_SET_ITEM(args, 1, + Shiboken::Conversions::copyToPython(converter, &index)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->at, args)); + + QObject *result = 0; + if (PyErr_Occurred()) + PyErr_Print(); + else if (PyType_IsSubtype(Py_TYPE(retVal), data->type)) + Shiboken::Conversions::pythonToCppPointer(qobjectType, retVal, &result); + return result; +} + +// Implementation of QQmlListProperty<T>::ClearFunction callback +void propListClear(QQmlListProperty<QObject> * propList) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTypeObject *qobjectType = qObjectType(); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->clear, args)); + + if (PyErr_Occurred()) + PyErr_Print(); +} + +// Implementation of QQmlListProperty<T>::ReplaceFunction callback +void propListReplace(QQmlListProperty<QObject> *propList, qsizetype index, QObject *value) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(3)); + PyTypeObject *qobjectType = qObjectType(); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); + auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(); + PyTuple_SET_ITEM(args, 1, + Shiboken::Conversions::copyToPython(converter, &index)); + PyTuple_SET_ITEM(args, 2, + Shiboken::Conversions::pointerToPython(qobjectType, value)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->replace, args)); + + if (PyErr_Occurred()) + PyErr_Print(); +} + +// Implementation of QQmlListProperty<T>::RemoveLastFunction callback +void propListRemoveLast(QQmlListProperty<QObject> *propList) +{ + Shiboken::GilState state; + + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTypeObject *qobjectType = qObjectType(); + PyTuple_SET_ITEM(args, 0, + Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); + + auto data = reinterpret_cast<QmlListProperty *>(propList->data); + Shiboken::AutoDecRef retVal(PyObject_CallObject(data->removeLast, args)); + + if (PyErr_Occurred()) + PyErr_Print(); +} + +// qt_metacall specialization for ListProperties +static void propListMetaCall(PySideProperty *pp, PyObject *self, + QMetaObject::Call call, void **args) +{ + if (call != QMetaObject::ReadProperty) + return; + + auto data = reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pp)); + QObject *qobj; + PyTypeObject *qobjectType = qObjectType(); + Shiboken::Conversions::pythonToCppPointer(qobjectType, self, &qobj); + QQmlListProperty<QObject> declProp( + qobj, data, + data->append && data->append != Py_None ? &propListAppender : nullptr, + data->count && data->count != Py_None ? &propListCount : nullptr, + data->at && data->at != Py_None ? &propListAt : nullptr, + data->clear && data->clear != Py_None ? &propListClear : nullptr, + data->replace && data->replace != Py_None ? &propListReplace : nullptr, + data->removeLast && data->removeLast != Py_None ? &propListRemoveLast : nullptr); + + // Copy the data to the memory location requested by the meta call + void *v = args[0]; + *reinterpret_cast<QQmlListProperty<QObject> *>(v) = declProp; +} + +static const char *PropertyList_SignatureStrings[] = { + "PySide6.QtQml.ListProperty(self,type:type,append:typing.Callable," + "at:typing.Callable=None,clear:typing.Callable=None,count:typing.Callable=None)", + nullptr // Sentinel +}; + +void initQtQmlListProperty(PyObject *module) +{ + // Export QmlListProperty type + if (InitSignatureStrings(PropertyListTypeF(), PropertyList_SignatureStrings) < 0) { + PyErr_Print(); + qWarning() << "Error initializing PropertyList type."; + return; + } + + // Register QQmlListProperty metatype for use in QML + qRegisterMetaType<QQmlListProperty<QObject>>(); + + Py_INCREF(reinterpret_cast<PyObject *>(PropertyListTypeF())); + PyModule_AddObject(module, PepType_GetNameStr(PropertyListTypeF()), + reinterpret_cast<PyObject *>(PropertyListTypeF())); +} diff --git a/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.h b/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.h new file mode 100644 index 000000000..bfae04bfc --- /dev/null +++ b/sources/pyside6/PySide6/QtQml/pysideqmllistproperty.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PYSIDEQMLLISTPROPERTY_H +#define PYSIDEQMLLISTPROPERTY_H + +#include <sbkpython.h> + +void initQtQmlListProperty(PyObject *module); + +#endif // PYSIDEQMLLISTPROPERTY_H diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.cpp b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.cpp index aa89579be..76ea97979 100644 --- a/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.cpp +++ b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.cpp @@ -38,28 +38,21 @@ ****************************************************************************/ #include "pysideqmlregistertype.h" +#include "pysideqmlregistertype_p.h" #include <limits> // shiboken #include <shiboken.h> -#include <signature.h> +#include <sbkstring.h> // pyside #include <pyside.h> #include <pyside_p.h> -#include <pysideproperty.h> - -// auto generated headers -#include "pyside6_qtcore_python.h" -#include "pyside6_qtqml_python.h" +#include <QtCore/QMutex> #include <QtQml/QJSValue> -// Forward declarations. -static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, - void **args); - // Mutex used to avoid race condition on PySide::nextQObjectMemoryAddr. static QMutex nextQmlElementMutex; @@ -74,14 +67,37 @@ static void createInto(void *memory, void *type) PySide::setNextQObjectMemoryAddr(0); } +PyTypeObject *qObjectType() +{ + static PyTypeObject *const result = + Shiboken::Conversions::getPythonTypeObject("QObject*"); + assert(result); + return result; +} + +static PyTypeObject *qQmlEngineType() +{ + static PyTypeObject *const result = + Shiboken::Conversions::getPythonTypeObject("QQmlEngine*"); + assert(result); + return result; +} + +static PyTypeObject *qQJSValueType() +{ + static PyTypeObject *const result = + Shiboken::Conversions::getPythonTypeObject("QJSValue*"); + assert(result); + return result; +} + int PySide::qmlRegisterType(PyObject *pyObj, const char *uri, int versionMajor, int versionMinor, const char *qmlName, const char *noCreationReason, bool creatable) { using namespace Shiboken; - static PyTypeObject *qobjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); - assert(qobjectType); + PyTypeObject *qobjectType = qObjectType(); PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj); if (!PySequence_Contains(pyObjType->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) { @@ -212,23 +228,20 @@ int PySide::qmlRegisterSingletonType(PyObject *pyObj, const char *uri, int versi if (hasCallback) { PyTuple_SET_ITEM(args, 0, Conversions::pointerToPython( - SbkPySide6_QtQmlTypes[SBK_QQMLENGINE_IDX], - engine)); + qQmlEngineType(), engine)); } AutoDecRef retVal(PyObject_CallObject(hasCallback ? callback : pyObj, args)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - // Make sure the callback returns something we can convert, else the entire application will crash. if (retVal.isNull() || - Conversions::isPythonToCppPointerConvertible(qobjectType, retVal) == nullptr) { + Conversions::isPythonToCppPointerConvertible(qObjectType(), retVal) == nullptr) { PyErr_Format(PyExc_TypeError, "Callback returns invalid value."); return nullptr; } QObject *obj = nullptr; - Conversions::pythonToCppPointer(qobjectType, retVal, &obj); + Conversions::pythonToCppPointer(qObjectType(), retVal, &obj); if (obj != nullptr) Py_INCREF(retVal); @@ -242,12 +255,11 @@ int PySide::qmlRegisterSingletonType(PyObject *pyObj, const char *uri, int versi AutoDecRef args(PyTuple_New(1)); PyTuple_SET_ITEM(args, 0, Conversions::pointerToPython( - SbkPySide6_QtQmlTypes[SBK_QQMLENGINE_IDX], - engine)); + qQmlEngineType(), engine)); AutoDecRef retVal(PyObject_CallObject(callback, args)); - PyTypeObject *qjsvalueType = SbkPySide6_QtQmlTypes[SBK_QJSVALUE_IDX]; + PyTypeObject *qjsvalueType = qQJSValueType(); // Make sure the callback returns something we can convert, else the entire application will crash. if (retVal.isNull() || @@ -274,9 +286,6 @@ int PySide::qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int v { using namespace Shiboken; - static PyTypeObject *qobjectType = Conversions::getPythonTypeObject("QObject*"); - assert(qobjectType); - // Check if the Python Type inherit from QObject PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj); @@ -291,7 +300,7 @@ int PySide::qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int v // Convert the instanceObject (PyObject) into a QObject QObject *instanceQObject = reinterpret_cast<QObject*>( - Object::cppPointer(reinterpret_cast<SbkObject*>(instanceObject), qobjectType)); + Object::cppPointer(reinterpret_cast<SbkObject*>(instanceObject), qObjectType())); // Create Singleton Functor to pass the QObject to the Type registration step // similarly to the case when we have a callback @@ -317,400 +326,6 @@ int PySide::qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int v return QQmlPrivate::qmlregister(QQmlPrivate::SingletonRegistration, &type); } -extern "C" -{ - -// This is the user data we store in the property. -struct QmlListProperty -{ - PyTypeObject *type; - PyObject *append; - PyObject *count; - PyObject *at; - PyObject *clear; - PyObject *replace; - PyObject *removeLast; -}; - -static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds) -{ - static const char *kwlist[] = {"type", "append", "count", "at", "clear", "replace", "removeLast", 0}; - PySideProperty *pySelf = reinterpret_cast<PySideProperty *>(self); - QmlListProperty *data = new QmlListProperty; - memset(data, 0, sizeof(QmlListProperty)); - - if (!PyArg_ParseTupleAndKeywords(args, kwds, - "O|OOOOOO:QtQml.ListProperty", (char **) kwlist, - &data->type, - &data->append, - &data->count, - &data->at, - &data->clear, - &data->replace, - &data->removeLast)) { - delete data; - return -1; - } - - static PyTypeObject *qobjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); - assert(qobjectType); - - if (!PySequence_Contains(data->type->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) { - PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.", - qobjectType->tp_name, data->type->tp_name); - delete data; - return -1; - } - - if ((data->append && data->append != Py_None && !PyCallable_Check(data->append)) || - (data->count && data->count != Py_None && !PyCallable_Check(data->count)) || - (data->at && data->at != Py_None && !PyCallable_Check(data->at)) || - (data->clear && data->clear != Py_None && !PyCallable_Check(data->clear)) || - (data->replace && data->replace != Py_None && !PyCallable_Check(data->replace)) || - (data->removeLast && data->removeLast != Py_None && !PyCallable_Check(data->removeLast))) { - PyErr_Format(PyExc_TypeError, "Non-callable parameter given"); - delete data; - return -1; - } - - PySide::Property::setMetaCallHandler(pySelf, &propListMetaCall); - PySide::Property::setTypeName(pySelf, "QQmlListProperty<QObject>"); - PySide::Property::setUserData(pySelf, data); - - return 0; -} - -void propListTpFree(void *self) -{ - auto pySelf = reinterpret_cast<PySideProperty *>(self); - delete reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pySelf)); - // calls base type constructor - Py_TYPE(pySelf)->tp_base->tp_free(self); -} - -static PyType_Slot PropertyListType_slots[] = { - {Py_tp_init, reinterpret_cast<void *>(propListTpInit)}, - {Py_tp_free, reinterpret_cast<void *>(propListTpFree)}, - {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)}, - {0, nullptr} -}; -static PyType_Spec PropertyListType_spec = { - "2:PySide6.QtQml.ListProperty", - sizeof(PySideProperty), - 0, - Py_TPFLAGS_DEFAULT, - PropertyListType_slots, -}; - - -PyTypeObject *PropertyListTypeF(void) -{ - static Shiboken::AutoDecRef bases(Py_BuildValue("(O)", PySidePropertyTypeF())); - static auto *type = SbkType_FromSpecWithBases(&PropertyListType_spec, bases); - return type; -} - -} // extern "C" - -// Implementation of QQmlListProperty<T>::AppendFunction callback -void propListAppender(QQmlListProperty<QObject> *propList, QObject *item) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(2)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - PyTuple_SET_ITEM(args, 1, - Shiboken::Conversions::pointerToPython(qobjectType, item)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->append, args)); - - if (PyErr_Occurred()) - PyErr_Print(); -} - -// Implementation of QQmlListProperty<T>::CountFunction callback -qsizetype propListCount(QQmlListProperty<QObject> *propList) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(1)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->count, args)); - - // Check return type - int cppResult = 0; - PythonToCppFunc pythonToCpp = 0; - if (PyErr_Occurred()) - PyErr_Print(); - else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(), retVal))) - pythonToCpp(retVal, &cppResult); - return cppResult; -} - -// Implementation of QQmlListProperty<T>::AtFunction callback -QObject *propListAt(QQmlListProperty<QObject> *propList, qsizetype index) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(2)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(), &index)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->at, args)); - - QObject *result = 0; - if (PyErr_Occurred()) - PyErr_Print(); - else if (PyType_IsSubtype(Py_TYPE(retVal), data->type)) - Shiboken::Conversions::pythonToCppPointer(qobjectType, retVal, &result); - return result; -} - -// Implementation of QQmlListProperty<T>::ClearFunction callback -void propListClear(QQmlListProperty<QObject> * propList) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(1)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->clear, args)); - - if (PyErr_Occurred()) - PyErr_Print(); -} - -// Implementation of QQmlListProperty<T>::ReplaceFunction callback -void propListReplace(QQmlListProperty<QObject> *propList, qsizetype index, QObject *value) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(3)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>(), &index)); - PyTuple_SET_ITEM(args, 2, - Shiboken::Conversions::pointerToPython(qobjectType, value)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->replace, args)); - - if (PyErr_Occurred()) - PyErr_Print(); -} - -// Implementation of QQmlListProperty<T>::RemoveLastFunction callback -void propListRemoveLast(QQmlListProperty<QObject> *propList) -{ - Shiboken::GilState state; - - Shiboken::AutoDecRef args(PyTuple_New(1)); - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - PyTuple_SET_ITEM(args, 0, - Shiboken::Conversions::pointerToPython(qobjectType, propList->object)); - - auto data = reinterpret_cast<QmlListProperty *>(propList->data); - Shiboken::AutoDecRef retVal(PyObject_CallObject(data->removeLast, args)); - - if (PyErr_Occurred()) - PyErr_Print(); -} - -// qt_metacall specialization for ListProperties -static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, void **args) -{ - if (call != QMetaObject::ReadProperty) - return; - - auto data = reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pp)); - QObject *qobj; - PyTypeObject *qobjectType = SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX]; - Shiboken::Conversions::pythonToCppPointer(qobjectType, self, &qobj); - QQmlListProperty<QObject> declProp(qobj, data, - data->append && data->append != Py_None ? &propListAppender : nullptr, - data->count && data->count != Py_None ? &propListCount : nullptr, - data->at && data->at != Py_None ? &propListAt : nullptr, - data->clear && data->clear != Py_None ? &propListClear : nullptr, - data->replace && data->replace != Py_None ? &propListReplace : nullptr, - data->removeLast && data->removeLast != Py_None ? &propListRemoveLast : nullptr); - - // Copy the data to the memory location requested by the meta call - void *v = args[0]; - *reinterpret_cast<QQmlListProperty<QObject> *>(v) = declProp; -} - -// VolatileBool (volatile bool) type definition. - -static PyObject * -QtQml_VolatileBoolObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{ - static const char *kwlist[] = {"x", 0}; - PyObject *x = Py_False; - long ok; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:bool", const_cast<char **>(kwlist), &x)) - return Q_NULLPTR; - ok = PyObject_IsTrue(x); - if (ok < 0) - return Q_NULLPTR; - - QtQml_VolatileBoolObject *self - = reinterpret_cast<QtQml_VolatileBoolObject *>(type->tp_alloc(type, 0)); - - if (self != nullptr) - self->flag = new AtomicBool(ok); - - return reinterpret_cast<PyObject *>(self); -} - -static void QtQml_VolatileBoolObject_dealloc(PyObject *self) -{ - auto volatileBool = reinterpret_cast<QtQml_VolatileBoolObject *>(self); - delete volatileBool->flag; - Sbk_object_dealloc(self); -} - -static PyObject * -QtQml_VolatileBoolObject_get(QtQml_VolatileBoolObject *self) -{ - return *self->flag ? Py_True : Py_False; -} - -static PyObject * -QtQml_VolatileBoolObject_set(QtQml_VolatileBoolObject *self, PyObject *args) -{ - PyObject *value = Py_False; - long ok; - - if (!PyArg_ParseTuple(args, "O:bool", &value)) { - return Q_NULLPTR; - } - - ok = PyObject_IsTrue(value); - if (ok < 0) { - PyErr_SetString(PyExc_TypeError, "Not a boolean value."); - return Q_NULLPTR; - } - - *self->flag = ok > 0; - - Py_RETURN_NONE; -} - -static PyMethodDef QtQml_VolatileBoolObject_methods[] = { - {"get", reinterpret_cast<PyCFunction>(QtQml_VolatileBoolObject_get), METH_NOARGS, - "B.get() -> Bool. Returns the value of the volatile boolean" - }, - {"set", reinterpret_cast<PyCFunction>(QtQml_VolatileBoolObject_set), METH_VARARGS, - "B.set(a) -> None. Sets the value of the volatile boolean" - }, - {nullptr, nullptr, 0, nullptr} /* Sentinel */ -}; - -static PyObject * -QtQml_VolatileBoolObject_repr(QtQml_VolatileBoolObject *self) -{ - PyObject *s; - - if (*self->flag) - s = PyBytes_FromFormat("%s(True)", - Py_TYPE(self)->tp_name); - else - s = PyBytes_FromFormat("%s(False)", - Py_TYPE(self)->tp_name); - Py_XINCREF(s); - return s; -} - -static PyObject * -QtQml_VolatileBoolObject_str(QtQml_VolatileBoolObject *self) -{ - PyObject *s; - - if (*self->flag) - s = PyBytes_FromFormat("%s(True) -> %p", - Py_TYPE(self)->tp_name, self->flag); - else - s = PyBytes_FromFormat("%s(False) -> %p", - Py_TYPE(self)->tp_name, self->flag); - Py_XINCREF(s); - return s; -} - -static PyType_Slot QtQml_VolatileBoolType_slots[] = { - {Py_tp_repr, reinterpret_cast<void *>(QtQml_VolatileBoolObject_repr)}, - {Py_tp_str, reinterpret_cast<void *>(QtQml_VolatileBoolObject_str)}, - {Py_tp_methods, reinterpret_cast<void *>(QtQml_VolatileBoolObject_methods)}, - {Py_tp_new, reinterpret_cast<void *>(QtQml_VolatileBoolObject_new)}, - {Py_tp_dealloc, reinterpret_cast<void *>(QtQml_VolatileBoolObject_dealloc)}, - {0, 0} -}; -static PyType_Spec QtQml_VolatileBoolType_spec = { - "2:PySide6.QtQml.VolatileBool", - sizeof(QtQml_VolatileBoolObject), - 0, - Py_TPFLAGS_DEFAULT, - QtQml_VolatileBoolType_slots, -}; - - -PyTypeObject *QtQml_VolatileBoolTypeF(void) -{ - static auto *type = SbkType_FromSpec(&QtQml_VolatileBoolType_spec); - return type; -} - -static const char *PropertyList_SignatureStrings[] = { - "PySide6.QtQml.ListProperty(self,type:type,append:typing.Callable," - "at:typing.Callable=None,clear:typing.Callable=None,count:typing.Callable=None)", - nullptr}; // Sentinel - -static const char *VolatileBool_SignatureStrings[] = { - "PySide6.QtQml.VolatileBool.get(self)->bool", - "PySide6.QtQml.VolatileBool.set(self,a:object)", - nullptr}; // Sentinel - -void PySide::initQmlSupport(PyObject *module) -{ - // Export QmlListProperty type - if (InitSignatureStrings(PropertyListTypeF(), PropertyList_SignatureStrings) < 0) { - PyErr_Print(); - qWarning() << "Error initializing PropertyList type."; - return; - } - - // Register QQmlListProperty metatype for use in QML - qRegisterMetaType<QQmlListProperty<QObject>>(); - - Py_INCREF(reinterpret_cast<PyObject *>(PropertyListTypeF())); - PyModule_AddObject(module, PepType_GetNameStr(PropertyListTypeF()), - reinterpret_cast<PyObject *>(PropertyListTypeF())); - - if (InitSignatureStrings(QtQml_VolatileBoolTypeF(), VolatileBool_SignatureStrings) < 0) { - PyErr_Print(); - qWarning() << "Error initializing VolatileBool type."; - return; - } - - Py_INCREF(QtQml_VolatileBoolTypeF()); - PyModule_AddObject(module, PepType_GetNameStr(QtQml_VolatileBoolTypeF()), - reinterpret_cast<PyObject *>(QtQml_VolatileBoolTypeF())); -} - static std::string getGlobalString(const char *name) { using Shiboken::AutoDecRef; @@ -756,11 +371,8 @@ PyObject *PySide::qmlElementMacro(PyObject *pyObj) return nullptr; } - static PyTypeObject *qobjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); - assert(qobjectType); - PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj); - if (!PySequence_Contains(pyObjType->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) { + if (!PySequence_Contains(pyObjType->tp_mro, reinterpret_cast<PyObject *>(qObjectType()))) { PyErr_Format(PyExc_TypeError, "This decorator can only be used with classes inherited from QObject, got %s.", pyObjType->tp_name); return nullptr; } diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.h b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.h index 0dbfb6e5a..5c2c15c3d 100644 --- a/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.h +++ b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype.h @@ -48,14 +48,6 @@ namespace PySide extern void *nextQmlElementMemoryAddr; /** - * Init the QML support doing things like registering QtQml.ListProperty and create the necessary stuff for - * qmlRegisterType. - * - * \param module QtQml python module - */ -void initQmlSupport(PyObject *module); - -/** * PySide implementation of qmlRegisterType<T> function. * * \param pyObj Python type to be registered. @@ -103,10 +95,6 @@ int qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int versionMa * \param pyObj Python type to be registered */ PyObject *qmlElementMacro(PyObject *pyObj); -} - -PyTypeObject *QtQml_VolatileBoolTypeF(void); - -#define VolatileBool_Check(op) (Py_TYPE(op) == QtQml_VolatileBoolTypeF()) +} // namespace PySide -#endif +#endif // PYSIDEQMLREGISTERTYPE_H diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlregistertype_p.h b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype_p.h new file mode 100644 index 000000000..d357a0392 --- /dev/null +++ b/sources/pyside6/PySide6/QtQml/pysideqmlregistertype_p.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PYSIDEQMLREGISTERTYPE_P_H +#define PYSIDEQMLREGISTERTYPE_P_H + +#include <sbkpython.h> + +PyTypeObject *qObjectType(); + +#endif // PYSIDEQMLREGISTERTYPE_P_H diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp new file mode 100644 index 000000000..5aa9fde1a --- /dev/null +++ b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp @@ -0,0 +1,190 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "pysideqmlvolatilebool.h" + +#include <signature.h> + +#include <QtCore/QDebug> + +// Volatile Bool used for QQmlIncubationController::incubateWhile(std::atomic<bool> *, int) + +// Generated headers containing the definition of struct +// QtQml_VolatileBoolObject. It is injected to avoid "pyside6_qtqml_python.h" +// depending on other headers. +#include "pyside6_qtcore_python.h" +#include "pyside6_qtqml_python.h" + +// VolatileBool (volatile bool) type definition. + +static PyObject * +QtQml_VolatileBoolObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + static const char *kwlist[] = {"x", 0}; + PyObject *x = Py_False; + long ok; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:bool", const_cast<char **>(kwlist), &x)) + return nullptr; + ok = PyObject_IsTrue(x); + if (ok < 0) + return nullptr; + + QtQml_VolatileBoolObject *self + = reinterpret_cast<QtQml_VolatileBoolObject *>(type->tp_alloc(type, 0)); + + if (self != nullptr) + self->flag = new AtomicBool(ok); + + return reinterpret_cast<PyObject *>(self); +} + +static void QtQml_VolatileBoolObject_dealloc(PyObject *self) +{ + auto volatileBool = reinterpret_cast<QtQml_VolatileBoolObject *>(self); + delete volatileBool->flag; + Sbk_object_dealloc(self); +} + +static PyObject * +QtQml_VolatileBoolObject_get(QtQml_VolatileBoolObject *self) +{ + return *self->flag ? Py_True : Py_False; +} + +static PyObject * +QtQml_VolatileBoolObject_set(QtQml_VolatileBoolObject *self, PyObject *args) +{ + PyObject *value = Py_False; + long ok; + + if (!PyArg_ParseTuple(args, "O:bool", &value)) { + return nullptr; + } + + ok = PyObject_IsTrue(value); + if (ok < 0) { + PyErr_SetString(PyExc_TypeError, "Not a boolean value."); + return nullptr; + } + + *self->flag = ok > 0; + + Py_RETURN_NONE; +} + +static PyMethodDef QtQml_VolatileBoolObject_methods[] = { + {"get", reinterpret_cast<PyCFunction>(QtQml_VolatileBoolObject_get), METH_NOARGS, + "B.get() -> Bool. Returns the value of the volatile boolean" + }, + {"set", reinterpret_cast<PyCFunction>(QtQml_VolatileBoolObject_set), METH_VARARGS, + "B.set(a) -> None. Sets the value of the volatile boolean" + }, + {nullptr, nullptr, 0, nullptr} /* Sentinel */ +}; + +static PyObject * +QtQml_VolatileBoolObject_repr(QtQml_VolatileBoolObject *self) +{ + PyObject *s; + + if (*self->flag) + s = PyBytes_FromFormat("%s(True)", + Py_TYPE(self)->tp_name); + else + s = PyBytes_FromFormat("%s(False)", + Py_TYPE(self)->tp_name); + Py_XINCREF(s); + return s; +} + +static PyObject * +QtQml_VolatileBoolObject_str(QtQml_VolatileBoolObject *self) +{ + PyObject *s; + + if (*self->flag) + s = PyBytes_FromFormat("%s(True) -> %p", + Py_TYPE(self)->tp_name, self->flag); + else + s = PyBytes_FromFormat("%s(False) -> %p", + Py_TYPE(self)->tp_name, self->flag); + Py_XINCREF(s); + return s; +} + +static PyType_Slot QtQml_VolatileBoolType_slots[] = { + {Py_tp_repr, reinterpret_cast<void *>(QtQml_VolatileBoolObject_repr)}, + {Py_tp_str, reinterpret_cast<void *>(QtQml_VolatileBoolObject_str)}, + {Py_tp_methods, reinterpret_cast<void *>(QtQml_VolatileBoolObject_methods)}, + {Py_tp_new, reinterpret_cast<void *>(QtQml_VolatileBoolObject_new)}, + {Py_tp_dealloc, reinterpret_cast<void *>(QtQml_VolatileBoolObject_dealloc)}, + {0, 0} +}; +static PyType_Spec QtQml_VolatileBoolType_spec = { + "2:PySide6.QtQml.VolatileBool", + sizeof(QtQml_VolatileBoolObject), + 0, + Py_TPFLAGS_DEFAULT, + QtQml_VolatileBoolType_slots, +}; + +PyTypeObject *QtQml_VolatileBoolTypeF(void) +{ + static auto *type = SbkType_FromSpec(&QtQml_VolatileBoolType_spec); + return type; +} + +static const char *VolatileBool_SignatureStrings[] = { + "PySide6.QtQml.VolatileBool.get(self)->bool", + "PySide6.QtQml.VolatileBool.set(self,a:object)", + nullptr}; // Sentinel + +void initQtQmlVolatileBool(PyObject *module) +{ + if (InitSignatureStrings(QtQml_VolatileBoolTypeF(), VolatileBool_SignatureStrings) < 0) { + PyErr_Print(); + qWarning() << "Error initializing VolatileBool type."; + return; + } + + Py_INCREF(QtQml_VolatileBoolTypeF()); + PyModule_AddObject(module, PepType_GetNameStr(QtQml_VolatileBoolTypeF()), + reinterpret_cast<PyObject *>(QtQml_VolatileBoolTypeF())); +} diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.h b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.h new file mode 100644 index 000000000..c67172563 --- /dev/null +++ b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.h @@ -0,0 +1,51 @@ +/**************************************************************************** +** +** Copyright (C) 2021 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt for Python. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PYSIDEQMLVOLATILEBOOL_H +#define PYSIDEQMLVOLATILEBOOL_H + +#include <sbkpython.h> + +PyTypeObject *QtQml_VolatileBoolTypeF(void); + +#define VolatileBool_Check(op) (Py_TYPE(op) == QtQml_VolatileBoolTypeF()) + +void initQtQmlVolatileBool(PyObject *module); + +#endif // PYSIDEQMLVOLATILEBOOL_H diff --git a/sources/pyside6/PySide6/QtQml/typesystem_qml.xml b/sources/pyside6/PySide6/QtQml/typesystem_qml.xml index 340869df1..eb05cdff8 100644 --- a/sources/pyside6/PySide6/QtQml/typesystem_qml.xml +++ b/sources/pyside6/PySide6/QtQml/typesystem_qml.xml @@ -57,6 +57,8 @@ <inject-code class="native" position="beginning"> #include "pysideqmlregistertype.h" + #include "pysideqmllistproperty.h" + #include "pysideqmlvolatilebool.h" </inject-code> <!-- This is to inform the generator that the VolatileBool python type exists --> @@ -71,7 +73,7 @@ <enum-type name="QQmlModuleImportSpecialVersions" since="6.0"/> <!-- expose QQmlIncubationController::incubateWhile() (see - QtQml_VolatileBoolTypeF/pysideqmlregistertype.h) --> + QtQml_VolatileBoolTypeF/pysideqmlvolatilebool.h) --> <namespace-type name="std" generate="no"> <value-type name="atomic" generate="no"/> </namespace-type> @@ -235,7 +237,7 @@ </object-type> <object-type name="QQmlIncubationController"> <extra-includes> - <include file-name="pysideqmlregistertype.h" location="local"/> + <include file-name="pysideqmlvolatilebool.h" location="local"/> </extra-includes> <modify-function signature="incubateWhile(std::atomic<bool>*,int)" allow-thread="yes"> <modify-argument index="1"> |