PythonQtInstanceWrapper.cpp
572 lines
| 20.9 KiB
| text/x-c
|
CppLexer
/ src / PythonQtInstanceWrapper.cpp
ezust
|
r0 | /* | ||
| * | ||||
| * Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29, | ||||
| * 28359 Bremen, Germany or: | ||||
| * | ||||
| * http://www.mevis.de | ||||
| * | ||||
| */ | ||||
| //---------------------------------------------------------------------------------- | ||||
| /*! | ||||
florianlink
|
r16 | // \file PythonQtInstanceWrapper.cpp | ||
|
ezust
|
r0 | // \author Florian Link | ||
| // \author Last changed by $Author: florian $ | ||||
| // \date 2006-05 | ||||
| */ | ||||
| //---------------------------------------------------------------------------------- | ||||
|
florianlink
|
r16 | #include "PythonQtInstanceWrapper.h" | ||
|
ezust
|
r0 | #include <QObject> | ||
| #include "PythonQt.h" | ||||
| #include "PythonQtSlot.h" | ||||
| #include "PythonQtClassInfo.h" | ||||
| #include "PythonQtConversion.h" | ||||
|
florianlink
|
r18 | #include "PythonQtClassWrapper.h" | ||
|
florianlink
|
r21 | PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo() | ||
|
florianlink
|
r18 | { | ||
| // take the class info from our type object | ||||
| return ((PythonQtClassWrapper*)ob_type)->_classInfo; | ||||
| } | ||||
|
ezust
|
r0 | |||
|
florianlink
|
r16 | static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) { | ||
|
florianlink
|
r15 | |||
| // is this a C++ wrapper? | ||||
|
ezust
|
r0 | if (self->_wrappedPtr) { | ||
|
florianlink
|
r18 | //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1()); | ||
|
florianlink
|
r10 | |||
|
ezust
|
r0 | PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr); | ||
| // we own our qobject, so we delete it now: | ||||
| delete self->_obj; | ||||
| self->_obj = NULL; | ||||
|
florianlink
|
r18 | if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) { | ||
| int type = self->classInfo()->metaTypeId(); | ||||
|
florianlink
|
r10 | if (self->_useQMetaTypeDestroy && type>=0) { | ||
| // use QMetaType to destroy the object | ||||
| QMetaType::destroy(type, self->_wrappedPtr); | ||||
|
ezust
|
r0 | } else { | ||
|
florianlink
|
r24 | PythonQtSlotInfo* slot = self->classInfo()->destructor(); | ||
|
florianlink
|
r10 | 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? | ||||
| } | ||||
| } | ||||
|
ezust
|
r0 | } | ||
| } | ||||
|
florianlink
|
r4 | } else { | ||
|
florianlink
|
r18 | //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1()); | ||
|
florianlink
|
r4 | if (self->_objPointerCopy) { | ||
| PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy); | ||||
| } | ||||
| if (self->_obj) { | ||||
|
florianlink
|
r15 | if (force || self->_ownedByPythonQt) { | ||
| if (force || !self->_obj->parent()) { | ||||
|
florianlink
|
r4 | 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); | ||||
| } | ||||
|
ezust
|
r0 | } | ||
| } | ||||
| } | ||||
|
florianlink
|
r4 | self->_obj = NULL; | ||
|
florianlink
|
r10 | } | ||
|
florianlink
|
r16 | static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self) | ||
|
florianlink
|
r10 | { | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper_deleteObject(self); | ||
|
florianlink
|
r4 | self->_obj.~QPointer<QObject>(); | ||
|
ezust
|
r0 | self->ob_type->tp_free((PyObject*)self); | ||
| } | ||||
|
florianlink
|
r18 | static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * args, PyObject * /*kwds*/) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r24 | //PythonQtClassWrapper *classType = (PythonQtClassWrapper*)type; | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper *self; | ||
|
florianlink
|
r18 | static PyObject* emptyTuple = NULL; | ||
| if (emptyTuple==NULL) { | ||||
| emptyTuple = PyTuple_New(0); | ||||
| } | ||||
| self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL); | ||||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | if (self != NULL) { | ||
|
florianlink
|
r4 | new (&self->_obj) QPointer<QObject>(); | ||
|
ezust
|
r0 | self->_wrappedPtr = NULL; | ||
| self->_ownedByPythonQt = false; | ||||
|
florianlink
|
r10 | self->_useQMetaTypeDestroy = false; | ||
|
florianlink
|
r24 | self->_isShellInstance = false; | ||
|
ezust
|
r0 | } | ||
| return (PyObject *)self; | ||||
| } | ||||
|
florianlink
|
r22 | int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r18 | 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; | ||||
|
florianlink
|
r41 | PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer); | ||
|
florianlink
|
r18 | 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); | ||||
|
florianlink
|
r24 | |||
| 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; | ||||
| } | ||||
| } | ||||
|
florianlink
|
r18 | } | ||
| } else { | ||||
| QString error = QString("No constructors available for ") + self->classInfo()->className(); | ||||
| PyErr_SetString(PyExc_ValueError, error.toLatin1().data()); | ||||
| return -1; | ||||
| } | ||||
|
ezust
|
r0 | return 0; | ||
| } | ||||
|
florianlink
|
r30 | static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r30 | return PyString_FromString(obj->ob_type->tp_name); | ||
|
ezust
|
r0 | } | ||
|
florianlink
|
r30 | static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r30 | return PythonQt::self()->helpCalled(obj->classInfo()); | ||
|
ezust
|
r0 | } | ||
|
florianlink
|
r16 | static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self) | ||
|
florianlink
|
r10 | { | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper_deleteObject(self, true); | ||
|
florianlink
|
r10 | Py_INCREF(Py_None); | ||
| return Py_None; | ||||
| } | ||||
|
ezust
|
r0 | |||
|
florianlink
|
r16 | static PyMethodDef PythonQtInstanceWrapper_methods[] = { | ||
| {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS, | ||||
|
ezust
|
r0 | "Return the classname of the object" | ||
| }, | ||||
|
florianlink
|
r16 | {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS, | ||
|
ezust
|
r0 | "Shows the help of available methods for this class" | ||
| }, | ||||
|
florianlink
|
r16 | {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS, | ||
|
florianlink
|
r10 | "Deletes the C++ object (at your own risk, my friend!)" | ||
| }, | ||||
| {NULL, NULL, 0, NULL} /* Sentinel */ | ||||
|
ezust
|
r0 | }; | ||
|
florianlink
|
r16 | static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name) | ||
|
ezust
|
r0 | { | ||
| const char *attributeName; | ||||
|
florianlink
|
r16 | PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj; | ||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | if ((attributeName = PyString_AsString(name)) == NULL) { | ||
| return NULL; | ||||
| } | ||||
|
florianlink
|
r4 | |||
|
florianlink
|
r24 | if (qstrcmp(attributeName, "__dict__")==0) { | ||
|
florianlink
|
r34 | PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name); | ||
| dict = PyDict_Copy(dict); | ||||
| // only the properties are missing, the rest is already available from | ||||
| // PythonQtClassWrapper... | ||||
| QStringList l = wrapper->classInfo()->propertyList(); | ||||
|
florianlink
|
r24 | foreach (QString name, l) { | ||
| PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data()); | ||||
|
florianlink
|
r34 | 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(); | ||||
| } | ||||
|
florianlink
|
r24 | } | ||
| // 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; | ||||
| } | ||||
|
florianlink
|
r27 | PyErr_Clear(); | ||
|
florianlink
|
r24 | |||
|
florianlink
|
r16 | if (!wrapper->_obj && !wrapper->_wrappedPtr) { | ||
|
florianlink
|
r18 | QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object"; | ||
|
ezust
|
r0 | PyErr_SetString(PyExc_ValueError, error.toLatin1().data()); | ||
| return NULL; | ||||
| } | ||||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | // mlabDebugConst("Python","get " << attributeName); | ||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | // TODO: dynamic properties are missing | ||
|
florianlink
|
r4 | |||
|
florianlink
|
r18 | PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName); | ||
|
ezust
|
r0 | switch (member._type) { | ||
| case PythonQtMemberInfo::Property: | ||||
|
florianlink
|
r16 | if (wrapper->_obj) { | ||
|
florianlink
|
r27 | if (member._property.userType() != QVariant::Invalid) { | ||
| return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj)); | ||||
| } else { | ||||
| Py_INCREF(Py_None); | ||||
| return Py_None; | ||||
| } | ||||
|
ezust
|
r0 | } | ||
| break; | ||||
| case PythonQtMemberInfo::Slot: | ||||
| return PythonQtSlotFunction_New(member._slot, obj, NULL); | ||||
| break; | ||||
| case PythonQtMemberInfo::EnumValue: | ||||
| return PyInt_FromLong(member._enumValue); | ||||
| break; | ||||
|
florianlink
|
r8 | default: | ||
| // is an invalid type, go on | ||||
| break; | ||||
|
ezust
|
r0 | } | ||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | // look for the interal methods (className(), help()) | ||
|
florianlink
|
r16 | PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName); | ||
|
ezust
|
r0 | if (internalMethod) { | ||
| return internalMethod; | ||||
| } | ||||
| PyErr_Clear(); | ||||
|
florianlink
|
r22 | 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::self()->priv()->wrapQObject(child); | ||||
| } | ||||
| } | ||||
| } | ||||
|
florianlink
|
r4 | |||
|
florianlink
|
r18 | QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'"; | ||
|
ezust
|
r0 | PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); | ||
| return NULL; | ||||
| } | ||||
|
florianlink
|
r16 | static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value) | ||
|
ezust
|
r0 | { | ||
| QString error; | ||||
| char *attributeName; | ||||
|
florianlink
|
r16 | PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj; | ||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | if ((attributeName = PyString_AsString(name)) == NULL) | ||
| return -1; | ||||
|
florianlink
|
r4 | |||
|
florianlink
|
r18 | PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName); | ||
|
ezust
|
r0 | if (member._type == PythonQtMemberInfo::Property) { | ||
|
florianlink
|
r48 | |||
| 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; | ||||
| } | ||||
|
ezust
|
r0 | 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()) { | ||||
|
florianlink
|
r16 | success = prop.write(wrapper->_obj, v); | ||
|
ezust
|
r0 | } | ||
| 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 { | ||||
|
florianlink
|
r30 | error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable"; | ||
|
ezust
|
r0 | } | ||
|
florianlink
|
r30 | } 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::EnumValue) { | ||||
| error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object"; | ||||
| } else if (member._type == PythonQtMemberInfo::NotFound) { | ||||
| // 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"; | ||||
|
ezust
|
r0 | } | ||
| } | ||||
|
florianlink
|
r4 | |||
|
ezust
|
r0 | PyErr_SetString(PyExc_AttributeError, error.toLatin1().data()); | ||
| return -1; | ||||
| } | ||||
|
florianlink
|
r16 | static PyObject * PythonQtInstanceWrapper_str(PyObject * obj) | ||
|
florianlink
|
r10 | { | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; | ||
|
florianlink
|
r22 | const char* typeName = obj->ob_type->tp_name; | ||
|
florianlink
|
r16 | QObject *qobj = wrapper->_obj; | ||
| if (wrapper->_wrappedPtr) { | ||||
|
florianlink
|
r18 | QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr); | ||
|
florianlink
|
r10 | if (!str.isEmpty()) { | ||
| return PyString_FromFormat("%s", str.toLatin1().constData()); | ||||
| } else | ||||
|
florianlink
|
r16 | if (wrapper->_obj) { | ||
|
florianlink
|
r22 | return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); | ||
|
florianlink
|
r10 | } else { | ||
|
florianlink
|
r22 | return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr); | ||
|
florianlink
|
r10 | } | ||
| } else { | ||||
|
florianlink
|
r22 | return PyString_FromFormat("%s (QObject %p)", typeName, qobj); | ||
|
florianlink
|
r10 | } | ||
| } | ||||
|
florianlink
|
r16 | static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; | ||
|
florianlink
|
r22 | const char* typeName = obj->ob_type->tp_name; | ||
|
florianlink
|
r16 | QObject *qobj = wrapper->_obj; | ||
| if (wrapper->_wrappedPtr) { | ||||
|
florianlink
|
r18 | QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr); | ||
|
florianlink
|
r10 | if (!str.isEmpty()) { | ||
|
florianlink
|
r22 | return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr); | ||
|
florianlink
|
r10 | } else | ||
|
florianlink
|
r16 | if (wrapper->_obj) { | ||
|
florianlink
|
r22 | return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj); | ||
|
ezust
|
r0 | } else { | ||
|
florianlink
|
r22 | return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr); | ||
|
ezust
|
r0 | } | ||
| } else { | ||||
|
florianlink
|
r30 | return PyString_FromFormat("%s (QObject %p)", typeName, wrapper->classInfo()->className(), qobj); | ||
|
ezust
|
r0 | } | ||
| } | ||||
|
florianlink
|
r16 | static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r18 | if (PyObject_TypeCheck(obj1, &PythonQtInstanceWrapper_Type) && | ||
| PyObject_TypeCheck(obj2, &PythonQtInstanceWrapper_Type)) { | ||||
|
florianlink
|
r4 | |||
|
florianlink
|
r16 | PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1; | ||
| PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2; | ||||
|
florianlink
|
r10 | // check pointers directly first: | ||
|
ezust
|
r0 | if (w1->_wrappedPtr != NULL) { | ||
|
florianlink
|
r10 | if (w1->_wrappedPtr == w2->_wrappedPtr) { | ||
|
ezust
|
r0 | return 0; | ||
| } | ||||
| } else if (w1->_obj == w2->_obj) { | ||||
| return 0; | ||||
| } | ||||
|
florianlink
|
r18 | const char* class1 = w1->classInfo()->className(); | ||
| const char* class2 = w2->classInfo()->className(); | ||||
|
florianlink
|
r10 | if (strcmp(class1, class2) == 0) { | ||
| // same class names, so we can try the operator_equal | ||||
|
florianlink
|
r18 | PythonQtMemberInfo info = w1->classInfo()->member("operator_equal"); | ||
|
florianlink
|
r10 | if (info._type == PythonQtMemberInfo::Slot) { | ||
| bool result = false; | ||||
| void* obj1 = w1->_wrappedPtr; | ||||
| if (!obj1) { | ||||
| obj1 = w1->_obj; | ||||
| } | ||||
| if (!obj1) { return -1; } | ||||
| void* obj2 = w2->_wrappedPtr; | ||||
| if (!obj2) { | ||||
| obj2 = w2->_obj; | ||||
| } | ||||
| if (!obj2) { return -1; } | ||||
| if (info._slot->isInstanceDecorator()) { | ||||
| // call on decorator QObject | ||||
| void* args[3]; | ||||
| args[0] = &result; | ||||
| args[1] = &obj1; // this is a pointer, so it needs a pointer to a pointer | ||||
| args[2] = obj2; // this is a reference, so it needs the direct pointer | ||||
| info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args); | ||||
| return result?0:-1; | ||||
| } else { | ||||
| // call directly on QObject | ||||
| if (w1->_obj && w2->_obj) { | ||||
| void* args[2]; | ||||
| args[0] = &result; | ||||
| args[2] = obj2; // this is a reference, so it needs the direct pointer | ||||
| w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args); | ||||
| } | ||||
| } | ||||
| } | ||||
| } | ||||
|
ezust
|
r0 | } | ||
|
florianlink
|
r10 | return -1; | ||
|
ezust
|
r0 | } | ||
|
florianlink
|
r16 | static int PythonQtInstanceWrapper_nonzero(PyObject *obj) | ||
|
ezust
|
r0 | { | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj; | ||
| return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1; | ||||
|
ezust
|
r0 | } | ||
|
florianlink
|
r4 | |||
|
florianlink
|
r16 | static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj) | ||
|
florianlink
|
r4 | { | ||
| if (obj->_wrappedPtr != NULL) { | ||||
| return reinterpret_cast<long>(obj->_wrappedPtr); | ||||
| } else { | ||||
| QObject* qobj = obj->_obj; // get pointer from QPointer wrapper | ||||
| return reinterpret_cast<long>(qobj); | ||||
| } | ||||
| } | ||||
|
ezust
|
r0 | // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr | ||
|
florianlink
|
r16 | static PyNumberMethods PythonQtInstanceWrapper_as_number = { | ||
|
ezust
|
r0 | 0, /* nb_add */ | ||
| 0, /* nb_subtract */ | ||||
| 0, /* nb_multiply */ | ||||
| 0, /* nb_divide */ | ||||
| 0, /* nb_remainder */ | ||||
| 0, /* nb_divmod */ | ||||
| 0, /* nb_power */ | ||||
| 0, /* nb_negative */ | ||||
| 0, /* nb_positive */ | ||||
| 0, /* nb_absolute */ | ||||
|
florianlink
|
r16 | PythonQtInstanceWrapper_nonzero, /* nb_nonzero */ | ||
|
ezust
|
r0 | 0, /* nb_invert */ | ||
| 0, /* nb_lshift */ | ||||
| 0, /* nb_rshift */ | ||||
| 0, /* nb_and */ | ||||
| 0, /* nb_xor */ | ||||
| 0, /* nb_or */ | ||||
| 0, /* nb_coerce */ | ||||
| 0, /* nb_int */ | ||||
| 0, /* nb_long */ | ||||
| 0, /* nb_float */ | ||||
| 0, /* nb_oct */ | ||||
| 0, /* nb_hex */ | ||||
| 0, /* nb_inplace_add */ | ||||
| 0, /* nb_inplace_subtract */ | ||||
| 0, /* nb_inplace_multiply */ | ||||
| 0, /* nb_inplace_divide */ | ||||
| 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 */ | ||||
| }; | ||||
|
florianlink
|
r16 | PyTypeObject PythonQtInstanceWrapper_Type = { | ||
|
florianlink
|
r18 | PyObject_HEAD_INIT(&PythonQtClassWrapper_Type) | ||
|
ezust
|
r0 | 0, /*ob_size*/ | ||
|
florianlink
|
r16 | "PythonQt.PythonQtInstanceWrapper", /*tp_name*/ | ||
| sizeof(PythonQtInstanceWrapper), /*tp_basicsize*/ | ||||
|
ezust
|
r0 | 0, /*tp_itemsize*/ | ||
|
florianlink
|
r16 | (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/ | ||
|
ezust
|
r0 | 0, /*tp_print*/ | ||
| 0, /*tp_getattr*/ | ||||
| 0, /*tp_setattr*/ | ||||
|
florianlink
|
r16 | PythonQtInstanceWrapper_compare, /*tp_compare*/ | ||
| PythonQtInstanceWrapper_repr, /*tp_repr*/ | ||||
| &PythonQtInstanceWrapper_as_number, /*tp_as_number*/ | ||||
|
ezust
|
r0 | 0, /*tp_as_sequence*/ | ||
| 0, /*tp_as_mapping*/ | ||||
|
florianlink
|
r16 | (hashfunc)PythonQtInstanceWrapper_hash, /*tp_hash */ | ||
|
ezust
|
r0 | 0, /*tp_call*/ | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper_str, /*tp_str*/ | ||
| PythonQtInstanceWrapper_getattro, /*tp_getattro*/ | ||||
| PythonQtInstanceWrapper_setattro, /*tp_setattro*/ | ||||
|
ezust
|
r0 | 0, /*tp_as_buffer*/ | ||
| Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ | ||||
|
florianlink
|
r16 | "PythonQtInstanceWrapper object", /* tp_doc */ | ||
|
ezust
|
r0 | 0, /* tp_traverse */ | ||
| 0, /* tp_clear */ | ||||
| 0, /* tp_richcompare */ | ||||
| 0, /* tp_weaklistoffset */ | ||||
| 0, /* tp_iter */ | ||||
| 0, /* tp_iternext */ | ||||
| 0, /* 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 */ | ||||
|
florianlink
|
r16 | (initproc)PythonQtInstanceWrapper_init, /* tp_init */ | ||
|
ezust
|
r0 | 0, /* tp_alloc */ | ||
|
florianlink
|
r16 | PythonQtInstanceWrapper_new, /* tp_new */ | ||
|
ezust
|
r0 | }; | ||
| //------------------------------------------------------- | ||||