#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 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 PyString_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_INCREF(Py_None);

return Py_None;

}

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

{

const char *attributeName;

PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;

if ((attributeName = PyString_AsString(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();

const QStringList lMembers = wrapper->classInfo()->memberList();

const QStringList lProperties = wrapper->classInfo()->propertyList();

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

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

Q_FOREACH (QString name, completeSet) {

}

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

PyObject* initName = PyString_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())

#ifdef PY3K

PyObject* internalMethod = PyObject_GenericGetAttr(obj, name);

#else

PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);

#endif

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)

"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 */

#ifdef PY3K

PythonQtClassWrapper_methods, /* tp_methods */

#else

nullptr, /* tp_methods */

#endif

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 */

};