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
-               PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
+               //! create a new instance of the given enum type with given value (returns a new reference)
+               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 +22 -35

                }
                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
-                     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;
+                     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;
                    }
                  }
                    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]));
+                     // the resulting object maybe present already, because we created it above at 1)...
+                     if (!result) {
+                       result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
                      }
                    }
                  } else {

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