GIT_REPOSITORIES/LPP/PythonQt Commit - r23:0fec1cae9cb6

- removed argument to fullSignature...

florianlink -

r23:0fec1cae9cb6

parent child

Context file:

r23:0fec1cae9cb6

Collapse all files

src/PythonQt.cpp +2 -2

                     PythonQtSlotInfo* info = o->m_ml;
                     while (info) {
-                      results << info->fullSignature(info->isInstanceDecorator());
+                      results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                     PythonQtSlotInfo* info = o->classInfo()->constructors();
                     while (info) {
-                      results << info->fullSignature(false);
+                      results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else {

src/PythonQtClassInfo.cpp +3 -3

                 h += "Constructors:\n";
                 PythonQtSlotInfo* constr = constructors();
                 while (constr) {
-                  h += constr->fullSignature(false) + "\n";
+                  h += constr->fullSignature() + "\n";
                   constr = constr->nextInfo();
                 }
               }
                     if (signa.startsWith("delete_")) continue;
                     if (signa.startsWith("static_")) continue;
                     PythonQtSlotInfo slot(m, i);
-                    h += slot.fullSignature(false)+ "\n";
+                    h += slot.fullSignature()+ "\n";
                   }
                 }
               }
                 QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(nameIt.next()));
                 while (it.hasNext()) {
                   PythonQtSlotInfo* slot = it.next();
-                  h += slot->fullSignature(slot->isInstanceDecorator()) + "\n";
+                  h += slot->fullSignature() + "\n";
                 }
               }

src/PythonQtClassWrapper.cpp +17 -7

                 }
                 dict = PyDict_Copy(dict);
-                QStringList l = wrapper->classInfo()->memberList(true);
+                QStringList l = wrapper->classInfo()->memberList(false);
                 foreach (QString name, l) {
                   PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
-                  PyDict_SetItemString(dict, name.toLatin1().data(), o);
+                  if (o) {
-                  Py_DECREF(o);
+                    PyDict_SetItemString(dict, name.toLatin1().data(), o);
+                    Py_DECREF(o);
+                  } else {
+                    // it must have been a property or child, which we do not know as a class object...
+                  }
                 }
                 if (wrapper->classInfo()->constructors()) {
-                  PyDict_SetItemString(dict, "__init__", PyCFunction_New(&PythonQtClassWrapper_methods[0], obj));
+                  PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[0], obj);
+                  PyDict_SetItemString(dict, "__init__", func);
+                  Py_DECREF(func);
+                }
+                for (int i = 1;i<3;i++) {
+                  PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);
+                  PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);
+                  Py_DECREF(func);
                 }
-                PyDict_SetItemString(dict, PythonQtClassWrapper_methods[1].ml_name, PyCFunction_New(&PythonQtClassWrapper_methods[1], obj));
-                PyDict_SetItemString(dict, PythonQtClassWrapper_methods[2].ml_name, PyCFunction_New(&PythonQtClassWrapper_methods[2], obj));
                 return dict;
               }
                 if (member._type == PythonQtMemberInfo::EnumValue) {
                   return PyInt_FromLong(member._enumValue);
                 } else
-                if (member._type == PythonQtMemberInfo::Slot && member._slot->isClassDecorator()) {
+                if (member._type == PythonQtMemberInfo::Slot) {
+                  // we return all slots, even the instance slots, since they are callable as unbound slots with self argument
                   return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 }
               }

src/PythonQtInstanceWrapper.cpp +1 -1

                 PyObject* dict = PyDict_New();
                 foreach (QString name, l) {
                   PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
-                  PyDict_SetItemString(dict, name.toLatin1().data(), Py_None);
+                  PyDict_SetItemString(dict, name.toLatin1().data(), o);
                   Py_DECREF(o);
                 }
                 // Note: we do not put children into the dict, is would look confusing?!

src/PythonQtMethodInfo.cpp +2 -1

             //-------------------------------------------------------------------------------------------------
-            QString PythonQtSlotInfo::fullSignature(bool skipFirstArg)
+            QString PythonQtSlotInfo::fullSignature()
             {
+              bool skipFirstArg = isInstanceDecorator();
               QString result = _meta.typeName();
               QByteArray sig = slotName();
               QList<QByteArray> names = _meta.parameterNames();

src/PythonQtMethodInfo.h +1 -1

               QObject* decorator() { return _decorator; }
               //! get the full signature including return type
-              QString fullSignature(bool skipFirstArg);
+              QString fullSignature();
               //! get the short slot name
               QByteArray slotName();

src/PythonQtSlot.cpp +50 -14

                     }
                   }
                 } else {
-                  QString e = QString("Called ") + info->fullSignature(skipFirst) + ", return type is ignored because it is unknown to PythonQt.";
+                  QString e = QString("Called ") + info->fullSignature() + ", return type is ignored because it is unknown to PythonQt.";
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   result = NULL;
                 }
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
                 return PythonQtSlotFunction_CallImpl(self->_obj, info, args, kw, self->_wrappedPtr);
               } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
-                return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
+                if (info->isClassDecorator()) {
-              } else {
+                  return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
-                return NULL;
+                } else {
+                  // otherwise, it is an unbound call and we have an instanceDecorator or normal slot...
+                  PythonQtClassWrapper* type = (PythonQtClassWrapper*) f->m_self;
+                  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()->className())) {
+                      PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*)firstArg;
+                      // strip the first argument...
+                      PyObject* newargs = PyTuple_New(argc-1);
+                      for (int i = 0;i<argc-1; i++) {
+                        PyTuple_SET_ITEM(newargs, i,PyTuple_GET_ITEM(args, i+1));
+                      }
+                      PyObject* result = PythonQtSlotFunction_CallImpl(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(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               if (info->nextInfo()) {
                 // overloaded slot call, try on all slots with strict conversion first
                 bool strict = true;
                   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) {
-                    bool skipFirst = i->isInstanceDecorator();
+                    e += QString(i->fullSignature()) + "\n";
-                    e += QString(i->fullSignature(skipFirst)) + "\n";
                     i = i->nextInfo();
                   }
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   PyErr_Clear();
                   ok = PythonQtCallSlot(objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
                   if (!ok && !PyErr_Occurred()) {
-                    QString e = QString("Called ") + info->fullSignature(skipFirst) + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
+                    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(skipFirst) + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
+                  QString e = QString("Called ") + info->fullSignature() + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               }
             };
             static PyObject *
-            meth_repr(PythonQtSlotFunctionObject *m)
+            meth_repr(PythonQtSlotFunctionObject *f)
             {
-              return PyString_FromFormat("<built-in qt slot %s of %s object at %p>",
+              if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
-                m->m_ml->metaMethod()->signature(),
+                PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
-                m->m_self->ob_type->tp_name,
+                return PyString_FromFormat("<qt slot %s of %s instance at %p>",
-                m->m_self);
+                  f->m_ml->metaMethod()->signature(),
+                  f->m_self->ob_type->tp_name,
+                  f->m_self);
+              } else 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->metaMethod()->signature(),
+                  self->classInfo()->className());
+              }
             }
             static int

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