#include "PythonQtClassWrapper.h"

#include <QObject>

#include "PythonQt.h"

#include "PythonQtSlot.h"

#include "PythonQtSignal.h"

#include "PythonQtClassInfo.h"

#include "PythonQtConversion.h"

#include "PythonQtInstanceWrapper.h"

static PyObject* PythonQtInstanceWrapper_invert(PythonQtInstanceWrapper* wrapper)

{

PyObject* result = nullptr;

static QByteArray memberName = "__invert__";

PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);

if (opSlot._type == PythonQtMemberInfo::Slot) {

result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, nullptr, nullptr,

wrapper->_wrappedPtr);

}

return result;

}

static PyObject* PythonQtInstanceWrapper_negative(PythonQtInstanceWrapper* wrapper)

{

PyObject* result = nullptr;

static QByteArray memberName = "__sub__";

PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);

if (opSlot._type == PythonQtMemberInfo::Slot) {

result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, nullptr, nullptr,

wrapper->_wrappedPtr);

}

return result;

}

static PyObject* PythonQtInstanceWrapper_positive(PythonQtInstanceWrapper* wrapper)

{

PyObject* result = nullptr;

static QByteArray memberName = "__add__";

PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);

if (opSlot._type == PythonQtMemberInfo::Slot) {

result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, nullptr, nullptr,

wrapper->_wrappedPtr);

}

return result;

}

static int PythonQtInstanceWrapper_nonzero(PythonQtInstanceWrapper* wrapper)

}

static Py_ssize_t PythonQtInstanceWrapper_length(PythonQtInstanceWrapper* wrapper)

}

static int PythonQtInstanceWrapper_setitem(PyObject* self, PyObject* index, PyObject* value)

}

static PyObject* PythonQtInstanceWrapper_binaryfunc(PyObject* self, PyObject* other, const QByteArray& opName,

const QByteArray& fallbackOpName = QByteArray())

{

// since we disabled type checking, we can receive any object as self, but we currently only support

// different objects on the right. Otherwise we would need to generate __radd__ etc. methods.

if (!PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {

QString error =

"Unsupported operation " + opName + "(" + self->ob_type->tp_name + ", " + other->ob_type->tp_name + ")";

PyErr_SetString(PyExc_ArithmeticError, QStringToPythonCharPointer(error));

return nullptr;

}

PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self;

PyObject* result = nullptr;

PythonQtMemberInfo opSlot = wrapper->classInfo()->member(opName);

if (opSlot._type == PythonQtMemberInfo::Slot) {

PyObject* args = PyTuple_New(1);

Py_INCREF(other);

PyTuple_SET_ITEM(args, 0, other);

result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, nullptr,

wrapper->_wrappedPtr);

Py_DECREF(args);

if (!result && !fallbackOpName.isEmpty()) {

// try fallback if we did not get a result

result = PythonQtInstanceWrapper_binaryfunc(self, other, fallbackOpName);

}

}

return result;

}

static PyObject* PythonQtInstanceWrapper_mul(PyObject* self, PyObject* other)

{

// since we disabled type checking, we can receive any object as self,

// in case of multiplication we support this by switching the types:

if (!PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {

PyObject* tmp;

tmp = self;

self = other;

other = tmp;

}

PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self;

PyObject* result = nullptr;

PythonQtMemberInfo opSlot = wrapper->classInfo()->member("__mul__");

if (opSlot._type == PythonQtMemberInfo::Slot) {

PyObject* args = PyTuple_New(1);

Py_INCREF(other);

PyTuple_SET_ITEM(args, 0, other);

result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, nullptr,

wrapper->_wrappedPtr);

Py_DECREF(args);

}

return result;

}

#define BINARY_OP(NAME) \

static PyObject* PythonQtInstanceWrapper_##NAME(PyObject* self, PyObject* other) \

{ \

static const QByteArray opName("__" #NAME "__"); \

return PythonQtInstanceWrapper_binaryfunc(self, other, opName); \

}

#define BINARY_OP_INPLACE(NAME) \

static PyObject* PythonQtInstanceWrapper_i##NAME(PyObject* self, PyObject* other) \

{ \

static const QByteArray opName("__i" #NAME "__"); \

static const QByteArray fallbackName("__" #NAME "__"); \

return PythonQtInstanceWrapper_binaryfunc(self, other, opName, fallbackName); \

}

BINARY_OP(add)

BINARY_OP(sub)

BINARY_OP(div)

BINARY_OP(and)

BINARY_OP(or)

BINARY_OP(xor)

BINARY_OP(mod)

BINARY_OP(lshift)

BINARY_OP(rshift)

BINARY_OP(getitem)

BINARY_OP_INPLACE(add)

BINARY_OP_INPLACE(sub)

BINARY_OP_INPLACE(mul)

BINARY_OP_INPLACE(div)

BINARY_OP_INPLACE(and)

BINARY_OP_INPLACE(or)

BINARY_OP_INPLACE(xor)

BINARY_OP_INPLACE(mod)

BINARY_OP_INPLACE(lshift)

BINARY_OP_INPLACE(rshift)

static void initializeSlots(PythonQtClassWrapper* wrap)

}

static PyObject* PythonQtClassWrapper_alloc(PyTypeObject* self, Py_ssize_t nitems)

{

// call the default type alloc

PyObject* obj = PyType_Type.tp_alloc(self, nitems);

// take current class type, if we are called via newPythonQtClassWrapper()

PythonQtClassWrapper* wrap = (PythonQtClassWrapper*)obj;

wrap->_classInfo = PythonQt::priv()->currentClassInfoForClassWrapperCreation();

if (wrap->_classInfo) {

initializeSlots(wrap);

}

return obj;

}

static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args, PyObject* kwds)

}

static PyObject* PythonQtClassWrapper_classname(PythonQtClassWrapper* type)

{

return PyUnicode_FromString((QByteArray("Class_") + type->classInfo()->className()).constData());

}

static PyObject* PythonQtClassWrapper_help(PythonQtClassWrapper* type)

{

return PythonQt::self()->helpCalled(type->classInfo());

}

PyObject* PythonQtClassWrapper_delete(PythonQtClassWrapper* type, PyObject* args)

{

Q_UNUSED(type)

Py_ssize_t argc = PyTuple_Size(args);

if (argc > 0) {

PyObject* self = PyTuple_GET_ITEM(args, 0);

if (PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {

return PythonQtInstanceWrapper_delete((PythonQtInstanceWrapper*)self);

}

}

return nullptr;

}

PyObject* PythonQtClassWrapper_inherits(PythonQtClassWrapper* type, PyObject* args)

{

Q_UNUSED(type)

PythonQtInstanceWrapper* wrapper = nullptr;

char* name = nullptr;

if (!PyArg_ParseTuple(args, "O!s:PythonQtClassWrapper.inherits", &PythonQtInstanceWrapper_Type, &wrapper, &name)) {

return nullptr;

}

return PythonQtConv::GetPyBool(wrapper->classInfo()->inherits(name));

}

static PyMethodDef PythonQtClassWrapper_methods[] = {

{"className", reinterpret_cast<PyCFunction>(reinterpret_cast<void*>(PythonQtClassWrapper_classname)), METH_NOARGS,

"Return the classname of the object"},

{"inherits", reinterpret_cast<PyCFunction>(reinterpret_cast<void*>(PythonQtClassWrapper_inherits)), METH_VARARGS,

"Returns if the class inherits or is of given type name"},

{"help", reinterpret_cast<PyCFunction>(reinterpret_cast<void*>(PythonQtClassWrapper_help)), METH_NOARGS,

"Shows the help of available methods for this class"},

{"delete", reinterpret_cast<PyCFunction>(reinterpret_cast<void*>(PythonQtClassWrapper_delete)), METH_VARARGS,

"Deletes the given C++ object"},

{nullptr, nullptr, 0, nullptr} /* Sentinel */

};

static PyObject* PythonQtClassWrapper_getDummyInstanceForProperty(PythonQtClassWrapper* wrapper,

const QString& property)

{

PythonQtClassInfo* info = wrapper->classInfo()->getClassInfoForProperty(property);

if (info) {

return (PyObject*)PythonQt::priv()->createNewPythonQtInstanceWrapper(nullptr, info);

}

Py_RETURN_NONE;

}

static PyObject* PythonQtClassWrapper_getattro(PyObject* obj, PyObject* name)

{

const char* attributeName;

PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;

if ((attributeName = PyUnicode_AsUTF8(name)) == nullptr) {

return nullptr;

}

if (obj == (PyObject*)&PythonQtInstanceWrapper_Type) {

// if we are called as PythonQtInstanceWrapper_Type, we need to get the properties from the type...

PyObject* superAttr = PyType_Type.tp_getattro(obj, name);

return superAttr;

}

if (qstrcmp(attributeName, "__dict__") == 0) {

PyObject* objectDict = ((PyTypeObject*)wrapper)->tp_dict;

if (!wrapper->classInfo()) {

Py_INCREF(objectDict);

return objectDict;

}

PyObject* dict = PyDict_New();

auto members = wrapper->classInfo()->memberList();

auto properties = wrapper->classInfo()->propertyList();

#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))

QSet<QString> completeSet(members.begin(), members.end());

completeSet.unite(QSet<QString>(properties.begin(), properties.end()));

#else

QSet<QString> completeSet = QSet<QString>::fromList(members);

completeSet.unite(QSet<QString>::fromList(properties));

#endif

for (const QString& name : qAsConst(completeSet)) {

if (name.startsWith("py_")) {

// do not expose internal slots

continue;

}

PyObject* o = PyObject_GetAttrString(obj, QStringToPythonConstCharPointer(name));

if (o) {

PyDict_SetItemString(dict, QStringToPythonConstCharPointer(name), o);

Py_DECREF(o);

} else {

// we should not get here anymore, but ignore this anyways.

PyErr_Clear();

}

}

if (wrapper->classInfo()->constructors()) {

PyObject* initName = PyUnicode_FromString("__init__");

PyObject* func = PyType_Type.tp_getattro(obj, initName);

Py_DECREF(initName);

PyDict_SetItemString(dict, "__init__", func);

Py_DECREF(func);

}

for (int i = 0; PythonQtClassWrapper_methods[i].ml_name != nullptr; i++) {

PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);

PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);

Py_DECREF(func);

}

PyDict_Update(dict, objectDict);

return dict;

}

// look in Python to support derived Python classes

PyObject* superAttr = PyType_Type.tp_getattro(obj, name);

if (superAttr) {

return superAttr;

}

PyErr_Clear();

if ((qstrncmp("py_", attributeName, 3) != 0) && wrapper->classInfo()) {

PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);

if (member._type == PythonQtMemberInfo::EnumValue) {

PyObject* enumValue = member._enumValue;

Py_INCREF(enumValue);

return enumValue;

} else if (member._type == PythonQtMemberInfo::EnumWrapper || member._type == PythonQtMemberInfo::NestedClass) {

PyObject* enumWrapper = member._pythonType;

Py_INCREF(enumWrapper);

return enumWrapper;

} else if (member._type == PythonQtMemberInfo::Slot) {

// NOTE: this does an extra lookup and string copy, it might be better to move this to

// PythonQtClassInfo and add a new cache for qualified class methods...

QByteArray qualifiedMemberName = "py_q_";

qualifiedMemberName += attributeName;

PythonQtMemberInfo qualifiedMember = wrapper->classInfo()->member(qualifiedMemberName);

if (qualifiedMember._type == PythonQtMemberInfo::Slot) {

// return the qualified member, so that virtual calls on classes call the qualified member

return PythonQtSlotFunction_New(qualifiedMember._slot, obj, nullptr);

} else {

// we return all slots, even the instance slots, since they are callable as unbound slots with self argument

return PythonQtSlotFunction_New(member._slot, obj, nullptr);

}

} else if (member._type == PythonQtMemberInfo::Signal) {

// we return all signals, even the instance signals, since they are callable as unbound signals with self argument

return PythonQtSignalFunction_New(member._slot, obj, nullptr);

} else if (member._type == PythonQtMemberInfo::Property) {

PyObject* dummy = PythonQtClassWrapper_getDummyInstanceForProperty(wrapper, attributeName);

return dummy;

}

QByteArray pyget = "py_get_";

member = wrapper->classInfo()->member((pyget + attributeName).constData());

if (member._type == PythonQtMemberInfo::Slot) {

PyObject* dummy = PythonQtClassWrapper_getDummyInstanceForProperty(wrapper, attributeName);

return dummy;

}

}

// look for the internal methods (className(), help())

PyObject* internalMethod = PyObject_GenericGetAttr(obj, name);

if (internalMethod) {

return internalMethod;

}

QString error =

QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";

PyErr_SetString(PyExc_AttributeError, QStringToPythonConstCharPointer(error));

return nullptr;

}

static int PythonQtClassWrapper_setattro(PyObject* obj, PyObject* name, PyObject* value)

{

return PyType_Type.tp_setattro(obj, name, value);

}

PyTypeObject PythonQtClassWrapper_Type = {

PyVarObject_HEAD_INIT(nullptr, 0) /*tp_base*/

"PythonQt.PythonQtClassWrapper", /*tp_name*/

sizeof(PythonQtClassWrapper), /*tp_basicsize*/

0, /*tp_itemsize*/

nullptr, /*tp_dealloc*/

0, /*tp_vectorcall_offset*/

nullptr, /*tp_getattr*/

nullptr, /*tp_setattr*/

nullptr, /*tp_compare*/

nullptr, //PythonQtClassWrapper_repr, /*tp_repr*/

nullptr, /*tp_as_number*/

nullptr, /*tp_as_sequence*/

nullptr, /*tp_as_mapping*/

nullptr, /*tp_hash */

nullptr, /*tp_call*/

nullptr, /*tp_str*/

PythonQtClassWrapper_getattro, /*tp_getattro*/

PythonQtClassWrapper_setattro, /*tp_setattro*/

nullptr, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/

nullptr, /* tp_doc */

nullptr, /* tp_traverse */

nullptr, /* tp_clear */

nullptr, /* tp_richcompare */

0, /* tp_weaklistoffset */

nullptr, /* tp_iter */

nullptr, /* tp_iternext */

PythonQtClassWrapper_methods, /* tp_methods */

nullptr, /* tp_members */

nullptr, /* tp_getset */

nullptr, /* tp_base */

nullptr, /* tp_dict */

nullptr, /* tp_descr_get */

nullptr, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)PythonQtClassWrapper_init, /* tp_init */

PythonQtClassWrapper_alloc, /* tp_alloc */

nullptr, /* tp_new */

nullptr, /* tp_free */

};