GIT_REPOSITORIES/LPP/PythonQt Commit - r41:189c3eb0464d

fixed enum handling for static methods calls and added correct support for decorated enum detection...

florianlink -

r41:189c3eb0464d

parent child

Context file:

r41:189c3eb0464d

Collapse all files

src/PythonQt.cpp 0 -27

@@ -276,33 +276,6 void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const
276	info->setPythonQtClassWrapper(pyobj);	276	info->setPythonQtClassWrapper(pyobj);
277	}	277	}
278		278
279	bool PythonQtPrivate::isEnumType(const QMetaObject* meta, const QByteArray& name) {
280	int i = meta?meta->indexOfEnumerator(name.constData()):-1;
281	if (i!=-1) {
282	return true;
283	} else {
284	// look for scope
285	int scopePos = name.indexOf("::");
286	if (scopePos != -1) {
287	// slit into scope and enum name
288	QByteArray enumScope = name.mid(0,scopePos);
289	QByteArray enumName = name.mid(scopePos+2);
290	if (enumScope == "Qt") {
291	// special qt namespace case
292	return isEnumType(&staticQtMetaObject, enumName);
293	} else {
294	// look for known classes as scope
295	// TODO: Q_GADGETS are not yet handled
296	PythonQtClassInfo* info = _knownClassInfos.value(enumScope);
297	if (info) {
298	return isEnumType(info->metaObject(), enumName);
299	}
300	}
301	}
302	}
303	return false;
304	}
305
306	PyObject* PythonQtPrivate::wrapQObject(QObject* obj)	279	PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
307	{	280	{
308	if (!obj) {	281	if (!obj) {

src/PythonQt.h 0 -4

               //! add a decorator object
               void addDecorators(QObject* o, int decoTypes);
-              //! check if the enum is either part of the \c meta class or contains a scope and is
-              //! an enum of another known metaobject (and as last resort, of the Qt namespace)
-              bool isEnumType(const QMetaObject* meta, const QByteArray& name);
               //! helper method that creates a PythonQtClassWrapper object
               PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package = NULL);

src/PythonQtClassInfo.cpp +43 0

@@ -725,3 +725,46 void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resul
725	}	725	}
726	return resultPtr;	726	return resultPtr;
727	}	727	}
		728
		729	bool PythonQtClassInfo::hasEnum(const QByteArray& name, PythonQtClassInfo* localScope)
		730	{
		731	int scopePos = name.lastIndexOf("::");
		732	if (scopePos != -1) {
		733	// slit into scope and enum name
		734	QByteArray enumScope = name.mid(0,scopePos);
		735	QByteArray enumName = name.mid(scopePos+2);
		736	PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(enumScope);
		737	if (info) {
		738	return info->hasEnum(enumName);
		739	} else{
		740	return false;
		741	}
		742	}
		743	if (localScope) {
		744	return localScope->hasEnum(name);
		745	} else {
		746	return false;
		747	}
		748	}
		749
		750	bool PythonQtClassInfo::hasEnum(const QByteArray& name)
		751	{
		752	bool found = false;
		753	if (_meta) {
		754	found = _meta->indexOfEnumerator(name)!=-1;
		755	}
		756	if (!found) {
		757	// check enums in the class hierachy of CPP classes
		758	// look for dynamic decorators in this class and in derived classes
		759	QList<QObject*> decoObjects;
		760	recursiveCollectDecoratorObjects(decoObjects);
		761	foreach(QObject* deco, decoObjects) {
		762	found = deco->metaObject()->indexOfEnumerator(name)!=-1;
		763	if (found) {
		764	break;
		765	}
		766	}
		767	}
		768	return found;
		769	}
		770

src/PythonQtClassInfo.h +6 0

               //! cast the pointer down in the class hierarchy if a polymorphic handler allows to do that
               void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
+              //! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum
+              static bool hasEnum(const QByteArray& name, PythonQtClassInfo* localScope);
             private:
+              //! checks if the enum is part of this class (without any leading scope!)
+              bool hasEnum(const QByteArray& name);
               //! clear all cached members
               void clearCachedMembers();

src/PythonQtConversion.cpp +2 -2

                return object;
              }
-             void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, const QMetaObject* meta, void* alreadyAllocatedCPPObject)
+             void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* meta, void* alreadyAllocatedCPPObject)
              {
                bool ok;
                void* ptr = NULL;
                    {
                      if (info.typeId == PythonQtMethodInfo::Unknown) {
                        // check for enum case
-                       if (meta && PythonQt::priv()->isEnumType(meta, info.name)) {
+                       if (PythonQtClassInfo::hasEnum(info.name, meta)) {
                          unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
                          if (ok) {
                            PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);

src/PythonQtConversion.h +1 -1

               static PyObject* ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data);
               //! convert python object to Qt (according to the given parameter) and if the conversion should be strict, the meta object is passed in for enum resolving
-              static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, const QMetaObject* meta, void* alreadyAllocatedCPPObject = NULL);
+              static void* ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* meta, void* alreadyAllocatedCPPObject = NULL);
               //! creates a data storage for the passed parameter type and returns a void pointer to be set as arg[0] of qt_metacall
               static void* CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info);

src/PythonQtInstanceWrapper.cpp +1 -1

               // we are called from python, try to construct our object
               if (self->classInfo()->constructors()) {
                 void* directCPPPointer = NULL;
-                PythonQtSlotFunction_CallImpl(NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
+                PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
                 if (PyErr_Occurred()) {
                   return -1;
                 }

src/PythonQtSlot.cpp +11 -12

             #define PYTHONQT_MAX_ARGS 32
-            bool PythonQtCallSlot(QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
+            bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
             {
               static unsigned int recursiveEntry = 0;
               if (returnValueParam.typeId != QMetaType::Void) {
                 // extra handling of enum return value
                 if (!returnValueParam.isPointer && returnValueParam.typeId == PythonQtMethodInfo::Unknown) {
-                  returnValueIsEnum = PythonQt::priv()->isEnumType(objectToCall->metaObject(), returnValueParam.name);
+                  returnValueIsEnum = PythonQtClassInfo::hasEnum(returnValueParam.name, classInfo);
                   if (returnValueIsEnum) {
                     // create enum return value
                     PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
                 }
               }
-              const QMetaObject* meta = objectToCall?objectToCall->metaObject():NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator()) {
                   for (int i = 2; i<argc && ok; i++) {
                     const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                     //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
-                    argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, meta);
+                    argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, classInfo);
                     if (argList[i]==NULL) {
                       ok = false;
                       break;
                 for (int i = 1; i<argc && ok; i++) {
                   const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                   //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
-                  argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, meta);
+                  argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, classInfo);
                   if (argList[i]==NULL) {
                     ok = false;
                     break;
               PythonQtSlotInfo*    info = f->m_ml;
               if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
-                return PythonQtSlotFunction_CallImpl(self->_obj, info, args, kw, self->_wrappedPtr);
+                return PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, args, kw, self->_wrappedPtr);
               } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
+                PythonQtClassWrapper* type = (PythonQtClassWrapper*) f->m_self;
                 if (info->isClassDecorator()) {
-                  return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
+                  return PythonQtSlotFunction_CallImpl(type->classInfo(), 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);
                       PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*)firstArg;
                       // strip the first argument...
                       PyObject* newargs = PyTuple_GetSlice(args, 1, argc);
-                      PyObject* result = PythonQtSlotFunction_CallImpl(self->_obj, info, newargs, kw, self->_wrappedPtr);
+                      PyObject* result = PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, newargs, kw, self->_wrappedPtr);
                       Py_DECREF(newargs);
                       return result;
                     } else {
               return NULL;
             }
-            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
+            PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
             {
               int argc = PyTuple_Size(args);
                   bool skipFirst = i->isInstanceDecorator();
                   if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                     PyErr_Clear();
-                    ok = PythonQtCallSlot(objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
+                    ok = PythonQtCallSlot(classInfo, objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
                     if (PyErr_Occurred() || ok) break;
                   }
                   i = i->nextInfo();
                 bool skipFirst = info->isInstanceDecorator();
                 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
                   PyErr_Clear();
-                  ok = PythonQtCallSlot(objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
+                  ok = PythonQtCallSlot(classInfo, objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
                   if (!ok && !PyErr_Occurred()) {
                     QString e = QString("Called ") + info->fullSignature() + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
                     PyErr_SetString(PyExc_ValueError, e.toLatin1().data());

src/PythonQtSlot.h +1 -1

             PyObject* PythonQtSlotFunction_Call(PyObject *, PyObject *, PyObject *);
-            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject *kw, void* firstArg=NULL,  void** directReturnValuePointer=NULL);
+            PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject *kw, void* firstArg=NULL,  void** directReturnValuePointer=NULL);
             PyObject* PythonQtSlotFunction_New(PythonQtSlotInfo *, PyObject *,

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