GIT_REPOSITORIES/LPP/PythonQt Commit - r113:ab319fdfc38d

added initial support for public member variable access via getters/setters...

florianlink -

r113:ab319fdfc38d

parent child

Context file:

r113:ab319fdfc38d

Collapse all files

src/PythonQtInstanceWrapper.cpp +27 -6

             /*
             *
             *  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
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \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 "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             #include "PythonQtClassWrapper.h"
             PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
             {
               // take the class info from our type object
               return ((PythonQtClassWrapper*)ob_type)->_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->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || 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>();
               self->ob_type->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_classname(PythonQtInstanceWrapper* obj)
             {
               return PyString_FromString(obj->ob_type->tp_name);
             }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
             {
               return PythonQt::self()->helpCalled(obj->classInfo());
             }
             static 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"
                 },
                 {"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;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 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();
                   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();
                   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) {
                     return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                   } 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::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:
-                // handle dynamic properties
-                if (wrapper->_obj) {
+                  // check for a getter_
-                  QVariant v = wrapper->_obj->property(attributeName);
+                  PythonQtMemberInfo member = wrapper->classInfo()->member(QByteArray("getter_") + attributeName);
-                  if (v.isValid()) {
+                  if (member._type == PythonQtMemberInfo::Slot) {
-                    return PythonQtConv::QVariantToPyObject(v);
+                    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())
               PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
               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;
-              char *attributeName;
+              const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 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()) {
                     success = prop.write(wrapper->_obj, v);
                   }
                   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::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_
+                PythonQtMemberInfo setter = wrapper->classInfo()->member(QByteArray("setter_") + 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 PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
               if (wrapper->_wrappedPtr) {
                 QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
               }
             }
             static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
               if (wrapper->_wrappedPtr) {
                 QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
                 } else
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
               }
             }
             static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (PyObject_TypeCheck(obj1, &PythonQtInstanceWrapper_Type) &&
                 PyObject_TypeCheck(obj2, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
                 PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
                 // check pointers directly first:
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w2->_wrappedPtr) {
                     return 0;
                   }
                 } else if (w1->_obj == w2->_obj) {
                   return 0;
                 }
                 const char* class1 = w1->classInfo()->className();
                 const char* class2 = w2->classInfo()->className();
                 if (strcmp(class1, class2) == 0) {
                   // same class names, so we can try the operator_equal
                   PythonQtMemberInfo info = w1->classInfo()->member("operator_equal");
                   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[1] = obj2;  // this is a reference, so it needs the direct pointer
                         w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       }
                     }
                   }
                 }
               }
               return -1;
             }
             static int PythonQtInstanceWrapper_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 = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_divide */
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
                 PythonQtInstanceWrapper_nonzero,      /* nb_nonzero */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,    /* nb_and */
 ,    /* nb_xor */
 ,    /* nb_or */
 ,      /* nb_coerce */
 ,      /* nb_int */
 ,      /* nb_long */
 ,      /* nb_float */
 ,      /* nb_oct */
 ,      /* nb_hex */
 ,      /* nb_inplace_add */
 ,      /* nb_inplace_subtract */
 ,      /* nb_inplace_multiply */
 ,      /* nb_inplace_divide */
 ,      /* nb_inplace_remainder */
 ,      /* nb_inplace_power */
 ,      /* nb_inplace_lshift */
 ,      /* nb_inplace_rshift */
 ,      /* nb_inplace_and */
 ,      /* nb_inplace_xor */
 ,      /* nb_inplace_or */
 ,      /* nb_floor_divide */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
             };
             PyTypeObject PythonQtInstanceWrapper_Type = {
                 PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
                 sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtInstanceWrapper_compare,         /*tp_compare*/
                 PythonQtInstanceWrapper_repr,            /*tp_repr*/
                 &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtInstanceWrapper_str,      /*tp_str*/
                 PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
                 PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
 ,             /* tp_methods */
 ,             /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtInstanceWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtSlot.cpp +1 -1

             /*
             *
             *  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
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtSlot.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMisc.h"
             #include "PythonQtConversion.h"
             #include <iostream>
             #define PYTHONQT_MAX_ARGS 32
             bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
             {
               static unsigned int recursiveEntry = 0;
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               // store the current storage position, so that we can get back to this state after a slot is called
               // (do this locally, so that we have all positions on the stack
               PythonQtValueStoragePosition globalValueStoragePos;
               PythonQtValueStoragePosition globalPtrStoragePos;
               PythonQtValueStoragePosition globalVariantStoragePos;
               PythonQtConv::global_valueStorage.getPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.getPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.getPos(globalVariantStoragePos);
               recursiveEntry++;
               // the arguments that are passed to qt_metacall
               void* argList[PYTHONQT_MAX_ARGS];
               PyObject* result = NULL;
               int argc = info->parameterCount();
               const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
               const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
               // set return argument to NULL
               argList[0] = NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator()) {
                 skipFirst = true;
                 // for decorators on CPP objects, we take the cpp ptr, for QObjects we take the QObject pointer
                 void* arg1 = firstArgument;
                 if (!arg1) {
                   arg1 = objectToCall;
                 }
                 if (arg1) {
                   // upcast to correct parent class
                   arg1 = ((char*)arg1)+info->upcastingOffset();
                 }
                 argList[1] = &arg1;
                 if (ok) {
                   for (int i = 2; i<argc && ok; i++) {
                     const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                     //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
                     argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, classInfo);
                     if (argList[i]==NULL) {
                       ok = false;
                       break;
                     }
                   }
                 }
               } else {
                 for (int i = 1; i<argc && ok; i++) {
                   const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                   //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
                   argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, classInfo);
                   if (argList[i]==NULL) {
                     ok = false;
                     break;
                   }
                 }
               }
               if (ok) {
                 // parameters are ok, now create the qt return value which is assigned to by metacall
                 if (returnValueParam.typeId != QMetaType::Void) {
                   // create empty default value for the return value
                   if (!directReturnValuePointer) {
                     // create empty default value for the return value
                     argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
                     if (argList[0]==NULL) {
                       // return value could not be created, maybe we have a registered class with a default constructor, so that we can construct the pythonqt wrapper object and
                       // pass its internal pointer
                       PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(returnValueParam.name);
                       if (info && info->pythonQtClassWrapper()) {
                         PyObject* emptyTuple = PyTuple_New(0);
                         // 1) default construct an empty object as python object (owned by PythonQt), by calling the meta class with empty arguments
                         result = PyObject_Call((PyObject*)info->pythonQtClassWrapper(), emptyTuple, NULL);
                         if (result) {
                           argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;
                         }
                         Py_DECREF(emptyTuple);
                       }
                     }
                   } else {
                     // we can use our pointer directly!
                     argList[0] = directReturnValuePointer;
                   }
                 }
                 // invoke the slot via metacall
                 (info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
                 // handle the return value (which in most cases still needs to be converted to a Python object)
                 if (argList[0] || returnValueParam.typeId == QMetaType::Void) {
                   if (directReturnValuePointer) {
                     result = NULL;
                   } else {
                     // the resulting object maybe present already, because we created it above at 1)...
                     if (!result) {
                       result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
                     }
                   }
                 } else {
                   QString e = QString("Called ") + info->fullSignature() + ", return type '" + returnValueParam.name + "' is ignored because it is unknown to PythonQt. Probably you should register it using qRegisterMetaType() or add a default constructor decorator to the class.";
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   result = NULL;
                 }
               }
               recursiveEntry--;
               // reset the parameter storage position to the stored pos to "pop" the parameter stack
               PythonQtConv::global_valueStorage.setPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.setPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.setPos(globalVariantStoragePos);
               *pythonReturnValue = result;
               // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
               return result || (directReturnValuePointer && *directReturnValuePointer);
             }
             //-----------------------------------------------------------------------------------
             static PythonQtSlotFunctionObject *pythonqtslot_free_list = NULL;
             PyObject *PythonQtSlotFunction_Call(PyObject *func, PyObject *args, PyObject *kw)
             {
               PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
               PythonQtSlotInfo*    info = f->m_ml;
               if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
                 if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
                   QString error = QString("Trying to call '") + f->m_ml->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   return NULL;
                 } else {
                   return PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, args, kw, self->_wrappedPtr);
                 }
               } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* type = (PythonQtClassWrapper*) f->m_self;
                 if (info->isClassDecorator()) {
                   return PythonQtSlotFunction_CallImpl(type->classInfo(), NULL, info, args, kw);
                 } else {
                   // otherwise, it is an unbound call and we have an instanceDecorator or normal slot...
                   Py_ssize_t argc = PyTuple_Size(args);
                   if (argc>0) {
                     PyObject* firstArg = PyTuple_GET_ITEM(args, 0);
                     if (PyObject_TypeCheck(firstArg, (PyTypeObject*)&PythonQtInstanceWrapper_Type)
                       && ((PythonQtInstanceWrapper*)firstArg)->classInfo()->inherits(type->classInfo())) {
                       PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*)firstArg;
                       if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
                         QString error = QString("Trying to call '") + f->m_ml->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
                         PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                         return NULL;
                       }
                       // strip the first argument...
                       PyObject* newargs = PyTuple_GetSlice(args, 1, argc);
                       PyObject* result = PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, newargs, kw, self->_wrappedPtr);
                       Py_DECREF(newargs);
                       return result;
                     } else {
                       // first arg is not of correct type!
                       QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument, got " + firstArg->ob_type->tp_name;
                       PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                       return NULL;
                     }
                   } else {
                     // wrong number of args
                     QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument.";
                     PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                     return NULL;
                   }
                 }
               }
               return NULL;
             }
             PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
             {
-              int argc = PyTuple_Size(args);
+              int argc = args?PyTuple_Size(args):0;
             #ifdef PYTHONQT_DEBUG
               std::cout << "called " << info->metaMethod()->typeName() << " " << info->metaMethod()->signature() << std::endl;
             #endif
               PyObject* r = NULL;
               bool ok = false;
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               if (info->nextInfo()) {
                 // overloaded slot call, try on all slots with strict conversion first
                 bool strict = true;
                 PythonQtSlotInfo* i = info;
                 while (i) {
                   bool skipFirst = i->isInstanceDecorator();
                   if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                     PyErr_Clear();
                     ok = PythonQtCallSlot(classInfo, objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
                     if (PyErr_Occurred() || ok) break;
                   }
                   i = i->nextInfo();
                   if (!i) {
                     if (strict) {
                       // one more run without being strict
                       strict = false;
                       i = info;
                     }
                   }
                 }
                 if (!ok && !PyErr_Occurred()) {
                   QString e = QString("Could not find matching overload for given arguments:\n" + PythonQtConv::PyObjGetString(args) + "\n The following slots are available:\n");
                   PythonQtSlotInfo* i = info;
                   while (i) {
                     e += QString(i->fullSignature()) + "\n";
                     i = i->nextInfo();
                   }
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               } else {
                 // simple (non-overloaded) slot call
                 bool skipFirst = info->isInstanceDecorator();
                 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
                   PyErr_Clear();
                   ok = PythonQtCallSlot(classInfo, objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
                   if (!ok && !PyErr_Occurred()) {
                     QString e = QString("Called ") + info->fullSignature() + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
                     PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   }
                 } else {
                   QString e = QString("Called ") + info->fullSignature() + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               }
               return r;
             }
             PyObject *
             PythonQtSlotFunction_New(PythonQtSlotInfo *ml, PyObject *self, PyObject *module)
             {
               PythonQtSlotFunctionObject *op;
               op = pythonqtslot_free_list;
               if (op != NULL) {
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(op->m_self);
                 PyObject_INIT(op, &PythonQtSlotFunction_Type);
               }
               else {
                 op = PyObject_GC_New(PythonQtSlotFunctionObject, &PythonQtSlotFunction_Type);
                 if (op == NULL)
                   return NULL;
               }
               op->m_ml = ml;
               Py_XINCREF(self);
               op->m_self = self;
               Py_XINCREF(module);
               op->m_module = module;
               PyObject_GC_Track(op);
               return (PyObject *)op;
             }
             PythonQtSlotInfo*
             PythonQtSlotFunction_GetSlotInfo(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_BadInternalCall();
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_ml;
             }
             PyObject *
             PythonQtSlotFunction_GetSelf(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_BadInternalCall();
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_self;
             }
             /* Methods (the standard built-in methods, that is) */
             static void
             meth_dealloc(PythonQtSlotFunctionObject *m)
             {
               PyObject_GC_UnTrack(m);
               Py_XDECREF(m->m_self);
               Py_XDECREF(m->m_module);
               m->m_self = (PyObject *)pythonqtslot_free_list;
               pythonqtslot_free_list = m;
             }
             static PyObject *
             meth_get__doc__(PythonQtSlotFunctionObject * /*m*/, void * /*closure*/)
             {
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyObject *
             meth_get__name__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               return PyString_FromString(m->m_ml->metaMethod()->signature());
             }
             static int
             meth_traverse(PythonQtSlotFunctionObject *m, visitproc visit, void *arg)
             {
               int err;
               if (m->m_self != NULL) {
                 err = visit(m->m_self, arg);
                 if (err)
                   return err;
               }
               if (m->m_module != NULL) {
                 err = visit(m->m_module, arg);
                 if (err)
                   return err;
               }
               return 0;
             }
             static PyObject *
             meth_get__self__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               PyObject *self;
               if (PyEval_GetRestricted()) {
                 PyErr_SetString(PyExc_RuntimeError,
                   "method.__self__ not accessible in restricted mode");
                 return NULL;
               }
               self = m->m_self;
               if (self == NULL)
                 self = Py_None;
               Py_INCREF(self);
               return self;
             }
             static PyGetSetDef meth_getsets [] = {
               {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
               {"__name__", (getter)meth_get__name__, NULL, NULL},
               {"__self__", (getter)meth_get__self__, NULL, NULL},
               {NULL, NULL, NULL,NULL},
             };
             #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 6
             #define PY_WRITE_RESTRICTED WRITE_RESTRICTED
             #endif
             #define OFF(x) offsetof(PythonQtSlotFunctionObject, x)
             static PyMemberDef meth_members[] = {
               {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
               {NULL}
             };
             static PyObject *
             meth_repr(PythonQtSlotFunctionObject *f)
             {
               if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* self = (PythonQtClassWrapper*) f->m_self;
                 return PyString_FromFormat("<unbound qt slot %s of %s type>",
                   f->m_ml->slotName().data(),
                   self->classInfo()->className());
               } else {
                 return PyString_FromFormat("<qt slot %s of %s instance at %p>",
                   f->m_ml->slotName().data(),
                   f->m_self->ob_type->tp_name,
                   f->m_self);
               }
             }
             static int
             meth_compare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b)
             {
               if (a->m_self != b->m_self)
                 return (a->m_self < b->m_self) ? -1 : 1;
               if (a->m_ml == b->m_ml)
                 return 0;
               if (strcmp(a->m_ml->metaMethod()->signature(), b->m_ml->metaMethod()->signature()) < 0)
                 return -1;
               else
                 return 1;
             }
             static long
             meth_hash(PythonQtSlotFunctionObject *a)
             {
               long x,y;
               if (a->m_self == NULL)
                 x = 0;
               else {
                 x = PyObject_Hash(a->m_self);
                 if (x == -1)
                   return -1;
               }
               y = _Py_HashPointer((void*)(a->m_ml));
               if (y == -1)
                 return -1;
               x ^= y;
               if (x == -1)
                 x = -2;
               return x;
             }
             PyTypeObject PythonQtSlotFunction_Type = {
               PyObject_HEAD_INIT(&PyType_Type)
 ,
                 "builtin_qt_slot",
                 sizeof(PythonQtSlotFunctionObject),
 ,
                 (destructor)meth_dealloc,     /* tp_dealloc */
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
                 (cmpfunc)meth_compare,      /* tp_compare */
                 (reprfunc)meth_repr,      /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_as_mapping */
                 (hashfunc)meth_hash,      /* tp_hash */
                 PythonQtSlotFunction_Call,      /* tp_call */
 ,          /* tp_str */
                 PyObject_GenericGetAttr,    /* tp_getattro */
 ,          /* tp_setattro */
 ,          /* tp_as_buffer */
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 ,          /* tp_doc */
                 (traverseproc)meth_traverse,    /* tp_traverse */
 ,          /* tp_clear */
 ,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
 ,          /* tp_methods */
                 meth_members,       /* tp_members */
                 meth_getsets,       /* tp_getset */
 ,          /* tp_base */
 ,          /* tp_dict */
             };
             /* Clear out the free list */
             void
             PythonQtSlotFunction_Fini(void)
             {
               while (pythonqtslot_free_list) {
                 PythonQtSlotFunctionObject *v = pythonqtslot_free_list;
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(v->m_self);
                 PyObject_GC_Del(v);
               }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages