GIT_REPOSITORIES/LPP/PythonQt Commit - r116:806ca936e21a

adapted to new py_ naming of special methods and added support for py_toString...

florianlink -

r116:806ca936e21a

parent child

Context file:

r116:806ca936e21a

Collapse all files

src/PythonQtClassInfo.cpp +4 -1

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQt.h"
             #include <QMetaMethod>
             #include <QMetaObject>
             #include <QMetaEnum>
             QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
             PythonQtClassInfo::PythonQtClassInfo() {
               _meta = NULL;
               _constructors = NULL;
               _destructor = NULL;
               _decoratorProvider = NULL;
               _decoratorProviderCB = NULL;
               _pythonQtClassWrapper = NULL;
               _shellSetInstanceWrapperCB = NULL;
               _metaTypeId = -1;
               _isQObject = false;
               _enumsCreated = false;
             }
             PythonQtClassInfo::~PythonQtClassInfo()
             {
               clearCachedMembers();
               if (_constructors) {
                 _constructors->deleteOverloadsAndThis();
               }
               if (_destructor) {
                 _destructor->deleteOverloadsAndThis();
               }
               foreach(PythonQtSlotInfo* info, _decoratorSlots) {
                 info->deleteOverloadsAndThis();
               }
             }
             void PythonQtClassInfo::setupQObject(const QMetaObject* meta)
             {
               // _wrappedClassName is already set earlier in the class setup
               _isQObject = true;
               _meta = meta;
             }
             void PythonQtClassInfo::setupCPPObject(const QByteArray& classname)
             {
               _isQObject = false;
               _wrappedClassName = classname;
               _metaTypeId = QMetaType::type(classname);
             }
             void PythonQtClassInfo::clearCachedMembers()
             {
               QHashIterator<QByteArray, PythonQtMemberInfo> i(_cachedMembers);
               while (i.hasNext()) {
                 PythonQtMemberInfo member = i.next().value();
                 if (member._type== PythonQtMemberInfo::Slot) {
                   PythonQtSlotInfo* info = member._slot;
                   while (info) {
                     PythonQtSlotInfo* next = info->nextInfo();
                     delete info;
                     info = next;
                   }
                 }
               }
             }
             int PythonQtClassInfo::findCharOffset(const char* sigStart, char someChar)
             {
               const char* sigEnd = sigStart;
               char c;
               do {
                 c = *sigEnd++;
               } while (c!=someChar && c!=0);
               return sigEnd-sigStart-1;
             }
             bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)
             {
               if (!_meta) return false;
               bool found = false;
               bool nameMapped = false;
               const char* attributeName = memberName;
               // look for properties
               int i = _meta->indexOfProperty(attributeName);
               if (i==-1) {
                 // try to map name to objectName
                 if (qstrcmp(attributeName, "name")==0) {
                   attributeName = "objectName";
                   nameMapped = true;
                   i = _meta->indexOfProperty(attributeName);
                 }
               }
               if (i!=-1) {
                 PythonQtMemberInfo newInfo(_meta->property(i));
                 _cachedMembers.insert(attributeName, newInfo);
                 if (nameMapped) {
                   _cachedMembers.insert(memberName, newInfo);
                 }
               #ifdef PYTHONQT_DEBUG
                 std::cout << "caching property " << memberName << " on " << _meta->className() << std::endl;
               #endif
                 found = true;
               }
               return found;
             }
             PythonQtSlotInfo* PythonQtClassInfo::recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
             {
               inputInfo = findDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset);
               foreach(const ParentClassInfo& info, _parentClasses) {
                 inputInfo = info._parent->recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset+info._upcastingOffset);
               }
               return inputInfo;
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset) {
               QObject* decoratorProvider = decorator();
               int memberNameLen = strlen(memberName);
               if (decoratorProvider) {
                 //qDebug()<< "looking " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       isClassDeco = true;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
                       PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
                       info->setUpcastingOffset(upcastingOffset);
                       //qDebug()<< "adding " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         memberCache.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               tail = findDecoratorSlots(memberName, memberNameLen, tail, found, memberCache, upcastingOffset);
               return tail;
             }
             bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
             {
               bool found = false;
               int memberNameLen = strlen(memberName);
               PythonQtSlotInfo* tail = NULL;
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 for (int i = 0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if (((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
                     || m.methodType()==QMetaMethod::Signal) {
                     const char* sigStart = m.signature();
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
                       PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         _cachedMembers.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               // look for dynamic decorators in this class and in derived classes
               tail = recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers, 0);
               return found;
             }
             bool PythonQtClassInfo::lookForEnumAndCache(const QMetaObject* meta, const char* memberName)
             {
               bool found = false;
               // look for enum values
               int enumCount = meta->enumeratorCount();
               for (int i=0;i<enumCount; i++) {
                 QMetaEnum e = meta->enumerator(i);
                 // we do not want flags, they will cause our values to appear two times
                 if (e.isFlag()) continue;
                 for (int j=0; j < e.keyCount(); j++) {
                   if (qstrcmp(e.key(j), memberName)==0) {
                     PyObject* enumType = findEnumWrapper(e.name());
                     if (enumType) {
                       PythonQtObjectPtr enumValuePtr;
                       enumValuePtr.setNewRef(PythonQtPrivate::createEnumValueInstance(enumType, e.value(j)));
                       PythonQtMemberInfo newInfo(enumValuePtr);
                       _cachedMembers.insert(memberName, newInfo);
               #ifdef PYTHONQT_DEBUG
                       std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
               #endif
                       found = true;
                       break;
                     } else {
                       std::cout << "enum " << e.name() << " not found on " << className() << std::endl;
                     }
                   }
                 }
               }
               return found;
             }
             PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
             {
               PythonQtMemberInfo info = _cachedMembers.value(memberName);
               if (info._type != PythonQtMemberInfo::Invalid) {
                 return info;
               } else {
                 bool found = false;
                 found = lookForPropertyAndCache(memberName);
                 if (!found) {
                   found = lookForMethodAndCache(memberName);
                 }
                 if (!found) {
                   if (_meta) {
                     // check enums in our meta object directly
                     found = lookForEnumAndCache(_meta, memberName);
                   }
                   if (!found) {
                     // check enums in the class hierachy of CPP classes
                     // look for dynamic decorators in this class and in derived classes
                     QList<QObject*> decoObjects;
                     recursiveCollectDecoratorObjects(decoObjects);
                     foreach(QObject* deco, decoObjects) {
                       // call on ourself for caching, but with different metaObject():
                       found = lookForEnumAndCache(deco->metaObject(), memberName);
                       if (found) {
                         break;
                       }
                     }
                   }
                 }
                 if (!found) {
                   // maybe it is an enum wrapper?
                   PyObject* p = findEnumWrapper(memberName);
                   if (p) {
                     info._type = PythonQtMemberInfo::EnumWrapper;
                     info._enumWrapper = p;
                     _cachedMembers.insert(memberName, info);
                     found = true;
                   }
                 }
                 if (!found) {
                   // since python keywords can not be looked up, we check if the name contains a single trailing _
                   // and remove that and look again, so that we e.g. find exec on an exec_ lookup
                   QByteArray mbrName(memberName);
                   if ((mbrName.length()>2) &&
                       (mbrName.at(mbrName.length()-1) == '_') &&
                       (mbrName.at(mbrName.length()-2) != '_')) {
                     mbrName = mbrName.mid(0,mbrName.length()-1);
                     found = lookForMethodAndCache(mbrName.constData());
                     if (found) {
                       return _cachedMembers.value(mbrName);
                     }
                   }
                 }
                 if (!found) {
                   // we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)
                   info._type = PythonQtMemberInfo::NotFound;
                   _cachedMembers.insert(memberName, info);
                 }
               }
               return _cachedMembers.value(memberName);
             }
             void PythonQtClassInfo::recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects) {
               QObject* deco = decorator();
               if (deco) {
                 decoratorObjects.append(deco);
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 info._parent->recursiveCollectDecoratorObjects(decoratorObjects);
               }
             }
             void PythonQtClassInfo::recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects) {
               classInfoObjects.append(this);
               foreach(const ParentClassInfo& info, _parentClasses) {
                 info._parent->recursiveCollectClassInfos(classInfoObjects);
               }
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
             {
               QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
               while (it.hasNext()) {
                 PythonQtSlotInfo* infoOrig = it.next();
                 const char* sigStart = infoOrig->metaMethod()->signature();
                 if (qstrncmp("static_", sigStart, 7)==0) {
                   sigStart += 7;
                   sigStart += findCharOffset(sigStart, '_')+1;
                 }
                 int offset = findCharOffset(sigStart, '(');
                 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                   //make a copy, otherwise we will have trouble on overloads!
                   PythonQtSlotInfo* info = new PythonQtSlotInfo(*infoOrig);
                   info->setUpcastingOffset(upcastingOffset);
                   found = true;
                   if (tail) {
                     tail->setNextInfo(info);
                   } else {
                     PythonQtMemberInfo newInfo(info);
                     memberCache.insert(memberName, newInfo);
                   }
                   tail = info;
                 }
               }
               return tail;
             }
             void PythonQtClassInfo::listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly) {
               QObject* decoratorProvider = decorator();
               if (decoratorProvider) {
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       continue;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       continue;
+                    } else if (qstrncmp(sigStart, "py_", 3)==0) {
+                      // hide everything that starts with py_
+                      continue;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     if (!metaOnly || isClassDeco) {
                       list << QString::fromLatin1(sigStart, offset);
                     }
                   }
                 }
               }
               // look for global decorator slots
               QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
               while (it.hasNext()) {
                 PythonQtSlotInfo* slot = it.next();
                 if (metaOnly) {
                   if (slot->isClassDecorator()) {
                     QByteArray first = slot->slotName();
                     if (first.startsWith("static_")) {
                       int idx = first.indexOf('_');
                       idx = first.indexOf('_', idx+1);
                       first = first.mid(idx+1);
                     }
                     list << first;
                   }
                 } else {
                   list << slot->slotName();
                 }
               }
             }
             QStringList PythonQtClassInfo::propertyList()
             {
               QStringList l;
               if (_isQObject && _meta) {
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   l << QString(p.name());
                 }
               }
               return l;
             }
             QStringList PythonQtClassInfo::memberList(bool metaOnly)
             {
               decorator();
               QStringList l;
               QString h;
               if (_isQObject && _meta && !metaOnly) {
                 l = propertyList();
               }
               // normal slots of QObject (or wrapper QObject)
               if (!metaOnly && _meta) {
                 int numMethods = _meta->methodCount();
                 bool skipQObj = !_isQObject;
                 for (int i = skipQObj?QObject::staticMetaObject.methodCount():0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if (((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
                       || m.methodType()==QMetaMethod::Signal) {
                     QByteArray signa(m.signature());
                     signa = signa.left(signa.indexOf('('));
                     l << signa;
                   }
                 }
               }
               {
                 // look for dynamic decorators in this class and in derived classes
                 QList<PythonQtClassInfo*> infos;
                 recursiveCollectClassInfos(infos);
                 foreach(PythonQtClassInfo* info, infos) {
                   info->listDecoratorSlotsFromDecoratorProvider(l, metaOnly);
                 }
               }
               // List enumerator keys...
               QList<const QMetaObject*> enumMetaObjects;
               if (_meta) {
                 enumMetaObjects << _meta;
               }
               // check enums in the class hierachy of CPP classes
               QList<QObject*> decoObjects;
               recursiveCollectDecoratorObjects(decoObjects);
               foreach(QObject* deco, decoObjects) {
                 enumMetaObjects << deco->metaObject();
               }
               foreach(const QMetaObject* meta, enumMetaObjects) {
                 for (int i = 0; i<meta->enumeratorCount(); i++) {
                   QMetaEnum e = meta->enumerator(i);
                   l << e.name();
                   // we do not want flags, they will cause our values to appear two times
                   if (e.isFlag()) continue;
                   for (int j=0; j < e.keyCount(); j++) {
                     l << QString(e.key(j));
                   }
                 }
               }
               return QSet<QString>::fromList(l).toList();
             }
             const char* PythonQtClassInfo::className()
             {
               return _wrappedClassName.constData();
             }
             void* PythonQtClassInfo::castTo(void* ptr, const char* classname)
             {
               if (ptr==NULL) {
                 return NULL;
               }
               if (_wrappedClassName == classname) {
                 return ptr;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 void* result = info._parent->castTo((char*)ptr + info._upcastingOffset, classname);
                 if (result) {
                   return result;
                 }
               }
               return NULL;
             }
             bool PythonQtClassInfo::inherits(const char* name)
             {
               if (_wrappedClassName == name) {
                 return true;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (info._parent->inherits(name)) {
                   return true;
                 }
               }
               return false;
             }
             bool PythonQtClassInfo::inherits(PythonQtClassInfo* classInfo)
             {
               if (classInfo == this) {
                 return true;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (info._parent->inherits(classInfo)) {
                   return true;
                 }
               }
               return false;
             }
             QString PythonQtClassInfo::help()
             {
               decorator();
               QString h;
               h += QString("--- ") + QString(className()) + QString(" ---\n");
               if (_isQObject) {
                 h += "Properties:\n";
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   h += QString(p.name()) + " (" + QString(p.typeName()) + " )\n";
                 }
               }
               if (constructors()) {
                 h += "Constructors:\n";
                 PythonQtSlotInfo* constr = constructors();
                 while (constr) {
                   h += constr->fullSignature() + "\n";
                   constr = constr->nextInfo();
                 }
               }
               h += "Slots:\n";
               h += "QString help()\n";
               h += "QString className()\n";
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 for (int i = 0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     PythonQtSlotInfo slot(this, m, i);
                     h += slot.fullSignature()+ "\n";
                   }
                 }
               }
               // TODO xxx : decorators and enums from decorator() are missing...
               // maybe we can reuse memberlist()?
               if (_meta && _meta->enumeratorCount()) {
                 h += "Enums:\n";
                 for (int i = 0; i<_meta->enumeratorCount(); i++) {
                   QMetaEnum e = _meta->enumerator(i);
                   h += QString(e.name()) + " {";
                   for (int j=0; j < e.keyCount(); j++) {
                     if (j) { h+= ", "; }
                     h += e.key(j);
                   }
                   h += " }\n";
                 }
               }
               if (_isQObject && _meta) {
                 int numMethods = _meta->methodCount();
                 if (numMethods>0) {
                   h += "Signals:\n";
                   for (int i = 0; i < numMethods; i++) {
                     QMetaMethod m = _meta->method(i);
                     if (m.methodType() == QMetaMethod::Signal) {
                       h += QString(m.signature()) + "\n";
                     }
                   }
                 }
               }
               return h;
             }
             PythonQtSlotInfo* PythonQtClassInfo::constructors()
             {
               if (!_constructors) {
                 // force creation of lazy decorator, which will register the decorators
                 decorator();
               }
               return _constructors;
             }
             PythonQtSlotInfo* PythonQtClassInfo::destructor()
             {
               if (!_destructor) {
                 // force creation of lazy decorator, which will register the decorators
                 decorator();
               }
               return _destructor;
             }
             void PythonQtClassInfo::addConstructor(PythonQtSlotInfo* info)
             {
               PythonQtSlotInfo* prev = constructors();
               if (prev) {
                 info->setNextInfo(prev->nextInfo());
                 prev->setNextInfo(info);
               } else {
                 _constructors = info;
               }
             }
             void PythonQtClassInfo::addDecoratorSlot(PythonQtSlotInfo* info)
             {
               _decoratorSlots.append(info);
             }
             void PythonQtClassInfo::setDestructor(PythonQtSlotInfo* info)
             {
               if (_destructor) {
                 _destructor->deleteOverloadsAndThis();
               }
               _destructor = info;
             }
             void PythonQtClassInfo::setMetaObject(const QMetaObject* meta)
             {
               _meta = meta;
               clearCachedMembers();
             }
             QObject* PythonQtClassInfo::decorator()
             {
               if (!_decoratorProvider && _decoratorProviderCB) {
                 _decoratorProvider = (*_decoratorProviderCB)();
                 if (_decoratorProvider) {
                   _decoratorProvider->setParent(PythonQt::priv());
                   // setup enums early, since they might be needed by the constructor decorators:
                   if (!_enumsCreated) {
                     createEnumWrappers();
                   }
                   PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
                 }
               }
               // check if enums need to be created and create them if they are not yet created
               if (!_enumsCreated) {
                 createEnumWrappers();
               }
               return _decoratorProvider;
             }
             bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
             {
-              PythonQtMemberInfo info = member("hasOwner");
+              PythonQtMemberInfo info = member("py_hasOwner");
               if (info._type == PythonQtMemberInfo::Slot) {
                 void* obj = object;
                 bool result = false;
                 void* args[2];
                 args[0] = &result;
                 args[1] = &obj;
                 info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                 return !result;
               } else {
                 return false;
               }
             }
             void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, char** resultClassName)
             {
               if (!_polymorphicHandlers.isEmpty()) {
                 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
                   void* resultPtr = (*cb)(ptr, resultClassName);
                   if (resultPtr) {
                     return resultPtr;
                   }
                 }
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (!info._parent->isQObject()) {
                   void* resultPtr = info._parent->recursiveCastDownIfPossible((char*)ptr + info._upcastingOffset, resultClassName);
                   if (resultPtr) {
                     return resultPtr;
                   }
                 }
               }
               return NULL;
             }
             void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo)
             {
               char* className;
               // this would do downcasting recursively...
               // void* resultPtr = recursiveCastDownIfPossible(ptr, &className);
               // we only do downcasting on the base object, not on the whole inheritance tree...
               void* resultPtr = NULL;
               if (!_polymorphicHandlers.isEmpty()) {
                 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
                   resultPtr = (*cb)(ptr, &className);
                   if (resultPtr) {
                     break;
                   }
                 }
               }
               if (resultPtr) {
                 *resultClassInfo = PythonQt::priv()->getClassInfo(className);
               } else {
                 *resultClassInfo = this;
                 resultPtr = ptr;
               }
               return resultPtr;
             }
             PyObject* PythonQtClassInfo::findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum)
             {
               if (isLocalEnum) {
                 *isLocalEnum = true;
               }
               int scopePos = name.lastIndexOf("::");
               if (scopePos != -1) {
                 if (isLocalEnum) {
                   *isLocalEnum = false;
                 }
                 // split into scope and enum name
                 QByteArray enumScope = name.mid(0,scopePos);
                 QByteArray enumName = name.mid(scopePos+2);
                 PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(enumScope);
                 if (info) {
                   return info->findEnumWrapper(enumName);
                 } else{
                   return NULL;
                 }
               }
               if (localScope) {
                 return localScope->findEnumWrapper(name);
               } else {
                 return NULL;
               }
             }
             void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)
             {
               for (int i = meta->enumeratorOffset();i<meta->enumeratorCount();i++) {
                 QMetaEnum e = meta->enumerator(i);
                 PythonQtObjectPtr p;
                 p.setNewRef(PythonQtPrivate::createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
                 _enumWrappers.append(p);
               }
             }
             void PythonQtClassInfo::createEnumWrappers()
             {
               if (!_enumsCreated) {
                 _enumsCreated = true;
                 if (_meta) {
                   createEnumWrappers(_meta);
                 }
                 if (decorator()) {
                   createEnumWrappers(decorator()->metaObject());
                 }
                 foreach(const ParentClassInfo& info, _parentClasses) {
                   info._parent->createEnumWrappers();
                 }
               }
             }
             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) {
                   return p.object();
                 }
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 PyObject* p = info._parent->findEnumWrapper(name);
                 if (p) return p;
               }
               return NULL;
             }

src/PythonQtClassInfo.h +1 -1

             #ifndef _PYTHONQTCLASSINFO_H
             #define _PYTHONQTCLASSINFO_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             #include <QMetaObject>
             #include <QMetaMethod>
             #include <QHash>
             #include <QByteArray>
             #include <QList>
             #include "PythonQt.h"
             class PythonQtSlotInfo;
             struct PythonQtMemberInfo {
               enum Type {
                 Invalid, Slot, EnumValue, EnumWrapper, Property, NotFound
               };
               PythonQtMemberInfo():_type(Invalid),_slot(NULL),_enumWrapper(NULL),_enumValue(0) { }
               PythonQtMemberInfo(PythonQtSlotInfo* info) {
                 _type = Slot;
                 _slot = info;
                 _enumValue = NULL;
               }
               PythonQtMemberInfo(const PythonQtObjectPtr& enumValue) {
                 _type = EnumValue;
                 _slot = NULL;
                 _enumValue = enumValue;
                 _enumWrapper = NULL;
               }
               PythonQtMemberInfo(const QMetaProperty& prop) {
                 _type = Property;
                 _slot = NULL;
                 _enumValue = NULL;
                 _property = prop;
                 _enumWrapper = NULL;
               }
               Type              _type;
               // TODO: this could be a union...
               PythonQtSlotInfo* _slot;
               PyObject*         _enumWrapper;
               PythonQtObjectPtr _enumValue;
               QMetaProperty     _property;
             };
             //! a class that stores all required information about a Qt object (and an optional associated C++ class name)
             /*! for fast lookup of slots when calling the object from Python
             */
             class PythonQtClassInfo {
             public:
               PythonQtClassInfo();
               ~PythonQtClassInfo();
               //! store information about parent classes
               struct ParentClassInfo {
                 ParentClassInfo(PythonQtClassInfo* parent, int upcastingOffset=0):_parent(parent),_upcastingOffset(upcastingOffset)
                 {};
                 PythonQtClassInfo* _parent;
                 int                _upcastingOffset;
               };
               //! setup as a QObject, taking the meta object as meta information about the QObject
               void setupQObject(const QMetaObject* meta);
               //! setup as a CPP (non-QObject), taking the classname
               void setupCPPObject(const QByteArray& classname);
               //! get the Python method definition for a given slot name (without return type and signature)
               PythonQtMemberInfo member(const char* member);
               //! get access to the constructor slot (which may be overloaded if there are multiple constructors)
               PythonQtSlotInfo* constructors();
               //! get access to the destructor slot
               PythonQtSlotInfo* destructor();
               //! add a constructor, ownership is passed to classinfo
               void addConstructor(PythonQtSlotInfo* info);
               //! set a destructor, ownership is passed to classinfo
               void setDestructor(PythonQtSlotInfo* info);
               //! add a decorator slot, ownership is passed to classinfo
               void addDecoratorSlot(PythonQtSlotInfo* info);
               //! get the classname (either of the QObject or of the wrapped CPP object)
               const char* className();
               //! returns if the QObject
               bool isQObject() { return _isQObject; }
               //! returns if the class is a CPP wrapper
               bool isCPPWrapper() { return !_isQObject; }
               //! get the meta object
               const QMetaObject* metaObject() { return _meta; }
               //! set the meta object, this will reset the caching
               void setMetaObject(const QMetaObject* meta);
               //! returns if this class inherits from the given classname
               bool inherits(const char* classname);
               //! returns if this class inherits from the given classinfo
               bool inherits(PythonQtClassInfo* info);
               //! casts the given \c ptr to an object of type \c classname, returns the new pointer
               //! which might be different to \c ptr due to C++ multiple inheritance
               //! (if the cast is not possible or if ptr is NULL, NULL is returned)
               void* castTo(void* ptr, const char* classname);
               //! get help string for the metaobject
               QString help();
               //! get list of all properties (on QObjects only, otherwise the list is empty)
               QStringList propertyList();
               //! get list of all members
               QStringList memberList(bool metaOnly = false);
               //! get the meta type id of this class (only valid for isCPPWrapper() == true)
               int metaTypeId() { return _metaTypeId; }
               //! set an additional decorator provider that offers additional decorator slots for this class
               void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb) { _decoratorProviderCB = cb; _decoratorProvider = NULL; }
               //! get the decorator qobject instance
               QObject* decorator();
               //! add the parent class info of a CPP object
               void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
-              //! check if the special method "hasOwner" is implemented and if it returns false, which means that the object may be destroyed
+              //! check if the special method "py_hasOwner" is implemented and if it returns false, which means that the object may be destroyed
               bool hasOwnerMethodButNoOwner(void* object);
               //! set the associated PythonQtClassWrapper (which handles instance creation of this type)
               void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
               //! get the associated PythonQtClassWrapper (which handles instance creation of this type)
               PyObject* pythonQtClassWrapper() { return _pythonQtClassWrapper; }
               //! set the shell set instance wrapper cb
               void setShellSetInstanceWrapperCB(PythonQtShellSetInstanceWrapperCB* cb) {
                 _shellSetInstanceWrapperCB = cb;
               }
               //! get the shell set instance wrapper cb
               PythonQtShellSetInstanceWrapperCB* shellSetInstanceWrapperCB() {
                 return _shellSetInstanceWrapperCB;
               }
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(PythonQtPolymorphicHandlerCB* cb) { _polymorphicHandlers.append(cb); }
               //! 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 PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);
             private:
               void createEnumWrappers();
               void createEnumWrappers(const QMetaObject* meta);
               PyObject* findEnumWrapper(const char* name);
               //! clear all cached members
               void clearCachedMembers();
               void* recursiveCastDownIfPossible(void* ptr, char** resultClassName);
               PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
               PythonQtSlotInfo* recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               void recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects);
               void recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects);
               bool lookForPropertyAndCache(const char* memberName);
               bool lookForMethodAndCache(const char* memberName);
               bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
               PythonQtSlotInfo* findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               int findCharOffset(const char* sigStart, char someChar);
               QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
               PythonQtSlotInfo*                    _constructors;
               PythonQtSlotInfo*                    _destructor;
               QList<PythonQtSlotInfo*>             _decoratorSlots;
               QList<PythonQtObjectPtr>             _enumWrappers;
               const QMetaObject*                   _meta;
               QByteArray                           _wrappedClassName;
               QList<ParentClassInfo>               _parentClasses;
               QList<PythonQtPolymorphicHandlerCB*> _polymorphicHandlers;
               QObject*                             _decoratorProvider;
               PythonQtQObjectCreatorFunctionCB*    _decoratorProviderCB;
               PyObject*                            _pythonQtClassWrapper;
               PythonQtShellSetInstanceWrapperCB*   _shellSetInstanceWrapperCB;
               int                                  _metaTypeId;
               bool                                 _isQObject;
               bool                                 _enumsCreated;
             };
             //---------------------------------------------------------------
             #endif

src/PythonQtInstanceWrapper.cpp +42 -12

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtInstanceWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtInstanceWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             #include "PythonQtClassWrapper.h"
             PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
             {
               // take the class info from our type object
               return ((PythonQtClassWrapper*)ob_type)->_classInfo;
             }
             static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
               // is this a C++ wrapper?
               if (self->_wrappedPtr) {
                 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
                 // we own our qobject, so we delete it now:
                 delete self->_obj;
                 self->_obj = NULL;
                 if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
                   int type = self->classInfo()->metaTypeId();
                   if (self->_useQMetaTypeDestroy && type>=0) {
                     // use QMetaType to destroy the object
                     QMetaType::destroy(type, self->_wrappedPtr);
                   } else {
                     PythonQtSlotInfo* slot = self->classInfo()->destructor();
                     if (slot) {
                       void* args[2];
                       args[0] = NULL;
                       args[1] = &self->_wrappedPtr;
                       slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
                       self->_wrappedPtr = NULL;
                     } else {
                       if (type>=0) {
                         // use QMetaType to destroy the object
                         QMetaType::destroy(type, self->_wrappedPtr);
                       } else {
                         // TODO: warn about not being able to destroy the object?
                       }
                     }
                   }
                 }
               } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 if (self->_objPointerCopy) {
                   PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
                 }
                 if (self->_obj) {
                   if (force || self->_ownedByPythonQt) {
                     if (force || !self->_obj->parent()) {
                       delete self->_obj;
                     }
                   } else {
                     if (self->_obj->parent()==NULL) {
                       // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
                       PythonQt::qObjectNoLongerWrappedCB(self->_obj);
                     }
                   }
                 }
               }
               self->_obj = NULL;
             }
             static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
             {
               PythonQtInstanceWrapper_deleteObject(self);
               self->_obj.~QPointer<QObject>();
               self->ob_type->tp_free((PyObject*)self);
             }
             static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               //PythonQtClassWrapper    *classType = (PythonQtClassWrapper*)type;
               PythonQtInstanceWrapper *self;
               static PyObject* emptyTuple = NULL;
               if (emptyTuple==NULL) {
                 emptyTuple = PyTuple_New(0);
               }
               self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL);
               if (self != NULL) {
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
                 self->_useQMetaTypeDestroy = false;
                 self->_isShellInstance = false;
               }
               return (PyObject *)self;
             }
             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
             {
               if (args == PythonQtPrivate::dummyTuple()) {
                 // we are called from the internal PythonQt API, so our data will be filled later on...
                 return 0;
               }
               // we are called from python, try to construct our object
               if (self->classInfo()->constructors()) {
                 void* directCPPPointer = NULL;
                 PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
                 if (PyErr_Occurred()) {
                   return -1;
                 }
                 if (directCPPPointer) {
                   // change ownershipflag to be owned by PythonQt
                   self->_ownedByPythonQt = true;
                   self->_useQMetaTypeDestroy = false;
                   if (self->classInfo()->isCPPWrapper()) {
                     self->_wrappedPtr = directCPPPointer;
                     // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
                   } else {
                     self->setQObject((QObject*)directCPPPointer);
                   }
                   // register with PythonQt
                   PythonQt::priv()->addWrapperPointer(directCPPPointer, self);
                   PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB();
                   if (cb) {
                     // if we are a derived python class, we set the wrapper
                     // to activate the shell class, otherwise we just ignore that it is a shell...
                     // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class,
                     // which is the case for all non-python derived types
                     if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                       // set the wrapper and remember that we have a shell instance!
                       (*cb)(directCPPPointer, self);
                       self->_isShellInstance = true;
                     }
                   }
                 }
               } else {
                 QString error = QString("No constructors available for ") + self->classInfo()->className();
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return -1;
               }
               return 0;
             }
             static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
             {
               return PyString_FromString(obj->ob_type->tp_name);
             }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
             {
               return PythonQt::self()->helpCalled(obj->classInfo());
             }
             static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
             {
               PythonQtInstanceWrapper_deleteObject(self, true);
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyMethodDef PythonQtInstanceWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
                 "Deletes the C++ object (at your own risk, my friend!)"
                 },
             {NULL, NULL, 0, NULL}  /* Sentinel */
             };
             static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name);
                 dict = PyDict_Copy(dict);
                 if (wrapper->_obj) {
                   // only the properties are missing, the rest is already available from
                   // PythonQtClassWrapper...
                   QStringList l = wrapper->classInfo()->propertyList();
                   foreach (QString name, l) {
                     PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                     if (o) {
                       PyDict_SetItemString(dict, name.toLatin1().data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data();
                     }
                   }
                   QList<QByteArray>	dynamicProps = wrapper->_obj->dynamicPropertyNames();
                   foreach (QByteArray name, dynamicProps) {
                     PyObject* o = PyObject_GetAttrString(obj, name.data());
                     if (o) {
                       PyDict_SetItemString(dict, name.data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: dynamic property could not be read " << name.data();
                     }
                   }
                 }
                 // Note: we do not put children into the dict, is would look confusing?!
                 return dict;
               }
               // first look in super, to return derived methods from base object first
               PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name);
               if (superAttr) {
                 return superAttr;
               }
               PyErr_Clear();
               //  mlabDebugConst("Python","get " << attributeName);
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wrapper->_obj) {
                   if (member._property.userType() != QVariant::Invalid) {
                     return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                   } else {
                     Py_INCREF(Py_None);
                     return Py_None;
                   }
                 } else {
                   QString error = QString("Trying to read property '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   return NULL;
                 }
                 break;
               case PythonQtMemberInfo::Slot:
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
                 {
                   PyObject* enumValue = member._enumValue;
                   Py_INCREF(enumValue);
                   return enumValue;
                 }
                 break;
               case PythonQtMemberInfo::EnumWrapper:
                 {
                   PyObject* enumWrapper = member._enumWrapper;
                   Py_INCREF(enumWrapper);
                   return enumWrapper;
                 }
                 break;
               case PythonQtMemberInfo::NotFound:
                 {
-                  // check for a getter_
+                  static const QByteArray getterString("py_get_");
-                  PythonQtMemberInfo member = wrapper->classInfo()->member(QByteArray("getter_") + attributeName);
+                  // check for a getter slot
+                  PythonQtMemberInfo member = wrapper->classInfo()->member(getterString + attributeName);
                   if (member._type == PythonQtMemberInfo::Slot) {
                     return PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, member._slot, NULL, NULL, wrapper->_wrappedPtr);
                   }
                   // handle dynamic properties
                   if (wrapper->_obj) {
                     QVariant v = wrapper->_obj->property(attributeName);
                     if (v.isValid()) {
                       return PythonQtConv::QVariantToPyObject(v);
                     }
                   }
                 }
                 break;
               default:
                 // is an invalid type, go on
                 break;
               }
               // look for the internal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (wrapper->_obj) {
                 // look for a child
                 QObjectList children = wrapper->_obj->children();
                 for (int i = 0; i < children.count(); i++) {
                   QObject *child = children.at(i);
                   if (child->objectName() == attributeName) {
                     return PythonQt::priv()->wrapQObject(child);
                   }
                 }
               }
               QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               QString error;
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 return -1;
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               if (member._type == PythonQtMemberInfo::Property) {
                 if (!wrapper->_obj) {
                   error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                   return -1;
                 }
                 QMetaProperty prop = member._property;
                 if (prop.isWritable()) {
                   QVariant v;
                   if (prop.isEnumType()) {
                     // this will give us either a string or an int, everything else will probably be an error
                     v = PythonQtConv::PyObjToQVariant(value);
                   } else {
                     int t = prop.userType();
                     v = PythonQtConv::PyObjToQVariant(value, t);
                   }
                   bool success = false;
                   if (v.isValid()) {
                     success = prop.write(wrapper->_obj, v);
                   }
                   if (success) {
                     return 0;
                   } else {
                     error = QString("Property '") + attributeName + "' of type '" +
                       prop.typeName() + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                   }
                 } else {
                   error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable";
                 }
               } else if (member._type == PythonQtMemberInfo::Slot) {
                 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) {
-                // check for a setter_
+                // check for a setter slot
-                PythonQtMemberInfo setter = wrapper->classInfo()->member(QByteArray("setter_") + attributeName);
+                static const QByteArray setterString("py_set_");
+                PythonQtMemberInfo setter = wrapper->classInfo()->member(setterString + attributeName);
                 if (setter._type == PythonQtMemberInfo::Slot) {
                   // call the setter and ignore the result value
                   void* result;
                   PyObject* args = PyTuple_New(1);
                   Py_INCREF(value);
                   PyTuple_SET_ITEM(args, 0, value);
                   PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, setter._slot, args, NULL, wrapper->_wrappedPtr, &result);
                   Py_DECREF(args);
                   return 0;
                 }
                 // handle dynamic properties
                 if (wrapper->_obj) {
                   QVariant prop = wrapper->_obj->property(attributeName);
                   if (prop.isValid()) {
                     QVariant v = PythonQtConv::PyObjToQVariant(value);
                     if (v.isValid()) {
                       wrapper->_obj->setProperty(attributeName, v);
                       return 0;
                     } else {
                       error = QString("Dynamic property '") + attributeName + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                       PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                       return -1;
                     }
                   }
                 }
                 // if we are a derived python class, we allow setting attributes.
                 // if we are a direct CPP wrapper, we do NOT allow it, since
                 // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore
                 // and when it is recreated from a CPP pointer the attributes are gone...
                 if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                   return PyBaseObject_Type.tp_setattro(obj,name,value);
                 } else {
                   error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
+            static QString getStringFromObject(PythonQtInstanceWrapper* wrapper) {
+              QString result;
+              if (wrapper->_wrappedPtr) {
+                // first try some manually string conversions for some variants
+                int metaid = wrapper->classInfo()->metaTypeId();
+                result = PythonQtConv::CPPObjectToString(metaid, wrapper->_wrappedPtr);
+                if (!result.isEmpty()) {
+                  return result;
+                }
+              }
+              // next, try to call py_toString
+              PythonQtMemberInfo info = wrapper->classInfo()->member("py_toString");
+              if (info._type == PythonQtMemberInfo::Slot) {
+                PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, info._slot, NULL, NULL, wrapper->_wrappedPtr);
+                if (resultObj) {
+                  // TODO this is one conversion too much, would be nicer to call the slot directly...
+                  result = PythonQtConv::PyObjGetString(resultObj);
+                  Py_DECREF(resultObj);
+                }
+              }
+              return result;
+            }
             static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
+              QString str = getStringFromObject(wrapper);
+              if (!str.isEmpty()) {
+                return PyString_FromFormat("%s", str.toLatin1().constData());
+              }
               if (wrapper->_wrappedPtr) {
-                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
-                if (!str.isEmpty()) {
-                  return PyString_FromFormat("%s", str.toLatin1().constData());
-                } else
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
               }
             }
             static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
-              if (wrapper->_wrappedPtr) {
+              QString str = getStringFromObject(wrapper);
-                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
+              if (!str.isEmpty()) {
-                if (!str.isEmpty()) {
+                if (str.startsWith(typeName)) {
+                  return PyString_FromFormat("%s", str.toLatin1().constData());
+                } else {
                   return PyString_FromFormat("%s(%s, %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr);
-                } else
+              }
+              if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (%s %p)", typeName, wrapper->classInfo()->className(), qobj);
               }
             }
             static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (PyObject_TypeCheck(obj1, &PythonQtInstanceWrapper_Type) &&
                 PyObject_TypeCheck(obj2, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
                 PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
                 // check pointers directly first:
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w2->_wrappedPtr) {
                     return 0;
                   }
                 } else if (w1->_obj == w2->_obj) {
                   return 0;
                 }
                 const char* class1 = w1->classInfo()->className();
                 const char* class2 = w2->classInfo()->className();
                 if (strcmp(class1, class2) == 0) {
                   // same class names, so we can try the operator_equal
                   PythonQtMemberInfo info = w1->classInfo()->member("operator_equal");
                   if (info._type == PythonQtMemberInfo::Slot) {
                     bool result = false;
                     void* obj1 = w1->_wrappedPtr;
                     if (!obj1) {
                       obj1 = w1->_obj;
                     }
                     if (!obj1) { return -1; }
                     void* obj2 = w2->_wrappedPtr;
                     if (!obj2) {
                       obj2 = w2->_obj;
                     }
                     if (!obj2) { return -1; }
                     if (info._slot->isInstanceDecorator()) {
                       // call on decorator QObject
                       void* args[3];
                       args[0] = &result;
                       args[1] = &obj1; // this is a pointer, so it needs a pointer to a pointer
                       args[2] = obj2;  // this is a reference, so it needs the direct pointer
                       info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       return result?0:-1;
                     } else {
                       // call directly on QObject
                       if (w1->_obj && w2->_obj) {
                         void* args[2];
                         args[0] = &result;
                         args[1] = obj2;  // this is a reference, so it needs the direct pointer
                         w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
+                        return result?0:-1;
                       }
                     }
                   }
                 }
               }
               return -1;
             }
             static int PythonQtInstanceWrapper_nonzero(PyObject *obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
             }
             static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
             {
               if (obj->_wrappedPtr != NULL) {
                 return reinterpret_cast<long>(obj->_wrappedPtr);
               } else {
                 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
                 return reinterpret_cast<long>(qobj);
               }
             }
             // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
             static PyNumberMethods PythonQtInstanceWrapper_as_number = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_divide */
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
                 PythonQtInstanceWrapper_nonzero,      /* nb_nonzero */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,    /* nb_and */
 ,    /* nb_xor */
 ,    /* nb_or */
 ,      /* nb_coerce */
 ,      /* nb_int */
 ,      /* nb_long */
 ,      /* nb_float */
 ,      /* nb_oct */
 ,      /* nb_hex */
 ,      /* nb_inplace_add */
 ,      /* nb_inplace_subtract */
 ,      /* nb_inplace_multiply */
 ,      /* nb_inplace_divide */
 ,      /* nb_inplace_remainder */
 ,      /* nb_inplace_power */
 ,      /* nb_inplace_lshift */
 ,      /* nb_inplace_rshift */
 ,      /* nb_inplace_and */
 ,      /* nb_inplace_xor */
 ,      /* nb_inplace_or */
 ,      /* nb_floor_divide */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
             };
             PyTypeObject PythonQtInstanceWrapper_Type = {
                 PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
                 sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtInstanceWrapper_compare,         /*tp_compare*/
                 PythonQtInstanceWrapper_repr,            /*tp_repr*/
                 &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtInstanceWrapper_str,      /*tp_str*/
                 PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
                 PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
 ,             /* tp_methods */
 ,             /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtInstanceWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

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