PythonQtInstanceWrapper.cpp
844 lines
| 28.8 KiB
| text/x-c
|
CppLexer
/ src / PythonQtInstanceWrapper.cpp
r0 | /* | |||
* | ||||
* 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 <QObject> | ||||
#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<QObject>(); | ||||
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<QObject>(); | ||||
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<QByteArray> 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<long>(obj->_wrappedPtr); | ||||
} else { | ||||
QObject* qobj = obj->_obj; // get pointer from QPointer wrapper | ||||
return reinterpret_cast<long>(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 */ | ||||
}; | ||||
//------------------------------------------------------- | ||||