GIT_REPOSITORIES/LPP/PythonQt Commit - r56:607d4eb3cb2d

support enum values on signals as well, all tests should succeed now...

florianlink -

r56:607d4eb3cb2d

parent child

Context file:

r56:607d4eb3cb2d

Collapse all files

src/PythonQt.cpp +8 0

               return result;
             }
+            PyObject*  PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)
+            {
+              PyObject* args = Py_BuildValue("(i)", enumValue);
+              PyObject* result = PyObject_Call(enumType, args, NULL);
+              Py_DECREF(args);
+              return result;
+            }
             PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
               PyObject* result;

src/PythonQt.h +6 -3

               //! add a decorator object
               void addDecorators(QObject* o, int decoTypes);
-              //! helper method that creates a PythonQtClassWrapper object
+              //! helper method that creates a PythonQtClassWrapper object  (returns a new reference)
               PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package = NULL);
-              //! helper that creates a new int derived class that represents the enum of the given name
+              //! create a new instance of the given enum type with given value (returns a new reference)
-              PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
+              static PyObject*  createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
+              //! helper that creates a new int derived class that represents the enum of the given name  (returns a new reference)
+              static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
               //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
               PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);

src/PythonQtClassInfo.cpp +6 -5

                   if (qstrcmp(e.key(j), memberName)==0) {
                     PyObject* enumType = findEnumWrapper(e.name());
                     if (enumType) {
-                      PyObject* args = Py_BuildValue("(i)", e.value(j));
-                      PyObject* enumValue = PyObject_Call(enumType, args, NULL);
-                      Py_DECREF(args);
                       PythonQtObjectPtr enumValuePtr;
-                      enumValuePtr.setNewRef(enumValue);
+                      enumValuePtr.setNewRef(PythonQtPrivate::createEnumValueInstance(enumType, e.value(j)));
                       PythonQtMemberInfo newInfo(enumValuePtr);
                       _cachedMembers.insert(memberName, newInfo);
               #ifdef PYTHONQT_DEBUG
               for (int i = meta->enumeratorOffset();i<meta->enumeratorCount();i++) {
                 QMetaEnum e = meta->enumerator(i);
                 PythonQtObjectPtr p;
-                p.setNewRef(PythonQt::priv()->createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
+                p.setNewRef(PythonQtPrivate::createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
                 _enumWrappers.append(p);
               }
             }
             }
             PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
+              // force enum creation
+              if (!_enumsCreated) {
+                createEnumWrappers();
+              }
               foreach(const PythonQtObjectPtr& p, _enumWrappers) {
                 const char* className = ((PyTypeObject*)p.object())->tp_name;
                 if (qstrcmp(className, name)==0) {

src/PythonQtConversion.cpp +14 0

             }
             PyObject* PythonQtConv::ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data) {
+              // is it an enum value?
+              if (info.enumWrapper) {
+                if (!info.isPointer) {
+                  return PythonQtPrivate::createEnumValueInstance(info.enumWrapper, *((unsigned int*)data));
+                } else {
+                  // we do not support pointers to enums (who needs them?)
+                  Py_INCREF(Py_None);
+                  return Py_None;
+                }
+              }
               if (info.typeId == QMetaType::Void) {
                 Py_INCREF(Py_None);
                 return Py_None;
                void* ptr = NULL;
                if (info.isPointer) {
                  PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, ptr);
+               } else if (info.enumWrapper) {
+                 // create enum return value
+                 PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, ptr);
                } else {
                  switch (info.typeId) {
                  case QMetaType::Char:

src/PythonQtSlot.cpp 0 -13

               }
               if (ok) {
-                bool returnValueIsEnum = false;
                 // parameters are ok, now create the qt return value which is assigned to by metacall
                 if (returnValueParam.typeId != QMetaType::Void) {
-                  // extra handling of enum return value
-                  if (!returnValueParam.isPointer && returnValueParam.enumWrapper) {
-                    // create enum return value
-                    PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
-                    returnValueIsEnum = true;
-                  } else {
                   // create empty default value for the return value
                   if (!directReturnValuePointer) {
                     // create empty default value for the return value
                     argList[0] = directReturnValuePointer;
                   }
                 }
                 // invoke the slot via metacall
                 (info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
                   if (directReturnValuePointer) {
                     result = NULL;
                   } else {
-                    if (!returnValueIsEnum) {
                     // the resulting object maybe present already, because we created it above at 1)...
                     if (!result) {
                       result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
                     }
-                    } else {
-                      result = PyInt_FromLong(*((unsigned int*)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.";

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