diff options
Diffstat (limited to 'sources/pyside6/libpyside/pysideslot.cpp')
-rw-r--r-- | sources/pyside6/libpyside/pysideslot.cpp | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/sources/pyside6/libpyside/pysideslot.cpp b/sources/pyside6/libpyside/pysideslot.cpp new file mode 100644 index 000000000..fa7e89f42 --- /dev/null +++ b/sources/pyside6/libpyside/pysideslot.cpp @@ -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 + +#include "pysidesignal_p.h" +#include "pysideslot_p.h" +#include "pysidestaticstrings.h" + +#include <shiboken.h> + +#include <QtCore/QMetaObject> +#include <QtCore/QString> +#include <signature.h> + +using namespace Shiboken; + +struct SlotData +{ + QByteArray name; + QByteArray args; + QByteArray resultType; + QByteArray tag; // QMetaMethod::tag() +}; + +struct PySideSlot +{ + PyObject_HEAD + SlotData *slotData; +}; + +extern "C" +{ + +static void slotDataListDestructor(PyObject *o) +{ + delete PySide::Slot::dataListFromCapsule(o); +} + +static int slotTpInit(PyObject *, PyObject *, PyObject *); +static PyObject *slotCall(PyObject *, PyObject *, PyObject *); + +// Class Definition ----------------------------------------------- + +static PyTypeObject *createSlotType() +{ + PyType_Slot PySideSlotType_slots[] = { + {Py_tp_call, reinterpret_cast<void *>(slotCall)}, + {Py_tp_init, reinterpret_cast<void *>(slotTpInit)}, + {Py_tp_new, reinterpret_cast<void *>(PyType_GenericNew)}, + {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)}, + {0, nullptr} + }; + + PyType_Spec PySideSlotType_spec = { + "2:PySide6.QtCore.Slot", + sizeof(PySideSlot), + 0, + Py_TPFLAGS_DEFAULT, + PySideSlotType_slots, + }; + + return SbkType_FromSpec(&PySideSlotType_spec); +} + +static PyTypeObject *PySideSlot_TypeF() +{ + static auto *type = createSlotType(); + return type; +} + +int slotTpInit(PyObject *self, PyObject *args, PyObject *kw) +{ + static PyObject *emptyTuple = nullptr; + static const char *kwlist[] = {"name", "result", "tag", nullptr}; + char *argName = nullptr; + PyObject *argResult = nullptr; + char *tag = nullptr; + + if (emptyTuple == nullptr) + emptyTuple = PyTuple_New(0); + + if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sOs:QtCore.Slot", + const_cast<char **>(kwlist), + &argName, &argResult, &tag)) { + return -1; + } + + PySideSlot *data = reinterpret_cast<PySideSlot *>(self); + if (!data->slotData) + data->slotData = new SlotData; + for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) { + PyObject *argType = PyTuple_GET_ITEM(args, i); + const auto typeName = PySide::Signal::getTypeName(argType); + if (typeName.isEmpty()) { + PyErr_Format(PyExc_TypeError, "Unknown signal argument type: %s", Py_TYPE(argType)->tp_name); + return -1; + } + if (!data->slotData->args.isEmpty()) + data->slotData->args += ','; + data->slotData->args += typeName; + } + + if (argName) + data->slotData->name = argName; + + if (tag) + data->slotData->tag = tag; + + data->slotData->resultType = argResult + ? PySide::Signal::getTypeName(argResult) : PySide::Signal::voidType(); + + return 0; +} + +PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */) +{ + PyObject *callback = nullptr; + + if (!PyArg_UnpackTuple(args, "Slot.__call__", 1, 1, &callback)) + return nullptr; + Py_INCREF(callback); + + if (PyCallable_Check(callback)) { + PySideSlot *data = reinterpret_cast<PySideSlot *>(self); + + if (!data->slotData) + data->slotData = new SlotData; + + if (data->slotData->name.isEmpty()) { + // PYSIDE-198: Use PyObject_GetAttr instead of PepFunction_GetName to support Nuitka. + AutoDecRef funcName(PyObject_GetAttr(callback, PyMagicName::name())); + data->slotData->name = funcName.isNull() ? "<no name>" : String::toCString(funcName); + } + const QByteArray returnType = QMetaObject::normalizedType(data->slotData->resultType); + const QByteArray signature = data->slotData->name + '(' + data->slotData->args + ')'; + + PyObject *pySlotName = PySide::PySideMagicName::slot_list_attr(); + PySide::Slot::DataList *entryList = nullptr; + if (PyObject_HasAttr(callback, pySlotName)) { + auto *capsule = PyObject_GetAttr(callback, pySlotName); + entryList = PySide::Slot::dataListFromCapsule(capsule); + } else { + entryList = new PySide::Slot::DataList{}; + auto *capsule = PyCapsule_New(entryList, nullptr /* name */, slotDataListDestructor); + Py_INCREF(capsule); + PyObject_SetAttr(callback, pySlotName, capsule); + } + entryList->append({signature, returnType, data->slotData->tag}); + + //clear data + delete data->slotData; + data->slotData = nullptr; + } + return callback; +} + +} // extern "C" + +namespace PySide::Slot { + +DataList *dataListFromCapsule(PyObject *capsule) +{ + if (capsule != nullptr && PyCapsule_CheckExact(capsule) != 0) { + if (void *v = PyCapsule_GetPointer(capsule, nullptr)) + return reinterpret_cast<DataList *>(v); + } + return nullptr; +} + +static const char *Slot_SignatureStrings[] = { + "PySide6.QtCore.Slot(self,*types:type,name:str=nullptr,result:type=nullptr)", + "PySide6.QtCore.Slot.__call__(self,function:typing.Callable)->typing.Any", + nullptr}; // Sentinel + +void init(PyObject *module) +{ + if (InitSignatureStrings(PySideSlot_TypeF(), Slot_SignatureStrings) < 0) + return; + + Py_INCREF(PySideSlot_TypeF()); + PyModule_AddObject(module, "Slot", reinterpret_cast<PyObject *>(PySideSlot_TypeF())); +} + +} // namespace PySide::Slot |