GIT_REPOSITORIES/LPP/PythonQt Commit - r116:806ca936e21a

adapted to new py_ naming of special methods and added support for py_toString...

florianlink -

r116:806ca936e21a

parent child

Context file:

r116:806ca936e21a

Collapse all files

src/PythonQtClassInfo.cpp +4 -1

                       continue;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       continue;
+                    } else if (qstrncmp(sigStart, "py_", 3)==0) {
+                      // hide everything that starts with py_
+                      continue;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
             bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
             {
-              PythonQtMemberInfo info = member("hasOwner");
+              PythonQtMemberInfo info = member("py_hasOwner");
               if (info._type == PythonQtMemberInfo::Slot) {
                 void* obj = object;
                 bool result = false;

src/PythonQtClassInfo.h +1 -1

               //! add the parent class info of a CPP object
               void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
-              //! check if the special method "hasOwner" is implemented and if it returns false, which means that the object may be destroyed
+              //! check if the special method "py_hasOwner" is implemented and if it returns false, which means that the object may be destroyed
               bool hasOwnerMethodButNoOwner(void* object);
               //! set the associated PythonQtClassWrapper (which handles instance creation of this type)

src/PythonQtInstanceWrapper.cpp +40 -10

                 break;
               case PythonQtMemberInfo::NotFound:
                 {
-                  // check for a getter_
+                  static const QByteArray getterString("py_get_");
-                  PythonQtMemberInfo member = wrapper->classInfo()->member(QByteArray("getter_") + attributeName);
+                  // 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);
                   }
               } 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_
+                // check for a setter slot
-                PythonQtMemberInfo setter = wrapper->classInfo()->member(QByteArray("setter_") + attributeName);
+                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;
               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;
+                }
+              }
+              // 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;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
-              if (wrapper->_wrappedPtr) {
+              QString str = getStringFromObject(wrapper);
-                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
               if (!str.isEmpty()) {
                 return PyString_FromFormat("%s", str.toLatin1().constData());
-                } else
+              if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
-              if (wrapper->_wrappedPtr) {
+              QString str = getStringFromObject(wrapper);
-                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
               if (!str.isEmpty()) {
+                if (str.startsWith(typeName)) {
+                  return PyString_FromFormat("%s", str.toLatin1().constData());
+                } else {
                   return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
-                } else
+              }
+              if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                         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 result?0:-1;
                       }
                     }
                   }

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