aboutsummaryrefslogtreecommitdiffstats
path: root/sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp
diff options
context:
space:
mode:
authorBrett Stottlemyer <bstottle@ford.com>2024-12-18 10:33:56 -0500
committerFriedemann Kleint <Friedemann.Kleint@qt.io>2025-03-13 16:28:42 +0100
commit19abd816e73bebdd489408d0a3b7676822bff39c (patch)
tree8459ae9401f5e190995b3e24b6ae6968cf457baf /sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp
parent3c66c456aeab597b7cb046f81c7f015433bb57a4 (diff)
Make Remote Objects usable beyond Models
While present, the Qt Remote Objects bindings to Python have not been very useful. The only usable components were those based on QAbstractItemModel, due to the lack of a way to interpret .rep files from Python. This addresses that limitation. Fixes: PYSIDE-862 Change-Id: Ice57c0c64f11c3c7e74d50ce3c48617bd9b422a3 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io> Reviewed-by: Brett Stottlemyer <brett.stottlemyer@gmail.com>
Diffstat (limited to 'sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp')
-rw-r--r--sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp260
1 files changed, 260 insertions, 0 deletions
diff --git a/sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp b/sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp
new file mode 100644
index 000000000..abfeaa037
--- /dev/null
+++ b/sources/pyside6/libpysideremoteobjects/pysidedynamicpod.cpp
@@ -0,0 +1,260 @@
+// Copyright (C) 2025 Ford Motor Company
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "pysidedynamicpod_p.h"
+#include "pysidecapsulemethod_p.h"
+#include "pysidedynamiccommon_p.h"
+
+#include <autodecref.h>
+#include <helper.h>
+#include <pep384ext.h>
+#include <sbkconverter.h>
+#include <sbkstaticstrings.h>
+#include <sbkstring.h>
+
+#include <pysidestaticstrings.h>
+
+#include <QtCore/qmetaobject.h>
+
+using namespace Shiboken;
+
+extern "C"
+{
+
+struct PodDefs
+{
+ static PyObject *tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+ {
+ SBK_UNUSED(kwds);
+ AutoDecRef param_types(PyObject_GetAttrString(reinterpret_cast<PyObject *>(type),
+ "__param_types__"));
+ if (!param_types) {
+ PyErr_Format(PyExc_RuntimeError, "Failed to get POD attributes for type %s",
+ type->tp_name);
+ return nullptr;
+ }
+
+ // param_types is a tuple of PyTypeObject pointers
+ Py_ssize_t size = PyTuple_Size(param_types);
+ if (size != PyTuple_Size(args)) {
+ PyErr_Format(PyExc_TypeError,
+ "Incorrect number of arguments for type %s. Expected %zd.",
+ type->tp_name, size);
+ return nullptr;
+ }
+
+ PyObject *self = PepExt_Type_GetAllocSlot(type)(type, size);
+
+ if (!self)
+ return nullptr;
+
+ for (Py_ssize_t i = 0; i < size; ++i) {
+ PyObject *expected_type = PyTuple_GetItem(param_types, i);
+ PyObject *item = PyTuple_GetItem(args, i);
+ // Check if the item is an instance of the expected type
+ if (PyObject_IsInstance(item, expected_type)) {
+ Py_INCREF(item);
+ PyTuple_SetItem(self, i, item);
+ } else {
+ // Try to convert the item to the expected type
+ PyObject *converted_item = PyObject_CallFunctionObjArgs(expected_type, item, nullptr);
+ if (!converted_item) {
+ Py_DECREF(self);
+ PyErr_Format(PyExc_TypeError, "Argument %zd must be convertible to type %s", i,
+ reinterpret_cast<PyTypeObject *>(expected_type)->tp_name);
+ return nullptr;
+ }
+ PyTuple_SetItem(self, i, converted_item);
+ }
+ }
+
+ return self;
+ }
+
+ static PyObject *tp_repr(PyObject *self)
+ {
+ auto *type = Py_TYPE(self);
+ std::string repr(type->tp_name);
+ repr += "(";
+ for (Py_ssize_t i = 0; i < PyTuple_Size(self); ++i) {
+ if (i > 0)
+ repr += ", ";
+
+ PyObject *item_repr = PyObject_Repr(PyTuple_GetItem(self, i));
+ repr += String::toCString(item_repr);
+ }
+ repr += ")";
+ return PyUnicode_FromString(repr.c_str());
+ }
+
+ static PyObject *CapsuleMethod_handler(PyObject *payload, PyObject * /* args */)
+ {
+ auto *methodData = reinterpret_cast<CapsuleDescriptorData *>(
+ PyCapsule_GetPointer(payload, "Payload"));
+ if (!methodData) {
+ PyErr_SetString(PyExc_RuntimeError, "Invalid call to dynamic method. Missing payload.");
+ return nullptr;
+ }
+ PyObject *self = methodData->self;
+ if (PyCapsule_IsValid(methodData->payload, "PropertyCapsule")) {
+ // Handle property getter/setter against our hidden properties attribute
+ auto *capsule = PyCapsule_GetPointer(methodData->payload, "PropertyCapsule");
+ if (capsule) {
+ auto *callData = reinterpret_cast<PropertyCapsule *>(capsule);
+ if (callData->indexInObject < 0 || callData->indexInObject >= PyTuple_Size(self)) {
+ PyErr_Format(PyExc_RuntimeError, "Unknown property method: %s",
+ callData->name.constData());
+ return nullptr;
+ }
+ auto *val = PyTuple_GetItem(self, callData->indexInObject);
+ Py_INCREF(val);
+ return val;
+ }
+ }
+
+ PyErr_SetString(PyExc_RuntimeError, "Unknown capsule type");
+ return nullptr;
+ }
+};
+
+static PyMethodDef DynamicPod_tp_methods[] = {
+ {"get_enum", reinterpret_cast<PyCFunction>(DynamicType_get_enum), METH_O | METH_CLASS,
+ "Get enum type by name"},
+ {nullptr, nullptr, 0, nullptr}
+};
+
+static PyType_Slot DynamicPod_slots[] = {
+ {Py_tp_base, reinterpret_cast<void *>(&PyTuple_Type)},
+ {Py_tp_new, reinterpret_cast<void *>(PodDefs::tp_new)},
+ {Py_tp_repr, reinterpret_cast<void *>(PodDefs::tp_repr)},
+ {Py_tp_methods, reinterpret_cast<void *>(DynamicPod_tp_methods)},
+ {0, nullptr}
+};
+
+// C++ to Python conversion for POD types.
+static PyObject *cppToPython_POD_Tuple(const void *cppIn)
+{
+ const auto &cppInRef = *reinterpret_cast<const QVariantList *>(cppIn);
+ PyObject *pyOut = PyTuple_New(Py_ssize_t(cppInRef.size()));
+ Py_ssize_t idx = 0;
+ for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
+ static const Conversions::SpecificConverter argConverter("QVariant");
+ const auto &cppItem = *it;
+ PyTuple_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(argConverter, &cppItem));
+ }
+ return pyOut;
+}
+static void pythonToCpp_Tuple_POD(PyObject *pyIn, void *cppOut)
+{
+ auto &cppOutRef = *reinterpret_cast<QVariantList *>(cppOut);
+
+ Py_ssize_t tupleSize = PyTuple_Size(pyIn);
+ if (tupleSize != cppOutRef.size()) {
+ PyErr_Format(PyExc_ValueError,
+ "Size mismatch: tuple has %zd elements, but POD expects %d elements",
+ tupleSize, cppOutRef.size());
+ return;
+ }
+
+ for (Py_ssize_t i = 0; i < tupleSize; ++i) {
+ static const Conversions::SpecificConverter argConverter("QVariant");
+ PyObject *item = PyTuple_GetItem(pyIn, i);
+ QVariant &variant = cppOutRef[i];
+ Conversions::SpecificConverter converter(variant.metaType().name());
+ Shiboken::Conversions::pythonToCppCopy(converter, item, variant.data());
+ }
+}
+static PythonToCppFunc is_Tuple_PythonToCpp_POD_Convertible(PyObject *pyIn)
+{
+ if (PyTuple_Check(pyIn))
+ return pythonToCpp_Tuple_POD;
+
+ return {};
+}
+
+} // extern "C"
+
+PyTypeObject *createPodType(QMetaObject *meta)
+{
+ auto qualname = QByteArrayLiteral("DynamicPod.") + meta->className();
+ PyType_Spec spec = {
+ qualname.constData(),
+ 0,
+ 0,
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_TYPE_SUBCLASS,
+ DynamicPod_slots
+ };
+
+ PyObject *obType = PyType_FromSpec(&spec);
+ if (!obType)
+ return nullptr;
+
+ if (create_managed_py_enums(obType, meta) < 0)
+ return nullptr;
+
+ Py_ssize_t size = meta->propertyCount() - meta->propertyOffset();
+ AutoDecRef pyParamTypes(PyTuple_New(size));
+ for (int i = 0; i < size; ++i) {
+ auto metaProperty = meta->property(i + meta->propertyOffset());
+ auto metaType = metaProperty.metaType();
+ if (!metaType.isValid()) {
+ PyErr_Format(PyExc_RuntimeError, "Failed to get meta type for property %s",
+ metaProperty.name());
+ return nullptr;
+ }
+ auto *pyType = Conversions::getPythonTypeObject(metaType.name());
+ Py_INCREF(pyType);
+ PyTuple_SetItem(pyParamTypes, i, reinterpret_cast<PyObject *>(pyType));
+ }
+
+ auto *type = reinterpret_cast<PyTypeObject *>(obType);
+ PyMethodDef method = {
+ nullptr,
+ reinterpret_cast<PyCFunction>(PodDefs::CapsuleMethod_handler),
+ METH_VARARGS,
+ nullptr
+ };
+ for (int i = meta->propertyOffset(); i < meta->propertyCount(); ++i) {
+ // Create a PropertyCapsule for each property to store the info needed
+ // for the handler.
+ auto metaProperty = meta->property(i);
+
+ method.ml_name = metaProperty.name();
+ auto *capsule = PyCapsule_New(new PropertyCapsule{metaProperty.name(),
+ i,
+ i - meta->propertyOffset()},
+ "PropertyCapsule",
+ [](PyObject *capsule) {
+ delete static_cast<PropertyCapsule *>(
+ PyCapsule_GetPointer(capsule, "PropertyCapsule"));
+ });
+ auto *capsulePropObject = make_capsule_property(&method, capsule);
+ if (PyObject_SetAttrString(reinterpret_cast<PyObject *>(type), metaProperty.name(),
+ capsulePropObject) < 0) {
+ return nullptr;
+ }
+
+ Py_DECREF(capsulePropObject);
+ }
+
+ // createConverter increases the ref count of type, but that will create
+ // a circular reference. When we add the capsule with the converter's pointer
+ // to the type's attributes. So we need to decrease the ref count on the type
+ // after calling createConverter.
+ auto *converter = Shiboken::Conversions::createConverter(type, cppToPython_POD_Tuple);
+ Py_DECREF(type);
+ if (set_cleanup_capsule_attr_for_pointer(type, "_converter_capsule", converter) < 0)
+ return nullptr;
+ Shiboken::Conversions::registerConverterName(converter, meta->className());
+ Shiboken::Conversions::registerConverterName(converter, type->tp_name);
+ Shiboken::Conversions::addPythonToCppValueConversion(converter, pythonToCpp_Tuple_POD,
+ is_Tuple_PythonToCpp_POD_Convertible);
+
+ static PyObject *const module = String::createStaticString("PySide6.QtRemoteObjects");
+ AutoDecRef pyQualname(String::fromCString(qualname.constData()));
+ PyObject_SetAttr(obType, PyMagicName::qualname(), pyQualname);
+ PyObject_SetAttr(obType, PyMagicName::module(), module);
+ PyObject_SetAttrString(obType, "__param_types__", pyParamTypes);
+
+ return type;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-19 01:13:02 +0000