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 +15 -5

                  }
                  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());
+                   if (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 +47 -11

                      }
                    }
                  } 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) {
+                 if (info->isClassDecorator()) {
                  return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
                } 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(skipFirst)) + "\n";
+                     e += QString(i->fullSignature()) + "\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>",
-                 m->m_ml->metaMethod()->signature(),
-                 m->m_self->ob_type->tp_name,
-                 m->m_self);
+               if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
+                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
+                 return PyString_FromFormat("<qt slot %s of %s instance at %p>",
+                   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