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 +22 -35

@@ -118,38 +118,29 bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObj
118	}	118	}
119		119
120	if (ok) {	120	if (ok) {
121	bool returnValueIsEnum = false;
122
123	// parameters are ok, now create the qt return value which is assigned to by metacall	121	// parameters are ok, now create the qt return value which is assigned to by metacall
124	if (returnValueParam.typeId != QMetaType::Void) {	122	if (returnValueParam.typeId != QMetaType::Void) {
125	// extra handling of enum return value	123	// create empty default value for the return value
126	if (!returnValueParam.isPointer && returnValueParam.enumWrapper) {	124	if (!directReturnValuePointer) {
127	// create enum return value
128	PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
129	returnValueIsEnum = true;
130	} else {
131	// create empty default value for the return value	125	// create empty default value for the return value
132	if (!directReturnValuePointer) {	126	argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
133	// create empty default value for the return value	127	if (argList[0]==NULL) {
134	argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);	128	// 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
135	if (argList[0]==NULL) {	129	// pass its internal pointer
136	// 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	130	PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(returnValueParam.name);
137	// pass its internal pointer	131	if (info && info->pythonQtClassWrapper()) {
138	PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(returnValueParam.name);	132	PyObject* emptyTuple = PyTuple_New(0);
139	if (info && info->pythonQtClassWrapper()) {	133	// 1) default construct an empty object as python object (owned by PythonQt), by calling the meta class with empty arguments
140	PyObject* emptyTuple = PyTuple_New(0);	134	result = PyObject_Call((PyObject*)info->pythonQtClassWrapper(), emptyTuple, NULL);
141	// 1) default construct an empty object as python object (owned by PythonQt), by calling the meta class with empty arguments	135	if (result) {
142	result = PyObject_Call((PyObject*)info->pythonQtClassWrapper(), emptyTuple, NULL);	136	argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;
143	if (~~result~~) {	137	}
144	argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;	138	Py_DECREF(emptyTuple);
145	}	139	}
146	Py_DECREF(emptyTuple);
147	}
148	}
149	} else {
150	// we can use our pointer directly!
151	argList[0] = directReturnValuePointer;
152	}	140	}
		141	} else {
		142	// we can use our pointer directly!
		143	argList[0] = directReturnValuePointer;
153	}	144	}
154	}	145	}
155		146
@@ -161,13 +152,9 bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObj
161	if (directReturnValuePointer) {	152	if (directReturnValuePointer) {
162	result = NULL;	153	result = NULL;
163	} else {	154	} else {
164	if (!returnValueIsEnum) {	155	// the resulting object maybe present already, because we created it above at 1)...
165	// the resulting object maybe present already, because we created it above at 1)...	156	if (!result) {
166	if (!result) {	157	result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
167	result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
168	}
169	} else {
170	result = PyInt_FromLong(((unsigned int)argList[0]));
171	}	158	}
172	}	159	}
173	} else {	160	} 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