/* * * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * Further, this software is distributed without any warranty that it is * free of the rightful claim of any third person regarding infringement * or the like. Any license provided herein, whether implied or * otherwise, applies only to this software file. Patent licenses, if * any, provided herein do not apply to combinations of this program with * other software, or any other product whatsoever. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29, * 28359 Bremen, Germany or: * * http://www.mevis.de * */ //---------------------------------------------------------------------------------- /*! // \file PythonQtInstanceWrapper.cpp // \author Florian Link // \author Last changed by $Author: florian $ // \date 2006-05 */ //---------------------------------------------------------------------------------- #include "PythonQtInstanceWrapper.h" #include #include "PythonQt.h" #include "PythonQtSlot.h" #include "PythonQtSignal.h" #include "PythonQtClassInfo.h" #include "PythonQtConversion.h" #include "PythonQtClassWrapper.h" PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo() { // take the class info from our type object return ((PythonQtClassWrapper*)Py_TYPE(this))->_classInfo; } static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) { // is this a C++ wrapper? if (self->_wrappedPtr) { //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1()); PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr); // we own our qobject, so we delete it now: delete self->_obj; self->_obj = NULL; if (force || self->_ownedByPythonQt) { int type = self->classInfo()->metaTypeId(); if (self->_useQMetaTypeDestroy && type>=0) { // use QMetaType to destroy the object QMetaType::destroy(type, self->_wrappedPtr); } else { PythonQtSlotInfo* slot = self->classInfo()->destructor(); if (slot) { void* args[2]; args[0] = NULL; args[1] = &self->_wrappedPtr; slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args); self->_wrappedPtr = NULL; } else { if (type>=0) { // use QMetaType to destroy the object QMetaType::destroy(type, self->_wrappedPtr); } else { // TODO: warn about not being able to destroy the object? } } } } } else { //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1()); if (self->_objPointerCopy) { PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy); } if (self->_obj) { if (force || self->_ownedByPythonQt) { if (force || !self->_obj->parent()) { delete self->_obj; } } else { if (self->_obj->parent()==NULL) { // tell someone who is interested that the qobject is no longer wrapped, if it has no parent PythonQt::qObjectNoLongerWrappedCB(self->_obj); } } } } self->_obj = NULL; } static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self) { PythonQtInstanceWrapper_deleteObject(self); self->_obj.~QPointer(); Py_TYPE(self)->tp_free((PyObject*)self); } static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/) { //PythonQtClassWrapper *classType = (PythonQtClassWrapper*)type; PythonQtInstanceWrapper *self; static PyObject* emptyTuple = NULL; if (emptyTuple==NULL) { emptyTuple = PyTuple_New(0); } self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL); if (self != NULL) { new (&self->_obj) QPointer(); self->_wrappedPtr = NULL; self->_ownedByPythonQt = false; self->_useQMetaTypeDestroy = false; self->_isShellInstance = false; } return (PyObject *)self; } int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds) { if (args == PythonQtPrivate::dummyTuple()) { // we are called from the internal PythonQt API, so our data will be filled later on... return 0; } // we are called from python, try to construct our object if (self->classInfo()->constructors()) { void* directCPPPointer = NULL; PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer); if (PyErr_Occurred()) { return -1; } if (directCPPPointer) { // change ownershipflag to be owned by PythonQt self->_ownedByPythonQt = true; self->_useQMetaTypeDestroy = false; if (self->classInfo()->isCPPWrapper()) { self->_wrappedPtr = directCPPPointer; // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?! } else { self->setQObject((QObject*)directCPPPointer); } // register with PythonQt PythonQt::priv()->addWrapperPointer(directCPPPointer, self); PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB(); if (cb) { // if we are a derived python class, we set the wrapper // to activate the shell class, otherwise we just ignore that it is a shell... // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class, // which is the case for all non-python derived types if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) { // set the wrapper and remember that we have a shell instance! (*cb)(directCPPPointer, self); self->_isShellInstance = true; } } } } else { QString error = QString("No constructors available for ") + self->classInfo()->className(); PyErr_SetString(PyExc_ValueError, error.toLatin1().data()); return -1; } return 0; } static PyObject *PythonQtInstanceWrapper_richcompare(PythonQtInstanceWrapper* wrapper, PyObject* other, int code) { bool validPtrs = false; bool areSamePtrs = false; if (PyObject_TypeCheck((PyObject*)wrapper, &PythonQtInstanceWrapper_Type)) { if (PyObject_TypeCheck(other, &PythonQtInstanceWrapper_Type)) { validPtrs = true; PythonQtInstanceWrapper* w1 = wrapper; PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)other; // check pointers directly if (w1->_wrappedPtr != NULL) { if (w1->_wrappedPtr == w2->_wrappedPtr) { areSamePtrs = true; } } else if (w1->_obj == w2->_obj) { areSamePtrs = true; } } else if (other == Py_None) { validPtrs = true; if (wrapper->_obj || wrapper->_wrappedPtr) { areSamePtrs = false; } else { areSamePtrs = true; } } } if ((wrapper->classInfo()->typeSlots() & PythonQt::Type_RichCompare) == 0) { // shortcut if richcompare is not supported: if (validPtrs && code == Py_EQ) { return PythonQtConv::GetPyBool(areSamePtrs); } else if (validPtrs && code == Py_NE) { return PythonQtConv::GetPyBool(!areSamePtrs); } Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } QByteArray memberName; switch (code) { case Py_LT: { static QByteArray name = "__lt__"; memberName = name; } break; case Py_LE: { static QByteArray name = "__le__"; memberName = name; } break; case Py_EQ: { static QByteArray name = "__eq__"; memberName = name; } break; case Py_NE: { static QByteArray name = "__ne__"; memberName = name; } break; case Py_GT: { static QByteArray name = "__gt__"; memberName = name; } break; case Py_GE: { static QByteArray name = "__ge__"; memberName = name; } break; } PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName); if (opSlot._type == PythonQtMemberInfo::Slot) { // TODO get rid of tuple PyObject* args = PyTuple_New(1); Py_INCREF(other); PyTuple_SET_ITEM(args, 0, other); PyObject* result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr); Py_DECREF(args); return result; } else { // not implemented, let python try something else! Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } } static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj) { #ifdef PY3K return PyUnicode_FromString(Py_TYPE(obj)->tp_name); #else return PyString_FromString(Py_TYPE(obj)->tp_name); #endif } PyObject *PythonQtInstanceWrapper_inherits(PythonQtInstanceWrapper* obj, PyObject *args) { char *name = NULL; if (!PyArg_ParseTuple(args, "s:PythonQtInstanceWrapper.inherits",&name)) { return NULL; } return PythonQtConv::GetPyBool(obj->classInfo()->inherits(name)); } static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj) { return PythonQt::self()->helpCalled(obj->classInfo()); } PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self) { PythonQtInstanceWrapper_deleteObject(self, true); Py_INCREF(Py_None); return Py_None; } static PyMethodDef PythonQtInstanceWrapper_methods[] = { {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS, "Return the classname of the object" }, {"inherits", (PyCFunction)PythonQtInstanceWrapper_inherits, METH_VARARGS, "Returns if the class inherits or is of given type name" }, {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS, "Shows the help of available methods for this class" }, {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS, "Deletes the C++ object (at your own risk, my friend!)" }, {NULL, NULL, 0, NULL} /* Sentinel */ }; static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name) { const char *attributeName; PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj; #ifdef PY3K if ((attributeName = PyUnicode_AsUTF8(name)) == NULL) { #else if ((attributeName = PyString_AsString(name)) == NULL) { #endif return NULL; } if (qstrcmp(attributeName, "__dict__")==0) { PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name); dict = PyDict_Copy(dict); if (wrapper->_obj) { // only the properties are missing, the rest is already available from // PythonQtClassWrapper... QStringList l = wrapper->classInfo()->propertyList(); Q_FOREACH (QString name, l) { PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data()); if (o) { PyDict_SetItemString(dict, name.toLatin1().data(), o); Py_DECREF(o); } else { std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data(); } } QList dynamicProps = wrapper->_obj->dynamicPropertyNames(); Q_FOREACH (QByteArray name, dynamicProps) { PyObject* o = PyObject_GetAttrString(obj, name.data()); if (o) { PyDict_SetItemString(dict, name.data(), o); Py_DECREF(o); } else { std::cerr << "PythonQtInstanceWrapper: dynamic property could not be read " << name.data(); } } } // Note: we do not put children into the dict, is would look confusing?! return dict; } // first look in super, to return derived methods from base object first PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name); if (superAttr) { return superAttr; } PyErr_Clear(); // mlabDebugConst("Python","get " << attributeName); PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName); switch (member._type) { case PythonQtMemberInfo::Property: if (wrapper->_obj) { if (member._property.userType() != QVariant::Invalid) { PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB(); if (profilingCB) { QString methodName = "getProperty("; methodName += attributeName; methodName += ")"; profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1()); } PyObject* value = PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj)); if (profilingCB) { profilingCB(PythonQt::Leave, NULL, NULL); } return value; } else { Py_INCREF(Py_None); return Py_None; } } else { QString error = QString("Trying to read property '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object"; PyErr_SetString(PyExc_ValueError, error.toLatin1().data()); return NULL; } break; case PythonQtMemberInfo::Slot: return PythonQtSlotFunction_New(member._slot, obj, NULL); break; case PythonQtMemberInfo::Signal: return PythonQtSignalFunction_New(member._slot, obj, NULL); break; case PythonQtMemberInfo::EnumValue: { PyObject* enumValue = member._enumValue; Py_INCREF(enumValue); return enumValue; } break; case PythonQtMemberInfo::EnumWrapper: { PyObject* enumWrapper = member._enumWrapper; Py_INCREF(enumWrapper); return enumWrapper; } break; case PythonQtMemberInfo::NotFound: { static const QByteArray getterString("py_get_"); // check for a getter slot PythonQtMemberInfo member = wrapper->classInfo()->member(getterString + attributeName); if (member._type == PythonQtMemberInfo::Slot) { return PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, member._slot, NULL, NULL, wrapper->_wrappedPtr); } // handle dynamic properties if (wrapper->_obj) { QVariant v = wrapper->_obj->property(attributeName); if (v.isValid()) { return PythonQtConv::QVariantToPyObject(v); } } } break; default: // is an invalid type, go on break; } // look for the internal methods (className(), help()) #ifdef PY3K PyObject* internalMethod = PyObject_GenericGetAttr(obj, name); #else PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName); #endif if (internalMethod) { return internalMethod; } PyErr_Clear(); if (wrapper->_obj) { // look for a child QObjectList children = wrapper->_obj->children(); for (int i = 0; i < children.count(); i++) { QObject *child = children.at(i); if (child->objectName() == attributeName) { return PythonQt::priv()->wrapQObject(child); } } } QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'"; PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); return NULL; } static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value) { QString error; const char *attributeName; PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj; #ifdef PY3K if ((attributeName = PyUnicode_AsUTF8(name)) == NULL) #else if ((attributeName = PyString_AsString(name)) == NULL) #endif return -1; PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName); if (member._type == PythonQtMemberInfo::Property) { if (!wrapper->_obj) { error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object"; PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); return -1; } QMetaProperty prop = member._property; if (prop.isWritable()) { QVariant v; if (prop.isEnumType()) { // this will give us either a string or an int, everything else will probably be an error v = PythonQtConv::PyObjToQVariant(value); } else { int t = prop.userType(); v = PythonQtConv::PyObjToQVariant(value, t); } bool success = false; if (v.isValid()) { PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB(); if (profilingCB) { QString methodName = "setProperty("; methodName += attributeName; methodName += ")"; profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1()); } success = prop.write(wrapper->_obj, v); if (profilingCB) { profilingCB(PythonQt::Leave, NULL, NULL); } } if (success) { return 0; } else { error = QString("Property '") + attributeName + "' of type '" + prop.typeName() + "' does not accept an object of type " + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")"; } } else { error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable"; } } else if (member._type == PythonQtMemberInfo::Slot) { error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object"; } else if (member._type == PythonQtMemberInfo::Signal) { error = QString("Signal '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object"; } else if (member._type == PythonQtMemberInfo::EnumValue) { error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object"; } else if (member._type == PythonQtMemberInfo::EnumWrapper) { error = QString("Enum '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object"; } else if (member._type == PythonQtMemberInfo::NotFound) { // check for a setter slot static const QByteArray setterString("py_set_"); PythonQtMemberInfo setter = wrapper->classInfo()->member(setterString + attributeName); if (setter._type == PythonQtMemberInfo::Slot) { // call the setter and ignore the result value void* result; PyObject* args = PyTuple_New(1); Py_INCREF(value); PyTuple_SET_ITEM(args, 0, value); PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, setter._slot, args, NULL, wrapper->_wrappedPtr, &result); Py_DECREF(args); return 0; } // handle dynamic properties if (wrapper->_obj) { QVariant prop = wrapper->_obj->property(attributeName); if (prop.isValid()) { QVariant v = PythonQtConv::PyObjToQVariant(value); if (v.isValid()) { wrapper->_obj->setProperty(attributeName, v); return 0; } else { error = QString("Dynamic property '") + attributeName + "' does not accept an object of type " + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")"; PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); return -1; } } } // if we are a derived python class, we allow setting attributes. // if we are a direct CPP wrapper, we do NOT allow it, since // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore // and when it is recreated from a CPP pointer the attributes are gone... if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) { return PyBaseObject_Type.tp_setattro(obj,name,value); } else { error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed"; } } PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); return -1; } static QString getStringFromObject(PythonQtInstanceWrapper* wrapper) { QString result; if (wrapper->_wrappedPtr) { // first try some manually string conversions for some variants int metaid = wrapper->classInfo()->metaTypeId(); result = PythonQtConv::CPPObjectToString(metaid, wrapper->_wrappedPtr); if (!result.isEmpty()) { return result; } } if (wrapper->_wrappedPtr || wrapper->_obj) { // next, try to call py_toString PythonQtMemberInfo info = wrapper->classInfo()->member("py_toString"); if (info._type == PythonQtMemberInfo::Slot) { PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, info._slot, NULL, NULL, wrapper->_wrappedPtr); if (resultObj) { // TODO this is one conversion too much, would be nicer to call the slot directly... result = PythonQtConv::PyObjGetString(resultObj); Py_DECREF(resultObj); } } } return result; } static PyObject * PythonQtInstanceWrapper_str(PyObject * obj) { PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; // QByteArray should be directly returned as a str if (wrapper->classInfo()->metaTypeId()==QVariant::ByteArray) { QByteArray* b = (QByteArray*) wrapper->_wrappedPtr; if (b->data()) { #ifdef PY3K return PyUnicode_FromStringAndSize(b->data(), b->size()); #else return PyString_FromStringAndSize(b->data(), b->size()); #endif } else { #ifdef PY3K return PyUnicode_New(0, 0); #else return PyString_FromString(""); #endif } } const char* typeName = obj->ob_type->tp_name; QObject *qobj = wrapper->_obj; QString str = getStringFromObject(wrapper); if (!str.isEmpty()) { #ifdef PY3K return PyUnicode_FromFormat("%s", str.toLatin1().constData()); #else return PyString_FromFormat("%s", str.toLatin1().constData()); #endif } if (wrapper->_wrappedPtr) { if (wrapper->_obj) { #ifdef PY3K return PyUnicode_FromFormat("<%s C++ Object at %p wrapped by %s at %p>", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); #else return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); #endif } else { #ifdef PY3K return PyUnicode_FromFormat("<%s C++ Object at %p>", typeName, wrapper->_wrappedPtr); #else return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr); #endif } } else { #ifdef PY3K return PyUnicode_FromFormat("<%s QObject at %p>", typeName, qobj); #else return PyString_FromFormat("%s (QObject %p)", typeName, qobj); #endif } } static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj) { PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; const char* typeName = obj->ob_type->tp_name; QObject *qobj = wrapper->_obj; QString str = getStringFromObject(wrapper); if (!str.isEmpty()) { if (str.startsWith(typeName)) { #ifdef PY3K return PyUnicode_FromFormat("%s", str.toLatin1().constData()); #else return PyString_FromFormat("%s", str.toLatin1().constData()); #endif } else { #ifdef PY3K return PyUnicode_FromFormat("<%s %s at %p>", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj); #else return PyString_FromFormat("%s (%s, at: %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj); #endif } } if (wrapper->_wrappedPtr) { if (wrapper->_obj) { #ifdef PY3K return PyUnicode_FromFormat("<%s C++ object at %p wrapped by %s at %p>", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); #else return PyString_FromFormat("%s (C++ object at: %p wrapped by %s at: %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); #endif } else { #ifdef PY3K return PyUnicode_FromFormat("<%s C++ object at %p>", typeName, wrapper->_wrappedPtr); #else return PyString_FromFormat("%s (C++ object at: %p)", typeName, wrapper->_wrappedPtr); #endif } } else { #ifdef PY3K return PyUnicode_FromFormat("<%s %s at %p>", typeName, wrapper->classInfo()->className(), qobj); #else return PyString_FromFormat("%s (%s at: %p)", typeName, wrapper->classInfo()->className(), qobj); #endif } } static int PythonQtInstanceWrapper_builtin_nonzero(PyObject *obj) { PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1; } static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj) { if (obj->_wrappedPtr != NULL) { return reinterpret_cast(obj->_wrappedPtr); } else { QObject* qobj = obj->_obj; // get pointer from QPointer wrapper return reinterpret_cast(qobj); } } // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr static PyNumberMethods PythonQtInstanceWrapper_as_number = { 0, /* nb_add */ 0, /* nb_subtract */ 0, /* nb_multiply */ #ifndef PY3K 0, /* nb_divide */ #endif 0, /* nb_remainder */ 0, /* nb_divmod */ 0, /* nb_power */ 0, /* nb_negative */ 0, /* nb_positive */ 0, /* nb_absolute */ PythonQtInstanceWrapper_builtin_nonzero, /* nb_nonzero / nb_bool in Py3K */ 0, /* nb_invert */ 0, /* nb_lshift */ 0, /* nb_rshift */ 0, /* nb_and */ 0, /* nb_xor */ 0, /* nb_or */ #ifndef PY3K 0, /* nb_coerce */ #endif 0, /* nb_int */ 0, /* nb_long / nb_reserved in Py3K */ 0, /* nb_float */ #ifndef PY3K 0, /* nb_oct */ 0, /* nb_hex */ #endif 0, /* nb_inplace_add */ 0, /* nb_inplace_subtract */ 0, /* nb_inplace_multiply */ #ifndef PY3K 0, /* nb_inplace_divide */ #endif 0, /* nb_inplace_remainder */ 0, /* nb_inplace_power */ 0, /* nb_inplace_lshift */ 0, /* nb_inplace_rshift */ 0, /* nb_inplace_and */ 0, /* nb_inplace_xor */ 0, /* nb_inplace_or */ 0, /* nb_floor_divide */ 0, /* nb_true_divide */ 0, /* nb_inplace_floor_divide */ 0, /* nb_inplace_true_divide */ #ifdef PY3K 0, /* nb_index in Py3K */ #endif }; PyTypeObject PythonQtInstanceWrapper_Type = { PyVarObject_HEAD_INIT(&PythonQtClassWrapper_Type, 0) "PythonQt.PythonQtInstanceWrapper", /*tp_name*/ sizeof(PythonQtInstanceWrapper), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ PythonQtInstanceWrapper_repr, /*tp_repr*/ &PythonQtInstanceWrapper_as_number, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ (hashfunc)PythonQtInstanceWrapper_hash, /*tp_hash */ 0, /*tp_call*/ PythonQtInstanceWrapper_str, /*tp_str*/ PythonQtInstanceWrapper_getattro, /*tp_getattro*/ PythonQtInstanceWrapper_setattro, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE /*| Py_TPFLAGS_CHECKTYPES FIXME Py_TPFLAGS_CHECKTYPES removal */, /*tp_flags*/ "PythonQtInstanceWrapper object", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc)PythonQtInstanceWrapper_richcompare, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ PythonQtInstanceWrapper_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc)PythonQtInstanceWrapper_init, /* tp_init */ 0, /* tp_alloc */ PythonQtInstanceWrapper_new, /* tp_new */ }; //-------------------------------------------------------