GIT_REPOSITORIES/LPP/PythonQt Commit - r51:581e3ee75957

added enum wrapper classes derived from python int, so that enums are distinguishable from normal python integers. This will allow better overload handling e.g. of QColor constructors in the future...

florianlink -

r51:581e3ee75957

parent child

Context file:

r51:581e3ee75957

Collapse all files

src/PythonQt.cpp +24 0

@@ -431,6 +431,30 PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtCla
431	return result;	431	return result;
432	}	432	}
433		433
		434	PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
		435	PyObject* result;
		436
		437	PyObject* className = PyString_FromString(enumName);
		438
		439	PyObject* baseClasses = PyTuple_New(1);
		440	PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
		441
		442	PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
		443	PyObject* typeDict = PyDict_New();
		444	PyDict_SetItemString(typeDict, "__module__", module);
		445
		446	PyObject* args = Py_BuildValue("OOO", className, baseClasses, typeDict);
		447
		448	// create the new int derived type object by calling the core type
		449	result = PyObject_Call((PyObject *)&PyType_Type, args, NULL);
		450
		451	Py_DECREF(baseClasses);
		452	Py_DECREF(typeDict);
		453	Py_DECREF(args);
		454	Py_DECREF(className);
		455
		456	return result;
		457	}
434		458
435	PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)	459	PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
436	{	460	{

src/PythonQt.h +3 0

               //! helper method that creates a PythonQtClassWrapper object
               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);
               //! 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 +71 -5

@@ -43,6 +43,8
43	#include "PythonQtMethodInfo.h"	43	#include "PythonQtMethodInfo.h"
44	#include "PythonQt.h"	44	#include "PythonQt.h"
45	#include <QMetaMethod>	45	#include <QMetaMethod>
		46	#include <QMetaObject>
		47	#include <QMetaEnum>
46		48
47	QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;	49	QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
48		50
@@ -56,6 +58,7 PythonQtClassInfo::PythonQtClassInfo() {
56	_shellSetInstanceWrapperCB = NULL;	58	_shellSetInstanceWrapperCB = NULL;
57	_metaTypeId = -1;	59	_metaTypeId = -1;
58	_isQObject = false;	60	_isQObject = false;
		61	_enumsCreated = false;
59	}	62	}
60		63
61	PythonQtClassInfo::~PythonQtClassInfo()	64	PythonQtClassInfo::~PythonQtClassInfo()
@@ -250,13 +253,23 bool PythonQtClassInfo::lookForEnumAndCache(const QMetaObject* meta, const char*
250	QMetaEnum e = meta->enumerator(i);	253	QMetaEnum e = meta->enumerator(i);
251	for (int j=0; j < e.keyCount(); j++) {	254	for (int j=0; j < e.keyCount(); j++) {
252	if (qstrcmp(e.key(j), memberName)==0) {	255	if (qstrcmp(e.key(j), memberName)==0) {
253	PythonQtMemberInfo newInfo(e.value(j));	256	PyObject* enumType = findEnumWrapper(e.name());
254	_cachedMembers.insert(memberName, newInfo);	257	if (enumType) {
		258	PyObject* args = Py_BuildValue("(i)", e.value(j));
		259	PyObject* enumValue = PyObject_Call(enumType, args, NULL);
		260	Py_DECREF(args);
		261	PythonQtObjectPtr enumValuePtr;
		262	enumValuePtr.setNewRef(enumValue);
		263	PythonQtMemberInfo newInfo(enumValuePtr);
		264	_cachedMembers.insert(memberName, newInfo);
255	#ifdef PYTHONQT_DEBUG	265	#ifdef PYTHONQT_DEBUG
256	std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;	266	std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
257	#endif	267	#endif
258	found = true;	268	found = true;
259	break;	269	break;
		270	} else {
		271	std::cout << "enum " << e.name() << " not found on " << className() << std::endl;
		272	}
260	}	273	}
261	}	274	}
262	}	275	}
@@ -295,6 +308,15 PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
295	}	308	}
296	}	309	}
297	if (!found) {	310	if (!found) {
		311	PyObject* p = findEnumWrapper(memberName);
		312	if (p) {
		313	info._type = PythonQtMemberInfo::EnumWrapper;
		314	info._enumWrapper = p;
		315	_cachedMembers.insert(memberName, info);
		316	found = true;
		317	}
		318	}
		319	if (!found) {
298	// we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)	320	// we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)
299	info._type = PythonQtMemberInfo::NotFound;	321	info._type = PythonQtMemberInfo::NotFound;
300	_cachedMembers.insert(memberName, info);	322	_cachedMembers.insert(memberName, info);
@@ -470,6 +492,7 QStringList PythonQtClassInfo::memberList(bool metaOnly)
470	foreach(const QMetaObject* meta, enumMetaObjects) {	492	foreach(const QMetaObject* meta, enumMetaObjects) {
471	for (int i = 0; i<meta->enumeratorCount(); i++) {	493	for (int i = 0; i<meta->enumeratorCount(); i++) {
472	QMetaEnum e = meta->enumerator(i);	494	QMetaEnum e = meta->enumerator(i);
		495	l << e.name();
473	for (int j=0; j < e.keyCount(); j++) {	496	for (int j=0; j < e.keyCount(); j++) {
474	l << QString(e.key(j));	497	l << QString(e.key(j));
475	}	498	}
@@ -661,6 +684,9 QObject* PythonQtClassInfo::decorator()
661	PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator \| PythonQtPrivate::DestructorDecorator);	684	PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator \| PythonQtPrivate::DestructorDecorator);
662	}	685	}
663	}	686	}
		687	if (!_enumsCreated) {
		688	createEnumWrappers();
		689	}
664	return _decoratorProvider;	690	return _decoratorProvider;
665	}	691	}
666		692
@@ -768,3 +794,43 bool PythonQtClassInfo::hasEnum(const QByteArray& name)
768	return found;	794	return found;
769	}	795	}
770		796
		797	void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)
		798	{
		799	for (int i = meta->enumeratorOffset();i<meta->enumeratorCount();i++) {
		800	QMetaEnum e = meta->enumerator(i);
		801	PythonQtObjectPtr p;
		802	p.setNewRef(PythonQt::priv()->createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
		803	_enumWrappers.append(p);
		804	}
		805	}
		806
		807	void PythonQtClassInfo::createEnumWrappers()
		808	{
		809	if (!_enumsCreated) {
		810	_enumsCreated = true;
		811	if (_meta) {
		812	createEnumWrappers(_meta);
		813	}
		814	if (decorator()) {
		815	createEnumWrappers(decorator()->metaObject());
		816	}
		817	foreach(const ParentClassInfo& info, _parentClasses) {
		818	info._parent->createEnumWrappers();
		819	}
		820	}
		821	}
		822
		823	PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
		824	foreach(const PythonQtObjectPtr& p, _enumWrappers) {
		825	const char* className = ((PyTypeObject*)p.object())->tp_name;
		826	if (qstrcmp(className, name)==0) {
		827	return p.object();
		828	}
		829	}
		830	foreach(const ParentClassInfo& info, _parentClasses) {
		831	PyObject* p = info._parent->findEnumWrapper(name);
		832	if (p) return p;
		833	}
		834	return NULL;
		835	}
		836

src/PythonQtClassInfo.h +17 -7

             struct PythonQtMemberInfo {
               enum Type {
-                Invalid, Slot, EnumValue, Property, NotFound
+                Invalid, Slot, EnumValue, EnumWrapper, Property, NotFound
               };
-              PythonQtMemberInfo():_type(Invalid),_slot(NULL),_enumValue(0) { }
+              PythonQtMemberInfo():_type(Invalid),_slot(NULL),_enumWrapper(NULL),_enumValue(0) { }
               PythonQtMemberInfo(PythonQtSlotInfo* info) {
                 _type = Slot;
                 _slot = info;
-                _enumValue = 0;
+                _enumValue = NULL;
               }
-              PythonQtMemberInfo(unsigned int enumValue) {
+              PythonQtMemberInfo(const PythonQtObjectPtr& enumValue) {
                 _type = EnumValue;
                 _slot = NULL;
                 _enumValue = enumValue;
+                _enumWrapper = NULL;
               }
               PythonQtMemberInfo(const QMetaProperty& prop) {
                 _type = Property;
                 _slot = NULL;
-                _enumValue = 0;
+                _enumValue = NULL;
                 _property = prop;
+                _enumWrapper = NULL;
               }
               Type              _type;
               // TODO: this could be a union...
               PythonQtSlotInfo* _slot;
-              unsigned int      _enumValue;
+              PyObject*         _enumWrapper;
+              PythonQtObjectPtr _enumValue;
               QMetaProperty     _property;
             };
               //! 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:
+              void createEnumWrappers();
+              void createEnumWrappers(const QMetaObject* meta);
+              PyObject* findEnumWrapper(const char* name);
               //! checks if the enum is part of this class (without any leading scope!)
               bool hasEnum(const QByteArray& name);
               PythonQtSlotInfo*                    _destructor;
               QList<PythonQtSlotInfo*>             _decoratorSlots;
+              QList<PythonQtObjectPtr>             _enumWrappers;
               const QMetaObject*                   _meta;
               QByteArray                           _wrappedClassName;
               int                                  _metaTypeId;
               bool                                 _isQObject;
+              bool                                 _enumsCreated;
             };

src/PythonQtClassWrapper.cpp +8 -3

               if (wrapper->classInfo()) {
                 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
                 if (member._type == PythonQtMemberInfo::EnumValue) {
-                  return PyInt_FromLong(member._enumValue);
+                  PyObject* enumValue = member._enumValue;
-                } else
+                  Py_INCREF(enumValue);
-                if (member._type == PythonQtMemberInfo::Slot) {
+                  return enumValue;
+                } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
+                  PyObject* enumWrapper = member._enumWrapper;
+                  Py_INCREF(enumWrapper);
+                  return enumWrapper;
+                } else if (member._type == PythonQtMemberInfo::Slot) {
                   // we return all slots, even the instance slots, since they are callable as unbound slots with self argument
                   return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 }

src/PythonQtConversion.cpp +8 -5

               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
               } else if (!strict) {
-                if (val->ob_type == &PyFloat_Type) {
+                if (PyObject_TypeCheck(val, &PyInt_Type)) {
+                  // support for derived int classes, e.g. for our enums
+                  d = PyInt_AS_LONG(val);
+                } else if (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val->ob_type == &PyLong_Type) {
                   // handle error on overflow!
             qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
               qint64 d = 0;
               ok = true;
-              if (val->ob_type == &PyInt_Type) {
+              if (PyObject_TypeCheck(val, &PyInt_Type)) {
                 d = PyInt_AS_LONG(val);
               } else if (val->ob_type == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
-              if (val->ob_type == &PyInt_Type) {
+              if (PyObject_TypeCheck(val, &PyInt_Type)) {
                 d = PyInt_AS_LONG(val);
               } else if (val->ob_type == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               if (val->ob_type == &PyFloat_Type) {
                 d = PyFloat_AS_DOUBLE(val);
               } else if (!strict) {
-                if (val->ob_type == &PyInt_Type) {
+                if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyLong_Type) {
                   d = PyLong_AsLong(val);
                 // no special type requested
                 if (val->ob_type==&PyString_Type || val->ob_type==&PyUnicode_Type) {
                   type = QVariant::String;
-                } else if (val->ob_type==&PyInt_Type) {
+                } else if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   type = QVariant::Int;
                 } else if (val->ob_type==&PyLong_Type) {
                   type = QVariant::LongLong;

src/PythonQtInstanceWrapper.cpp +10 -1

                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
-                return PyInt_FromLong(member._enumValue);
+                PyObject* enumValue = member._enumValue;
+                Py_INCREF(enumValue);
+                return enumValue;
+                break;
+              case PythonQtMemberInfo::EnumWrapper:
+                PyObject* enumWrapper = member._enumWrapper;
+                Py_INCREF(enumWrapper);
+                return enumWrapper;
                 break;
                 default:
                   // is an invalid type, go on
                 error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::EnumValue) {
                 error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
+              } 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) {
                 // if we are a derived python class, we allow setting attributes.
                 // if we are a direct CPP wrapper, we do NOT allow it, since

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