GIT_REPOSITORIES/LPP/PythonQt Commit - r119:609e1e5898f0

added support for operators and rich compare...

florianlink -

r119:609e1e5898f0

parent child

Context file:

r119:609e1e5898f0

Collapse all files

generator/abstractmetabuilder.cpp +7 -7

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $QT_BEGIN_LICENSE:LGPL$
             ** No Commercial Usage
             ** This file contains pre-release code and may not be distributed.
             ** You may use this file in accordance with the terms and conditions
             ** contained in the Technology Preview License Agreement accompanying
             ** this package.
             **
             ** GNU Lesser General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU Lesser
             ** General Public License version 2.1 as published by the Free Software
             ** Foundation and appearing in the file LICENSE.LGPL included in the
             ** packaging of this file.  Please review the following information to
             ** ensure the GNU Lesser General Public License version 2.1 requirements
             ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
             **
             ** In addition, as a special exception, Nokia gives you certain additional
             ** rights.  These rights are described in the Nokia Qt LGPL Exception
             ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
             **
             ** If you have questions regarding the use of this file, please contact
             ** Nokia at qt-info@nokia.com.
             **
             **
             **
             **
             **
             **
             **
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "abstractmetabuilder.h"
             #include "reporthandler.h"
             #include "ast.h"
             #include "binder.h"
             #include "control.h"
             #include "default_visitor.h"
             #include "dumptree.h"
             #include "lexer.h"
             #include "parser.h"
             #include "tokens.h"
             #include <QtCore/QDebug>
             #include <QtCore/QFile>
             #include <QtCore/QFileInfo>
             #include <QtCore/QTextCodec>
             #include <QtCore/QTextStream>
             #include <QtCore/QVariant>
             static QString strip_template_args(const QString &name)
             {
                 int pos = name.indexOf('<');
                 return pos < 0 ? name : name.left(pos);
             }
             static QHash<QString, QString> *operator_names;
             QString rename_operator(const QString &oper)
             {
                 QString op = oper.trimmed();
                 if (!operator_names) {
                     operator_names = new QHash<QString, QString>;
                     operator_names->insert("+", "__add__");
                     operator_names->insert("-", "__sub__");
                     operator_names->insert("*", "__mul__");
                     operator_names->insert("/", "__div__");
                     operator_names->insert("%", "__mod__");
                     operator_names->insert("&", "__and__");
                     operator_names->insert("|", "__or__");
                     operator_names->insert("^", "__xor__");
-                    operator_names->insert("~", "__negate__");
+                    operator_names->insert("~", "__invert__");
                     operator_names->insert("<<", "__lshift__");
                     operator_names->insert(">>", "__rshift__");
                     // assigments
                     operator_names->insert("=", "assign");
                     operator_names->insert("+=", "__iadd__");
                     operator_names->insert("-=", "__isub__");
                     operator_names->insert("*=", "__imul__");
                     operator_names->insert("/=", "__idiv__");
                     operator_names->insert("%=", "__imod__");
                     operator_names->insert("&=", "__iand__");
                     operator_names->insert("|=", "__ior__");
                     operator_names->insert("^=", "__ixor__");
                     operator_names->insert("<<=", "__ilshift__");
                     operator_names->insert(">>=", "__irshift__");
                     // Logical
                     operator_names->insert("&&", "logical_and");
                     operator_names->insert("||", "logical_or");
                     operator_names->insert("!", "not");
                     // incr/decr
                     operator_names->insert("++", "increment");
                     operator_names->insert("--", "decrement");
                     // compare
-                    operator_names->insert("<", "less");
+                    operator_names->insert("<", "__lt__");
-                    operator_names->insert(">", "greater");
+                    operator_names->insert(">", "__gt__");
-                    operator_names->insert("<=", "less_or_equal");
+                    operator_names->insert("<=", "__le__");
-                    operator_names->insert(">=", "greater_or_equal");
+                    operator_names->insert(">=", "__ge__");
-                    operator_names->insert("!=", "not_equal");
+                    operator_names->insert("!=", "__ne__");
-                    operator_names->insert("==", "equal");
+                    operator_names->insert("==", "__eq__");
                     // other
                     operator_names->insert("[]", "subscript");
                     operator_names->insert("->", "pointer");
                 }
                 if (!operator_names->contains(op)) {
                     TypeDatabase *tb = TypeDatabase::instance();
                     TypeParser::Info typeInfo = TypeParser::parse(op);
                     QString cast_to_name = typeInfo.qualified_name.join("::");
                     TypeEntry *te = tb->findType(cast_to_name);
                     if ((te && te->codeGeneration() == TypeEntry::GenerateNothing)
                         || tb->isClassRejected(cast_to_name)) {
                         return QString();
                     } else if (te) {
                         return "operator_cast_" + typeInfo.qualified_name.join("_");
                     } else {
                         ReportHandler::warning(QString("unknown operator '%1'").arg(op));
                         return "operator " + op;
                     }
                 }
                 QString r = operator_names->value(op);
                 if (r.startsWith("__")) {
                   return r;
                 } else {
                   return "operator_" + r;
                 }
             }
             AbstractMetaBuilder::AbstractMetaBuilder()
                 : m_current_class(0)
             {
             }
             void AbstractMetaBuilder::checkFunctionModifications()
             {
                 TypeDatabase *types = TypeDatabase::instance();
                 SingleTypeEntryHash entryHash = types->entries();
                 QList<TypeEntry *> entries = entryHash.values();
                 foreach (TypeEntry *entry, entries) {
                     if (entry == 0)
                         continue;
                     if (!entry->isComplex() || entry->codeGeneration() == TypeEntry::GenerateNothing)
                         continue;
                     ComplexTypeEntry *centry = static_cast<ComplexTypeEntry *>(entry);
                     FunctionModificationList modifications = centry->functionModifications();
                     foreach (FunctionModification modification, modifications) {
                         QString signature = modification.signature;
                         QString name = signature.trimmed();
                         name = name.mid(0, signature.indexOf("("));
                         AbstractMetaClass *clazz = m_meta_classes.findClass(centry->qualifiedCppName());
                         if (clazz == 0)
                             continue;
                         AbstractMetaFunctionList functions = clazz->functions();
                         bool found = false;
                         QStringList possibleSignatures;
                         foreach (AbstractMetaFunction *function, functions) {
                             if (function->minimalSignature() == signature && function->implementingClass() == clazz) {
                                 found = true;
                                 break;
                             }
                             if (function->originalName() == name)
                                 possibleSignatures.append(function->minimalSignature() + " in " + function->implementingClass()->name());
                         }
                         if (!found) {
                             QString warning
                                 = QString("signature '%1' for function modification in '%2' not found. Possible candidates: %3")
                                     .arg(signature)
                                     .arg(clazz->qualifiedCppName())
                                     .arg(possibleSignatures.join(", "));
                             ReportHandler::warning(warning);
                         }
                     }
                 }
             }
             AbstractMetaClass *AbstractMetaBuilder::argumentToClass(ArgumentModelItem argument)
             {
                 AbstractMetaClass *returned = 0;
                 bool ok = false;
                 AbstractMetaType *type = translateType(argument->type(), &ok);
                 if (ok && type != 0 && type->typeEntry() != 0 && type->typeEntry()->isComplex()) {
                     const TypeEntry *entry = type->typeEntry();
                     returned = m_meta_classes.findClass(entry->name());
                 }
                 delete type;
                 return returned;
             }
             /**
              * Checks the argument of a hash function and flags the type if it is a complex type
              */
             void AbstractMetaBuilder::registerHashFunction(FunctionModelItem function_item)
             {
                 ArgumentList arguments = function_item->arguments();
                 if (arguments.size() == 1) {
                     if (AbstractMetaClass *cls = argumentToClass(arguments.at(0)))
                         cls->setHasHashFunction(true);
                 }
             }
             /**
              * Check if a class has a debug stream operator that can be used as toString
              */
             void AbstractMetaBuilder::registerToStringCapability(FunctionModelItem function_item)
             {
                 ArgumentList arguments = function_item->arguments();
                 if (arguments.size() == 2) {
                     if (arguments.at(0)->type().toString() == "QDebug"){
                         ArgumentModelItem arg = arguments.at(1);
                         if (AbstractMetaClass *cls = argumentToClass(arg)) {
                             if (arg->type().indirections() < 2 && cls->name()!="QObject") {
                                 cls->setToStringCapability(function_item);
                             }
                         }
                     }
                 }
             }
             void AbstractMetaBuilder::traverseCompareOperator(FunctionModelItem item) {
                 ArgumentList arguments = item->arguments();
                 if (arguments.size() == 2 && item->accessPolicy() == CodeModel::Public) {
                     AbstractMetaClass *comparer_class = argumentToClass(arguments.at(0));
                     AbstractMetaClass *compared_class = argumentToClass(arguments.at(1));
                     if (comparer_class != 0 && compared_class != 0) {
                         AbstractMetaClass *old_current_class = m_current_class;
                         m_current_class = comparer_class;
                         AbstractMetaFunction *meta_function = traverseFunction(item);
                         if (meta_function != 0 && !meta_function->isInvalid()) {
                             // Strip away first argument, since that is the containing object
                             AbstractMetaArgumentList arguments = meta_function->arguments();
                             arguments.pop_front();
                             meta_function->setArguments(arguments);
                             meta_function->setFunctionType(AbstractMetaFunction::GlobalScopeFunction);
                             meta_function->setOriginalAttributes(meta_function->attributes());
                             setupFunctionDefaults(meta_function, comparer_class);
                             comparer_class->addFunction(meta_function);
                         } else if (meta_function != 0) {
                             delete meta_function;
                         }
                         m_current_class = old_current_class;
                     }
                 }
             }
             void AbstractMetaBuilder::traverseStreamOperator(FunctionModelItem item)
             {
                 ArgumentList arguments = item->arguments();
                 if (arguments.size() == 2 && item->accessPolicy() == CodeModel::Public) {
                     AbstractMetaClass *streamClass = argumentToClass(arguments.at(0));
                     AbstractMetaClass *streamedClass = argumentToClass(arguments.at(1));
                     if (streamClass != 0 && streamedClass != 0
                         && (streamClass->name() == "QDataStream" || streamClass->name() == "QTextStream")) {
                         AbstractMetaClass *old_current_class = m_current_class;
                         m_current_class = streamedClass;
                         AbstractMetaFunction *streamFunction = traverseFunction(item);
                         if (streamFunction != 0 && !streamFunction->isInvalid()) {
                             QString name = item->name();
                             streamFunction->setFunctionType(AbstractMetaFunction::GlobalScopeFunction);
                             if (name.endsWith("<<"))
                                 streamFunction->setName("writeTo");
                             else
                                 streamFunction->setName("readFrom");
                             // Strip away last argument, since that is the containing object
                             AbstractMetaArgumentList arguments = streamFunction->arguments();
                             arguments.pop_back();
                             streamFunction->setArguments(arguments);
                             *streamFunction += AbstractMetaAttributes::Final;
                             *streamFunction += AbstractMetaAttributes::Public;
                             streamFunction->setOriginalAttributes(streamFunction->attributes());
                             streamFunction->setType(0);
                             setupFunctionDefaults(streamFunction, streamedClass);
                             streamedClass->addFunction(streamFunction);
                             streamedClass->typeEntry()->addExtraInclude(streamClass->typeEntry()->include());
                             m_current_class = old_current_class;
                         }
                     }
                 }
             }
             void AbstractMetaBuilder::traverseBinaryArithmeticOperator(FunctionModelItem item)
             {
               ArgumentList arguments = item->arguments();
               if (arguments.size() == 2 && item->accessPolicy() == CodeModel::Public) {
                 AbstractMetaClass *aClass = argumentToClass(arguments.at(0));
                 AbstractMetaClass *bClass = argumentToClass(arguments.at(1));
                 if (!aClass) return;
                 AbstractMetaClass *old_current_class = m_current_class;
                 m_current_class = aClass;
                 AbstractMetaFunction *streamFunction = traverseFunction(item);
                 if (streamFunction != 0 && !streamFunction->isInvalid()) {
                   QString name = rename_operator(item->name().mid(8));
                   if (name.isEmpty()) return;
                   streamFunction->setFunctionType(AbstractMetaFunction::GlobalScopeFunction);
                   streamFunction->setName(name);
                   // Strip away the first argument, since that is the operator object
                   AbstractMetaArgumentList arguments = streamFunction->arguments();
                   arguments.removeFirst();
                   streamFunction->setArguments(arguments);
                   *streamFunction += AbstractMetaAttributes::Final;
                   *streamFunction += AbstractMetaAttributes::Public;
                   streamFunction->setOriginalAttributes(streamFunction->attributes());
                   setupFunctionDefaults(streamFunction, aClass);
                   aClass->addFunction(streamFunction);
                   if (bClass) {
                     aClass->typeEntry()->addExtraInclude(bClass->typeEntry()->include());
                   }
                   m_current_class = old_current_class;
                 }
               }
             }
             void AbstractMetaBuilder::fixQObjectForScope(TypeDatabase *types,
             					 NamespaceModelItem scope)
             {
                 foreach (ClassModelItem item, scope->classes()) {
                     QString qualified_name = item->qualifiedName().join("::");
                     TypeEntry *entry = types->findType(qualified_name);
                     if (entry) {
             	    if (isQObject(qualified_name) && entry->isComplex()) {
                             ((ComplexTypeEntry *) entry)->setQObject(true);
             	    }
             	}
                 }
                 foreach (NamespaceModelItem item, scope->namespaceMap().values()) {
                     if (scope != item)
             	  fixQObjectForScope(types, item);
                 }
             }
             static bool class_less_than(AbstractMetaClass *a, AbstractMetaClass *b)
             {
                 return a->name() < b->name();
             }
             void AbstractMetaBuilder::sortLists()
             {
                qSort(m_meta_classes.begin(), m_meta_classes.end(), class_less_than);
                foreach (AbstractMetaClass *cls, m_meta_classes) {
                     cls->sortFunctions();
                }
             }
             bool AbstractMetaBuilder::build()
             {
                 Q_ASSERT(!m_file_name.isEmpty());
                 QFile file(m_file_name);
                 if (!file.open(QFile::ReadOnly))
                     return false;
                 QTextStream stream(&file);
                 stream.setCodec(QTextCodec::codecForName("UTF-8"));
                 QByteArray contents = stream.readAll().toUtf8();
                 file.close();
                 Control control;
                 Parser p(&control);
                 pool __pool;
                 TranslationUnitAST *ast = p.parse(contents, contents.size(), &__pool);
                 CodeModel model;
                 Binder binder(&model, p.location());
                 m_dom = binder.run(ast);
                 pushScope(model_dynamic_cast<ScopeModelItem>(m_dom));
                 QHash<QString, ClassModelItem> typeMap = m_dom->classMap();
                 // fix up QObject's in the type system..
                 TypeDatabase *types = TypeDatabase::instance();
                 fixQObjectForScope(types, model_dynamic_cast<NamespaceModelItem>(m_dom));
                 // Start the generation...
                 foreach (ClassModelItem item, typeMap.values()) {
                     AbstractMetaClass *cls = traverseClass(item);
                     addAbstractMetaClass(cls);
                 }
                 QHash<QString, NamespaceModelItem> namespaceMap = m_dom->namespaceMap();
                 foreach (NamespaceModelItem item, namespaceMap.values()) {
                     AbstractMetaClass *meta_class = traverseNamespace(item);
                     if (meta_class)
                         m_meta_classes << meta_class;
                 }
                 // Some trickery to support global-namespace enums...
                 QHash<QString, EnumModelItem> enumMap = m_dom->enumMap();
                 m_current_class = 0;
                 foreach (EnumModelItem item, enumMap) {
                     AbstractMetaEnum *meta_enum = traverseEnum(item, 0, QSet<QString>());
                     if (meta_enum) {
                         QString package = meta_enum->typeEntry()->javaPackage();
                         QString globalName = TypeDatabase::globalNamespaceClassName(meta_enum->typeEntry());
                         AbstractMetaClass *global = m_meta_classes.findClass(package + "." + globalName);
                         if (!global) {
                             ComplexTypeEntry *gte = new ObjectTypeEntry(globalName);
                             gte->setTargetLangPackage(meta_enum->typeEntry()->javaPackage());
                             gte->setCodeGeneration(meta_enum->typeEntry()->codeGeneration());
                             global = createMetaClass();
                             global->setTypeEntry(gte);
                             *global += AbstractMetaAttributes::Final;
                             *global += AbstractMetaAttributes::Public;
                             *global += AbstractMetaAttributes::Fake;
                             m_meta_classes << global;
                         }
                         global->addEnum(meta_enum);
                         meta_enum->setEnclosingClass(global);
                         meta_enum->typeEntry()->setQualifier(globalName);
                         // Global enums should be public despite not having public
                         // identifiers so we'll fix the original attributes here.
                         meta_enum->setOriginalAttributes(meta_enum->attributes());
                     }
                 }
                 // Go through all typedefs to see if we have defined any
                 // specific typedefs to be used as classes.
                 TypeAliasList typeAliases = m_dom->typeAliases();
                 foreach (TypeAliasModelItem typeAlias, typeAliases) {
                     AbstractMetaClass *cls = traverseTypeAlias(typeAlias);
                     addAbstractMetaClass(cls);
                 }
                 foreach (AbstractMetaClass *cls, m_meta_classes) {
                     if (!cls->isInterface() && !cls->isNamespace()) {
                         setupInheritance(cls);
                     }
                 }
                 foreach (AbstractMetaClass *cls, m_meta_classes) {
                     cls->fixFunctions();
                     if (cls->typeEntry() == 0) {
                         ReportHandler::warning(QString("class '%1' does not have an entry in the type system")
                                                .arg(cls->name()));
                     } else {
                         if (!cls->hasConstructors() && !cls->isFinalInCpp() && !cls->isInterface() && !cls->isNamespace())
                             cls->addDefaultConstructor();
                     }
                     if (cls->isAbstract() && !cls->isInterface()) {
                         cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + "$ConcreteWrapper");
                     }
                 }
                 QList<TypeEntry *> entries = TypeDatabase::instance()->entries().values();
                 foreach (const TypeEntry *entry, entries) {
                     if (entry->isPrimitive())
                         continue;
                     if ((entry->isValue() || entry->isObject())
                         && !entry->isString()
                         && !entry->isChar()
                         && !entry->isContainer()
                         && !entry->isCustom()
                         && !entry->isVariant()
                         && !m_meta_classes.findClass(entry->qualifiedCppName())) {
                         ReportHandler::warning(QString("type '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.")
                                                .arg(entry->qualifiedCppName()));
                     }
                     if (entry->isEnum()) {
                         QString pkg = entry->javaPackage();
                         QString name = (pkg.isEmpty() ? QString() : pkg + ".")
                                        + ((EnumTypeEntry *) entry)->javaQualifier();
                         AbstractMetaClass *cls = m_meta_classes.findClass(name);
                         if (!cls) {
                             ReportHandler::warning(QString("namespace '%1' for enum '%2' is not declared")
                                                    .arg(name).arg(entry->targetLangName()));
                         } else {
                             AbstractMetaEnum *e = cls->findEnum(entry->targetLangName());
                             if (!e)
                                 ReportHandler::warning(QString("enum '%1' is specified in typesystem, "
                                                                "but not declared")
                                                        .arg(entry->qualifiedCppName()));
                         }
                     }
                 }
                 {
                     FunctionList hash_functions = m_dom->findFunctions("qHash");
                     foreach (FunctionModelItem item, hash_functions) {
                         registerHashFunction(item);
                     }
                 }
                 {
                     FunctionList hash_functions = m_dom->findFunctions("operator<<");
                     foreach (FunctionModelItem item, hash_functions) {
                         registerToStringCapability(item);
                     }
                 }
                 {
                     FunctionList compare_operators = m_dom->findFunctions("operator==")
                                                      + m_dom->findFunctions("operator<=")
                                                      + m_dom->findFunctions("operator>=")
                                                      + m_dom->findFunctions("operator<")
                                                      + m_dom->findFunctions("operator>");
                     foreach (FunctionModelItem item, compare_operators) {
                         traverseCompareOperator(item);
                     }
                 }
                 {
                   FunctionList stream_operators =
                       m_dom->findFunctions("operator+") + m_dom->findFunctions("operator-")
                     + m_dom->findFunctions("operator/") + m_dom->findFunctions("operator*")
                     + m_dom->findFunctions("operator&") + m_dom->findFunctions("operator|")
                     + m_dom->findFunctions("operator%") + m_dom->findFunctions("operator^");
                   foreach (FunctionModelItem item, stream_operators) {
                     traverseBinaryArithmeticOperator(item);
                   }
                 }
                 {
                     FunctionList stream_operators = m_dom->findFunctions("operator<<") + m_dom->findFunctions("operator>>");
                     foreach (FunctionModelItem item, stream_operators) {
                         traverseStreamOperator(item);
                     }
                 }
                 figureOutEnumValues();
                 figureOutDefaultEnumArguments();
                 checkFunctionModifications();
                 foreach (AbstractMetaClass *cls, m_meta_classes) {
                     setupEquals(cls);
                     setupComparable(cls);
                     setupClonable(cls);
                 }
                 dumpLog();
                 sortLists();
                 return true;
             }
             void AbstractMetaBuilder::addAbstractMetaClass(AbstractMetaClass *cls)
             {
                 if (!cls)
                     return;
                 cls->setOriginalAttributes(cls->attributes());
                 if (cls->typeEntry()->isContainer()) {
                     m_templates << cls;
                 } else {
                     m_meta_classes << cls;
                     if (cls->typeEntry()->designatedInterface()) {
                         AbstractMetaClass *interface = cls->extractInterface();
                         m_meta_classes << interface;
                         ReportHandler::debugSparse(QString(" -> interface '%1'").arg(interface->name()));
                     }
                 }
             }
             AbstractMetaClass *AbstractMetaBuilder::traverseNamespace(NamespaceModelItem namespace_item)
             {
                 QString namespace_name = (!m_namespace_prefix.isEmpty() ? m_namespace_prefix + "::" : QString()) + namespace_item->name();
                 NamespaceTypeEntry *type = TypeDatabase::instance()->findNamespaceType(namespace_name);
                 if (TypeDatabase::instance()->isClassRejected(namespace_name)) {
                     m_rejected_classes.insert(namespace_name, GenerationDisabled);
                     return 0;
                 }
                 if (!type) {
                     ReportHandler::warning(QString("namespace '%1' does not have a type entry")
                                            .arg(namespace_name));
                     return 0;
                 }
                 AbstractMetaClass *meta_class = createMetaClass();
                 meta_class->setTypeEntry(type);
                 *meta_class += AbstractMetaAttributes::Public;
                 m_current_class = meta_class;
                 ReportHandler::debugSparse(QString("namespace '%1.%2'")
                                            .arg(meta_class->package())
                                            .arg(namespace_item->name()));
                 traverseEnums(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class, namespace_item->enumsDeclarations());
                 traverseFunctions(model_dynamic_cast<ScopeModelItem>(namespace_item), meta_class);
             //     traverseClasses(model_dynamic_cast<ScopeModelItem>(namespace_item));
                 pushScope(model_dynamic_cast<ScopeModelItem>(namespace_item));
                 m_namespace_prefix = currentScope()->qualifiedName().join("::");
                 ClassList classes = namespace_item->classes();
                 foreach (ClassModelItem cls, classes) {
                     AbstractMetaClass *mjc = traverseClass(cls);
                     addAbstractMetaClass(mjc);
                 }
                 // Go through all typedefs to see if we have defined any
                 // specific typedefs to be used as classes.
                 TypeAliasList typeAliases = namespace_item->typeAliases();
                 foreach (TypeAliasModelItem typeAlias, typeAliases) {
                     AbstractMetaClass *cls = traverseTypeAlias(typeAlias);
                     addAbstractMetaClass(cls);
                 }
                 // Traverse namespaces recursively
                 QList<NamespaceModelItem> inner_namespaces = namespace_item->namespaceMap().values();
                 foreach (const NamespaceModelItem &ni, inner_namespaces) {
                     AbstractMetaClass *mjc = traverseNamespace(ni);
                     addAbstractMetaClass(mjc);
                 }
                 m_current_class = 0;
                 popScope();
                 m_namespace_prefix = currentScope()->qualifiedName().join("::");
                 if (!type->include().isValid()) {
                     QFileInfo info(namespace_item->fileName());
                     type->setInclude(Include(Include::IncludePath, info.fileName()));
                 }
                 return meta_class;
             }
             struct Operator
             {
                 enum Type { Plus, ShiftLeft, None };
                 Operator() : type(None) { }
                 int calculate(int x) {
                     switch (type) {
                     case Plus: return x + value;
                     case ShiftLeft: return x << value;
                     case None: return x;
                     }
                     return x;
                 }
                 Type type;
                 int value;
             };
             Operator findOperator(QString *s) {
                 const char *names[] = {
                     "+",
                     "<<"
                 };
                 for (int i=0; i<Operator::None; ++i) {
                     QString name = QLatin1String(names[i]);
                     QString str = *s;
                     int splitPoint = str.indexOf(name);
                     if (splitPoint > 0) {
                         bool ok;
                         QString right = str.mid(splitPoint + name.length());
                         Operator op;
                         op.value = right.toInt(&ok);
                         if (ok) {
                             op.type = Operator::Type(i);
                             *s = str.left(splitPoint).trimmed();
                             return op;
                         }
                     }
                 }
                 return Operator();
             }
             int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
                                                     int oldValuevalue,
                                                     AbstractMetaEnum *meta_enum,
                                                     AbstractMetaFunction *meta_function)
             {
                 if (stringValue.isEmpty())
                     return oldValuevalue;
                 QStringList stringValues = stringValue.split("|");
                 int returnValue = 0;
                 bool matched = false;
                 for (int i=0; i<stringValues.size(); ++i) {
                     QString s = stringValues.at(i).trimmed();
                     bool ok;
                     int v;
                     Operator op = findOperator(&s);
                     if (s.length() > 0 && s.at(0) == QLatin1Char('0'))
                         v = s.toUInt(&ok, 0);
                     else
                         v = s.toInt(&ok);
                     if (ok) {
                         matched = true;
                     } else if (m_enum_values.contains(s)) {
                         v = m_enum_values[s]->value();
                         matched = true;
                     } else {
                         AbstractMetaEnumValue *ev = 0;
                         if (meta_enum && (ev = meta_enum->values().find(s))) {
                             v = ev->value();
                             matched = true;
                         } else if (meta_enum && (ev = meta_enum->enclosingClass()->findEnumValue(s, meta_enum))) {
                             v = ev->value();
                             matched = true;
                         } else {
                             if (meta_enum)
                                 ReportHandler::warning("unhandled enum value: " + s + " in "
                                                        + meta_enum->enclosingClass()->name() + "::"
                                                        + meta_enum->name());
                             else
                                 ReportHandler::warning("unhandled enum value: Unknown enum");
                         }
                     }
                     if (matched)
                         returnValue |= op.calculate(v);
                 }
                 if (!matched) {
                     QString warn = QString("unmatched enum %1").arg(stringValue);
                     if (meta_function != 0) {
                         warn += QString(" when parsing default value of '%1' in class '%2'")
                             .arg(meta_function->name())
                             .arg(meta_function->implementingClass()->name());
                     }
                     ReportHandler::warning(warn);
                     returnValue = oldValuevalue;
                 }
                 return returnValue;
             }
             void AbstractMetaBuilder::figureOutEnumValuesForClass(AbstractMetaClass *meta_class,
                                                               QSet<AbstractMetaClass *> *classes)
             {
                 AbstractMetaClass *base = meta_class->baseClass();
                 if (base != 0 && !classes->contains(base))
                     figureOutEnumValuesForClass(base, classes);
                 if (classes->contains(meta_class))
                     return;
                 AbstractMetaEnumList enums = meta_class->enums();
                 foreach (AbstractMetaEnum *e, enums) {
                     if (!e) {
                         ReportHandler::warning("bad enum in class " + meta_class->name());
                         continue;
                     }
                     AbstractMetaEnumValueList lst = e->values();
                     int value = 0;
                     for (int i=0; i<lst.size(); ++i) {
                         value = figureOutEnumValue(lst.at(i)->stringValue(), value, e);
                         lst.at(i)->setValue(value);
                         value++;
                     }
                     // Check for duplicate values...
                     EnumTypeEntry *ete = e->typeEntry();
                     if (!ete->forceInteger()) {
                         QHash<int, AbstractMetaEnumValue *> entries;
                         foreach (AbstractMetaEnumValue *v, lst) {
                             bool vRejected = ete->isEnumValueRejected(v->name());
                             AbstractMetaEnumValue *current = entries.value(v->value());
                             if (current) {
                                 bool currentRejected = ete->isEnumValueRejected(current->name());
                                 if (!currentRejected && !vRejected) {
                                     ReportHandler::warning(
                                         QString("duplicate enum values: %1::%2, %3 and %4 are %5, already rejected: (%6)")
                                         .arg(meta_class->name())
                                         .arg(e->name())
                                         .arg(v->name())
                                         .arg(entries[v->value()]->name())
                                         .arg(v->value())
                                         .arg(ete->enumValueRejections().join(", ")));
                                     continue;
                                 }
                             }
                             if (!vRejected)
                                 entries[v->value()] = v;
                         }
                         // Entries now contain all the original entries, no
                         // rejected ones... Use this to generate the enumValueRedirection table.
                         foreach (AbstractMetaEnumValue *reject, lst) {
                             if (!ete->isEnumValueRejected(reject->name()))
                                 continue;
                             AbstractMetaEnumValue *used = entries.value(reject->value());
                             if (!used) {
                                 ReportHandler::warning(
                                     QString::fromLatin1("Rejected enum has no alternative...: %1::%2")
                                     .arg(meta_class->name())
                                     .arg(reject->name()));
                                 continue;
                             }
                             ete->addEnumValueRedirection(reject->name(), used->name());
                         }
                     }
                 }
                 *classes += meta_class;
             }
             void AbstractMetaBuilder::figureOutEnumValues()
             {
                 // Keep a set of classes that we already traversed. We use this to
                 // enforce that we traverse base classes prior to subclasses.
                 QSet<AbstractMetaClass *> classes;
                 foreach (AbstractMetaClass *c, m_meta_classes) {
                     figureOutEnumValuesForClass(c, &classes);
                 }
             }
             void AbstractMetaBuilder::figureOutDefaultEnumArguments()
             {
                 foreach (AbstractMetaClass *meta_class, m_meta_classes) {
                     foreach (AbstractMetaFunction *meta_function, meta_class->functions()) {
                         foreach (AbstractMetaArgument *arg, meta_function->arguments()) {
                             QString expr = arg->defaultValueExpression();
                             if (expr.isEmpty())
                                 continue;
                             if (!meta_function->replacedDefaultExpression(meta_function->implementingClass(),
                                 arg->argumentIndex()+1).isEmpty()) {
                                 continue;
                             }
                             QString new_expr = expr;
                             if (arg->type()->isEnum()) {
                                 QStringList lst = expr.split(QLatin1String("::"));
                                 if (lst.size() == 1) {
                                     QVector<AbstractMetaClass *> classes(1, meta_class);
                                     AbstractMetaEnum *e = 0;
                                     while (!classes.isEmpty() && e == 0) {
                                         if (classes.front() != 0) {
                                             classes << classes.front()->baseClass();
                                             AbstractMetaClassList interfaces = classes.front()->interfaces();
                                             foreach (AbstractMetaClass *interface, interfaces)
                                                 classes << interface->primaryInterfaceImplementor();
                                             e = classes.front()->findEnumForValue(expr);
                                         }
                                         classes.pop_front();
                                     }
                                     if (e != 0) {
                                         new_expr = QString("%1.%2")
                                                 .arg(e->typeEntry()->qualifiedTargetLangName())
                                                 .arg(expr);
                                     } else {
                                         ReportHandler::warning("Cannot find enum constant for value '" + expr + "' in '" + meta_class->name() + "' or any of its super classes");
                                     }
                                 } else if (lst.size() == 2) {
                                     AbstractMetaClass *cl = m_meta_classes.findClass(lst.at(0));
                                     if (!cl) {
                                         ReportHandler::warning("missing required class for enums: " + lst.at(0));
                                         continue;
                                     }
                                     new_expr = QString("%1.%2.%3")
                                                .arg(cl->typeEntry()->qualifiedTargetLangName())
                                                .arg(arg->type()->name())
                                                .arg(lst.at(1));
                                 } else {
                                     ReportHandler::warning("bad default value passed to enum " + expr);
                                 }
                             } else if(arg->type()->isFlags()) {
                                 const FlagsTypeEntry *flagsEntry =
                                     static_cast<const FlagsTypeEntry *>(arg->type()->typeEntry());
                                 EnumTypeEntry *enumEntry = flagsEntry->originator();
                                 AbstractMetaEnum *meta_enum = m_meta_classes.findEnum(enumEntry);
                                 if (!meta_enum) {
                                     ReportHandler::warning("unknown required enum " + enumEntry->qualifiedCppName());
                                     continue;
                                 }
                                 int value = figureOutEnumValue(expr, 0, meta_enum, meta_function);
                                 new_expr = QString::number(value);
                             } else if (arg->type()->isPrimitive()) {
                                 AbstractMetaEnumValue *value = 0;
                                 if (expr.contains("::"))
                                     value = m_meta_classes.findEnumValue(expr);
                                 if (!value)
                                     value = meta_class->findEnumValue(expr, 0);
                                 if (value) {
                                     new_expr = QString::number(value->value());
                                 } else if (expr.contains(QLatin1Char('+'))) {
                                     new_expr = QString::number(figureOutEnumValue(expr, 0, 0));
                                 }
                             }
                             arg->setDefaultValueExpression(new_expr);
                         }
                     }
                 }
             }
             AbstractMetaEnum *AbstractMetaBuilder::traverseEnum(EnumModelItem enum_item, AbstractMetaClass *enclosing, const QSet<QString> &enumsDeclarations)
             {
                 // Skipping private enums.
                 if (enum_item->accessPolicy() == CodeModel::Private) {
                     return 0;
                 }
                 QString qualified_name = enum_item->qualifiedName().join("::");
                 TypeEntry *type_entry = TypeDatabase::instance()->findType(qualified_name);
                 QString enum_name = enum_item->name();
                 QString class_name;
                 if (m_current_class)
                     class_name = m_current_class->typeEntry()->qualifiedCppName();
                 if (TypeDatabase::instance()->isEnumRejected(class_name, enum_name)) {
                     m_rejected_enums.insert(qualified_name, GenerationDisabled);
                     return 0;
                 }
                 if (!type_entry || !type_entry->isEnum()) {
                     QString context = m_current_class ? m_current_class->name() : QLatin1String("");
                     ReportHandler::warning(QString("enum '%1' does not have a type entry or is not an enum")
                                            .arg(qualified_name));
                     m_rejected_enums.insert(qualified_name, NotInTypeSystem);
                    return 0;
                 }
                 AbstractMetaEnum *meta_enum = createMetaEnum();
                 if (   enumsDeclarations.contains(qualified_name)
                     || enumsDeclarations.contains(enum_name)) {
                     meta_enum->setHasQEnumsDeclaration(true);
                 }
                 meta_enum->setTypeEntry((EnumTypeEntry *) type_entry);
                 switch (enum_item->accessPolicy()) {
                 case CodeModel::Public: *meta_enum += AbstractMetaAttributes::Public; break;
                 case CodeModel::Protected: *meta_enum += AbstractMetaAttributes::Protected; break;
             //     case CodeModel::Private: *meta_enum += AbstractMetaAttributes::Private; break;
                 default: break;
                 }
                 ReportHandler::debugMedium(QString(" - traversing enum %1").arg(meta_enum->fullName()));
                 foreach (EnumeratorModelItem value, enum_item->enumerators()) {
                     AbstractMetaEnumValue *meta_enum_value = createMetaEnumValue();
                     meta_enum_value->setName(value->name());
                     // Deciding the enum value...
                     meta_enum_value->setStringValue(value->value());
                     meta_enum->addEnumValue(meta_enum_value);
                     ReportHandler::debugFull("   - " + meta_enum_value->name() + " = "
                                              + meta_enum_value->value());
                     // Add into global register...
                     if (enclosing)
                         m_enum_values[enclosing->name() + "::" + meta_enum_value->name()] = meta_enum_value;
                     else
                         m_enum_values[meta_enum_value->name()] = meta_enum_value;
                 }
                 QFileInfo info(enum_item->fileName());
                 meta_enum->typeEntry()->setInclude(Include(Include::IncludePath, info.fileName()));
                 m_enums << meta_enum;
                 return meta_enum;
             }
             AbstractMetaClass *AbstractMetaBuilder::traverseTypeAlias(TypeAliasModelItem typeAlias)
             {
                 QString class_name = strip_template_args(typeAlias->name());
                 QString full_class_name = class_name;
                 // we have an inner class
                 if (m_current_class) {
                     full_class_name = strip_template_args(m_current_class->typeEntry()->qualifiedCppName())
                                       + "::" + full_class_name;
                 }
                 // If we haven't specified anything for the typedef, then we don't care
                 ComplexTypeEntry *type = TypeDatabase::instance()->findComplexType(full_class_name);
                 if (type == 0)
                     return 0;
                 if (type->isObject())
                     static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(strip_template_args(typeAlias->type().qualifiedName().join("::"))));
                 AbstractMetaClass *meta_class = createMetaClass();
                 meta_class->setTypeAlias(true);
                 meta_class->setTypeEntry(type);
                 meta_class->setBaseClassNames(QStringList() << typeAlias->type().qualifiedName().join("::"));
                 *meta_class += AbstractMetaAttributes::Public;
                 // Set the default include file name
                 if (!type->include().isValid()) {
                     QFileInfo info(typeAlias->fileName());
                     type->setInclude(Include(Include::IncludePath, info.fileName()));
                 }
                 return meta_class;
             }
             AbstractMetaClass *AbstractMetaBuilder::traverseClass(ClassModelItem class_item)
             {
                 QString class_name = strip_template_args(class_item->name());
                 QString full_class_name = class_name;
                 // we have inner an class
                 if (m_current_class) {
                     full_class_name = strip_template_args(m_current_class->typeEntry()->qualifiedCppName())
                                       + "::" + full_class_name;
                 }
                 ComplexTypeEntry *type = TypeDatabase::instance()->findComplexType(full_class_name);
                 RejectReason reason = NoReason;
                 if (full_class_name == "QMetaTypeId") {
                     // QtScript: record which types have been declared
                     int lpos = class_item->name().indexOf('<');
                     int rpos = class_item->name().lastIndexOf('>');
                     if ((lpos != -1) && (rpos != -1)) {
                         QString declared_typename = class_item->name().mid(lpos+1, rpos - lpos-1);
                         m_qmetatype_declared_typenames.insert(declared_typename);
                     }
                 }
                 if (TypeDatabase::instance()->isClassRejected(full_class_name)) {
                     reason = GenerationDisabled;
                 } else if (!type) {
                     TypeEntry *te = TypeDatabase::instance()->findType(full_class_name);
                     if (te && !te->isComplex())
                         reason = RedefinedToNotClass;
                     else
                         reason = NotInTypeSystem;
                 } else if (type->codeGeneration() == TypeEntry::GenerateNothing) {
                     reason = GenerationDisabled;
                 }
                 if (reason != NoReason) {
                     m_rejected_classes.insert(full_class_name, reason);
                     return 0;
                 }
                 if (type->isObject()) {
                     ((ObjectTypeEntry *)type)->setQObject(isQObject(full_class_name));
                 }
                 AbstractMetaClass *meta_class = createMetaClass();
                 meta_class->setTypeEntry(type);
                 meta_class->setBaseClassNames(class_item->baseClasses());
                 *meta_class += AbstractMetaAttributes::Public;
                 AbstractMetaClass *old_current_class = m_current_class;
                 m_current_class = meta_class;
                 if (type->isContainer()) {
                     ReportHandler::debugSparse(QString("container: '%1'").arg(full_class_name));
                 } else {
                     ReportHandler::debugSparse(QString("class: '%1'").arg(meta_class->fullName()));
                 }
                 TemplateParameterList template_parameters = class_item->templateParameters();
                 QList<TypeEntry *> template_args;
                 template_args.clear();
                 for (int i=0; i<template_parameters.size(); ++i) {
                     const TemplateParameterModelItem &param = template_parameters.at(i);
                     TemplateArgumentEntry *param_type = new TemplateArgumentEntry(param->name());
                     param_type->setOrdinal(i);
                     template_args.append(param_type);
                 }
                 meta_class->setTemplateArguments(template_args);
                 parseQ_Property(meta_class, class_item->propertyDeclarations());
                 traverseFunctions(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
                 traverseEnums(model_dynamic_cast<ScopeModelItem>(class_item), meta_class, class_item->enumsDeclarations());
                 traverseFields(model_dynamic_cast<ScopeModelItem>(class_item), meta_class);
                 // Inner classes
                 {
                     QList<ClassModelItem> inner_classes = class_item->classMap().values();
                     foreach (const ClassModelItem &ci, inner_classes) {
                         AbstractMetaClass *cl = traverseClass(ci);
                         if (cl) {
                             cl->setEnclosingClass(meta_class);
                             m_meta_classes << cl;
                         }
                     }
                 }
                 // Go through all typedefs to see if we have defined any
                 // specific typedefs to be used as classes.
                 TypeAliasList typeAliases = class_item->typeAliases();
                 foreach (TypeAliasModelItem typeAlias, typeAliases) {
                     AbstractMetaClass *cls = traverseTypeAlias(typeAlias);
                     if (cls != 0) {
                         cls->setEnclosingClass(meta_class);
                         addAbstractMetaClass(cls);
                     }
                 }
                 m_current_class = old_current_class;
                 // Set the default include file name
                 if (!type->include().isValid()) {
                     QFileInfo info(class_item->fileName());
                     type->setInclude(Include(Include::IncludePath, info.fileName()));
                 }
                 return meta_class;
             }
             AbstractMetaField *AbstractMetaBuilder::traverseField(VariableModelItem field, const AbstractMetaClass *cls)
             {
                 QString field_name = field->name();
                 QString class_name = m_current_class->typeEntry()->qualifiedCppName();
                 // Ignore friend decl.
                 if (field->isFriend())
                     return 0;
                 if (field->accessPolicy() == CodeModel::Private)
                     return 0;
                 if (TypeDatabase::instance()->isFieldRejected(class_name, field_name)) {
                     m_rejected_fields.insert(class_name + "::" + field_name, GenerationDisabled);
                     return 0;
                 }
                 AbstractMetaField *meta_field = createMetaField();
                 meta_field->setName(field_name);
                 meta_field->setEnclosingClass(cls);
                 bool ok;
                 TypeInfo field_type = field->type();
                 AbstractMetaType *meta_type = translateType(field_type, &ok);
                 if (!meta_type || !ok) {
                     ReportHandler::warning(QString("skipping field '%1::%2' with unmatched type '%3'")
                                            .arg(m_current_class->name())
                                            .arg(field_name)
                                            .arg(TypeInfo::resolveType(field_type, currentScope()->toItem()).qualifiedName().join("::")));
                     delete meta_field;
                     return 0;
                 }
                 meta_field->setType(meta_type);
                 uint attr = 0;
                 if (field->isStatic())
                     attr |= AbstractMetaAttributes::Static;
                 CodeModel::AccessPolicy policy = field->accessPolicy();
                 if (policy == CodeModel::Public)
                     attr |= AbstractMetaAttributes::Public;
                 else if (policy == CodeModel::Protected)
                     attr |= AbstractMetaAttributes::Protected;
                 else
                     attr |= AbstractMetaAttributes::Private;
                 meta_field->setAttributes(attr);
                 return meta_field;
             }
             void AbstractMetaBuilder::traverseFields(ScopeModelItem scope_item, AbstractMetaClass *meta_class)
             {
                 foreach (VariableModelItem field, scope_item->variables()) {
                     AbstractMetaField *meta_field = traverseField(field, meta_class);
                     if (meta_field) {
                         meta_field->setOriginalAttributes(meta_field->attributes());
                         meta_class->addField(meta_field);
                     }
                 }
             }
             void AbstractMetaBuilder::setupFunctionDefaults(AbstractMetaFunction *meta_function, AbstractMetaClass *meta_class)
             {
                 // Set the default value of the declaring class. This may be changed
                 // in fixFunctions later on
                 meta_function->setDeclaringClass(meta_class);
                 // Some of the queries below depend on the implementing class being set
                 // to function properly. Such as function modifications
                 meta_function->setImplementingClass(meta_class);
                 if (meta_function->name() == "operator_equal")
                     meta_class->setHasEqualsOperator(true);
                 if (!meta_function->isFinalInTargetLang()
                     && meta_function->isRemovedFrom(meta_class, TypeSystem::TargetLangCode)) {
                     *meta_function += AbstractMetaAttributes::FinalInCpp;
                 }
             }
             void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scope_item, AbstractMetaClass *meta_class)
             {
                 foreach (FunctionModelItem function, scope_item->functions()) {
                     AbstractMetaFunction *meta_function = traverseFunction(function);
                     if (meta_function) {
                         meta_function->setOriginalAttributes(meta_function->attributes());
                         if (meta_class->isNamespace())
                             *meta_function += AbstractMetaAttributes::Static;
                         if (QPropertySpec *read = meta_class->propertySpecForRead(meta_function->name())) {
                             if (read->type() == meta_function->type()->typeEntry()) {
                                 *meta_function += AbstractMetaAttributes::PropertyReader;
                                 meta_function->setPropertySpec(read);
             //                     printf("%s is reader for %s\n",
             //                            qPrintable(meta_function->name()),
             //                            qPrintable(read->name()));
                             }
                         } else if (QPropertySpec *write =
                                    meta_class->propertySpecForWrite(meta_function->name())) {
                             if (write->type() == meta_function->arguments().at(0)->type()->typeEntry()) {
                                 *meta_function += AbstractMetaAttributes::PropertyWriter;
                                 meta_function->setPropertySpec(write);
             //                     printf("%s is writer for %s\n",
             //                            qPrintable(meta_function->name()),
             //                            qPrintable(write->name()));
                             }
                         } else if (QPropertySpec *reset =
                                    meta_class->propertySpecForReset(meta_function->name())) {
                             *meta_function += AbstractMetaAttributes::PropertyResetter;
                             meta_function->setPropertySpec(reset);
             //                     printf("%s is resetter for %s\n",
             //                            qPrintable(meta_function->name()),
             //                            qPrintable(reset->name()));
                         }
                         bool isInvalidDestructor = meta_function->isDestructor() && meta_function->isPrivate();
                         bool isInvalidConstructor = meta_function->isConstructor()
                             && (meta_function->isPrivate() || meta_function->isInvalid());
                         if ((isInvalidDestructor || isInvalidConstructor)
                             && !meta_class->hasNonPrivateConstructor()) {
                             *meta_class += AbstractMetaAttributes::Final;
                         } else if (meta_function->isConstructor() && !meta_function->isPrivate()) {
                             *meta_class -= AbstractMetaAttributes::Final;
                             meta_class->setHasNonPrivateConstructor(true);
                         }
                         // Classes with virtual destructors should always have a shell class
                         // (since we aren't registering the destructors, we need this extra check)
                         if (meta_function->isDestructor() && !meta_function->isFinal())
                             meta_class->setForceShellClass(true);
                         if (!meta_function->isDestructor()
                             && !meta_function->isInvalid()
                             && (!meta_function->isConstructor() || !meta_function->isPrivate())) {
                             if (meta_class->typeEntry()->designatedInterface() && !meta_function->isPublic()
                                 && !meta_function->isPrivate()) {
                                 QString warn = QString("non-public function '%1' in interface '%2'")
                                     .arg(meta_function->name()).arg(meta_class->name());
                                 ReportHandler::warning(warn);
                                 meta_function->setVisibility(AbstractMetaClass::Public);
                             }
                             setupFunctionDefaults(meta_function, meta_class);
                             if (meta_function->isSignal() && meta_class->hasSignal(meta_function)) {
                                 QString warn = QString("signal '%1' in class '%2' is overloaded.")
                                     .arg(meta_function->name()).arg(meta_class->name());
                                 ReportHandler::warning(warn);
                             }
                             if (meta_function->isSignal() && !meta_class->isQObject()) {
                                 QString warn = QString("signal '%1' in non-QObject class '%2'")
                                     .arg(meta_function->name()).arg(meta_class->name());
                                 ReportHandler::warning(warn);
                             }
                             meta_class->addFunction(meta_function);
                         } else if (meta_function->isDestructor() && !meta_function->isPublic()) {
                             meta_class->setHasPublicDestructor(false);
                         }
                     }
                 }
             }
             bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *meta_class)
             {
                 Q_ASSERT(!meta_class->isInterface());
                 if (m_setup_inheritance_done.contains(meta_class))
                     return true;
                 m_setup_inheritance_done.insert(meta_class);
                 QStringList base_classes = meta_class->baseClassNames();
                 TypeDatabase *types = TypeDatabase::instance();
                 // we only support our own containers and ONLY if there is only one baseclass
                 if (base_classes.size() == 1 && base_classes.first().count('<') == 1) {
                     QStringList scope = meta_class->typeEntry()->qualifiedCppName().split("::");
                     scope.removeLast();
                     for (int i=scope.size(); i>=0; --i) {
                         QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join("::") + "::" : QString();
                         QString complete_name = prefix + base_classes.first();
                         TypeParser::Info info = TypeParser::parse(complete_name);
                         QString base_name = info.qualified_name.join("::");
                         AbstractMetaClass *templ = 0;
                         foreach (AbstractMetaClass *c, m_templates) {
                             if (c->typeEntry()->name() == base_name) {
                                 templ = c;
                                 break;
                             }
                         }
                         if (templ == 0)
                             templ = m_meta_classes.findClass(base_name);
                         if (templ) {
                             setupInheritance(templ);
                             inheritTemplate(meta_class, templ, info);
                             return true;
                         }
                     }
                     ReportHandler::warning(QString("template baseclass '%1' of '%2' is not known")
                                             .arg(base_classes.first())
                                             .arg(meta_class->name()));
                     return false;
                 }
                 int primary = -1;
                 int primaries = 0;
                 for (int i=0; i<base_classes.size(); ++i) {
                     if (types->isClassRejected(base_classes.at(i)))
                         continue;
                     TypeEntry *base_class_entry = types->findType(base_classes.at(i));
                     if (!base_class_entry) {
                         ReportHandler::warning(QString("class '%1' inherits from unknown base class '%2'")
                                                .arg(meta_class->name()).arg(base_classes.at(i)));
                     }
                     // true for primary base class
                     else if (!base_class_entry->designatedInterface()) {
                         if (primaries > 0) {
                             ReportHandler::warning(QString("class '%1' has multiple primary base classes"
                                                            " '%2' and '%3'")
                                                    .arg(meta_class->name())
                                                    .arg(base_classes.at(primary))
                                                    .arg(base_class_entry->name()));
                             return false;
                         }
                         primaries++;
                         primary = i;
                     }
                 }
                 if (primary >= 0) {
                     AbstractMetaClass *base_class = m_meta_classes.findClass(base_classes.at(primary));
                     if (!base_class) {
                         ReportHandler::warning(QString("unknown baseclass for '%1': '%2'")
                                                .arg(meta_class->name())
                                                .arg(base_classes.at(primary)));
                         return false;
                     }
                     meta_class->setBaseClass(base_class);
                     if (meta_class->typeEntry()->designatedInterface() != 0 && meta_class->isQObject()) {
                         ReportHandler::warning(QString("QObject extended by interface type '%1'. This is not supported and the generated Java code will not compile.")
                                                .arg(meta_class->name()));
                     } else if (meta_class->typeEntry()->designatedInterface() != 0 && base_class != 0 && !base_class->isInterface()) {
                         ReportHandler::warning(QString("object type '%1' extended by interface type '%2'. The resulting API will be less expressive than the original.")
                                                .arg(base_class->name())
                                                .arg(meta_class->name()));
                     }
                 }
                 for (int i=0; i<base_classes.size(); ++i) {
                     if (types->isClassRejected(base_classes.at(i)))
                         continue;
                     if (i != primary) {
                         AbstractMetaClass *base_class = m_meta_classes.findClass(base_classes.at(i));
                         if (base_class == 0) {
                             ReportHandler::warning(QString("class not found for setup inheritance '%1'").arg(base_classes.at(i)));
                             return false;
                         }
                         setupInheritance(base_class);
                         QString interface_name = InterfaceTypeEntry::interfaceName(base_class->name());
                         AbstractMetaClass *iface = m_meta_classes.findClass(interface_name);
                         if (!iface) {
                             ReportHandler::warning(QString("unknown interface for '%1': '%2'")
                                                    .arg(meta_class->name())
                                                    .arg(interface_name));
                             return false;
                         }
                         meta_class->addInterface(iface);
                         AbstractMetaClassList interfaces = iface->interfaces();
                         foreach (AbstractMetaClass *iface, interfaces)
                             meta_class->addInterface(iface);
                     }
                 }
                 return true;
             }
             void AbstractMetaBuilder::traverseEnums(ScopeModelItem scope_item, AbstractMetaClass *meta_class, const QStringList &enumsDeclarations)
             {
                 EnumList enums = scope_item->enums();
                 foreach (EnumModelItem enum_item, enums) {
                     AbstractMetaEnum *meta_enum = traverseEnum(enum_item, meta_class, QSet<QString>::fromList(enumsDeclarations));
                     if (meta_enum) {
                         meta_enum->setOriginalAttributes(meta_enum->attributes());
                         meta_class->addEnum(meta_enum);
                         meta_enum->setEnclosingClass(meta_class);
                     }
                 }
             }
             AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem function_item)
             {
                 QString function_name = function_item->name();
                 QString class_name = m_current_class->typeEntry()->qualifiedCppName();
                 if (TypeDatabase::instance()->isFunctionRejected(class_name, function_name)) {
                     m_rejected_functions.insert(class_name + "::" + function_name, GenerationDisabled);
                     return 0;
                 }
                 Q_ASSERT(function_item->functionType() == CodeModel::Normal
                          || function_item->functionType() == CodeModel::Signal
                          || function_item->functionType() == CodeModel::Slot);
                 if (function_item->isFriend())
                     return 0;
                 QString cast_type;
                 if (function_name.startsWith("operator")) {
                     function_name = rename_operator(function_name.mid(8));
                     if (function_name.isEmpty()) {
                         m_rejected_functions.insert(class_name + "::" + function_name,
                                                     GenerationDisabled);
                         return 0;
                     }
                     if (function_name.contains("_cast_"))
                         cast_type = function_name.mid(14).trimmed();
                 }
                 AbstractMetaFunction *meta_function = createMetaFunction();
                 meta_function->setConstant(function_item->isConstant());
                 ReportHandler::debugMedium(QString(" - %2()").arg(function_name));
                 meta_function->setName(function_name);
                 meta_function->setOriginalName(function_item->name());
                 if (function_item->isAbstract())
                     *meta_function += AbstractMetaAttributes::Abstract;
                 if (!meta_function->isAbstract())
                     *meta_function += AbstractMetaAttributes::Native;
                 if (!function_item->isVirtual())
                     *meta_function += AbstractMetaAttributes::Final;
                 if (function_item->isInvokable())
                     *meta_function += AbstractMetaAttributes::Invokable;
                 if (function_item->isStatic()) {
                     *meta_function += AbstractMetaAttributes::Static;
                     *meta_function += AbstractMetaAttributes::Final;
                 }
                 // Access rights
                 if (function_item->accessPolicy() == CodeModel::Public)
                     *meta_function += AbstractMetaAttributes::Public;
                 else if (function_item->accessPolicy() == CodeModel::Private)
                     *meta_function += AbstractMetaAttributes::Private;
                 else
                     *meta_function += AbstractMetaAttributes::Protected;
                 QString stripped_class_name = class_name;
                 int cc_pos = stripped_class_name.lastIndexOf("::");
                 if (cc_pos > 0)
                     stripped_class_name = stripped_class_name.mid(cc_pos + 2);
                 TypeInfo function_type = function_item->type();
                 if (function_name.startsWith('~')) {
                     meta_function->setFunctionType(AbstractMetaFunction::DestructorFunction);
                     meta_function->setInvalid(true);
                 } else if (strip_template_args(function_name) == stripped_class_name) {
                     meta_function->setFunctionType(AbstractMetaFunction::ConstructorFunction);
                     meta_function->setName(m_current_class->name());
                 } else {
                     bool ok;
                     AbstractMetaType *type = 0;
                     if (!cast_type.isEmpty()) {
                         TypeInfo info;
                         info.setQualifiedName(QStringList(cast_type));
                         type = translateType(info, &ok);
                     } else {
                         type = translateType(function_type, &ok);
                     }
                     if (!ok) {
                         ReportHandler::warning(QString("skipping function '%1::%2', unmatched return type '%3'")
                                                .arg(class_name)
                                                .arg(function_item->name())
                                                .arg(function_item->type().toString()));
                         m_rejected_functions[class_name + "::" + function_name] =
                             UnmatchedReturnType;
                         meta_function->setInvalid(true);
                         return meta_function;
                     }
                     meta_function->setType(type);
                     if (function_item->functionType() == CodeModel::Signal)
                         meta_function->setFunctionType(AbstractMetaFunction::SignalFunction);
                     else if (function_item->functionType() == CodeModel::Slot)
                         meta_function->setFunctionType(AbstractMetaFunction::SlotFunction);
                 }
                 ArgumentList arguments = function_item->arguments();
                 AbstractMetaArgumentList meta_arguments;
                 int first_default_argument = 0;
                 for (int i=0; i<arguments.size(); ++i) {
                     ArgumentModelItem arg = arguments.at(i);
                     bool ok;
                     AbstractMetaType *meta_type = translateType(arg->type(), &ok);
                     if (!meta_type || !ok) {
                         ReportHandler::warning(QString("skipping function '%1::%2', "
                                                        "unmatched parameter type '%3'")
                                                .arg(class_name)
                                                .arg(function_item->name())
                                                .arg(arg->type().toString()));
                         m_rejected_functions[class_name + "::" + function_name] =
                             UnmatchedArgumentType;
                         meta_function->setInvalid(true);
                         return meta_function;
                     }
                     AbstractMetaArgument *meta_argument = createMetaArgument();
                     meta_argument->setType(meta_type);
                     meta_argument->setName(arg->name());
                     meta_argument->setArgumentIndex(i);
                     meta_arguments << meta_argument;
                 }
                 meta_function->setArguments(meta_arguments);
                 // Find the correct default values
                 for (int i=0; i<arguments.size(); ++i) {
                     ArgumentModelItem arg = arguments.at(i);
                     AbstractMetaArgument *meta_arg = meta_arguments.at(i);
                     if (arg->defaultValue()) {
                         QString expr = arg->defaultValueExpression();
                         if (!expr.isEmpty())
                             meta_arg->setOriginalDefaultValueExpression(expr);
                         expr = translateDefaultValue(arg, meta_arg->type(), meta_function, m_current_class, i);
                         if (expr.isEmpty()) {
                             first_default_argument = i;
                         } else {
                             meta_arg->setDefaultValueExpression(expr);
                         }
                         if (meta_arg->type()->isEnum() || meta_arg->type()->isFlags()) {
                             m_enum_default_arguments
                                 << QPair<AbstractMetaArgument *, AbstractMetaFunction *>(meta_arg, meta_function);
                         }
                     }
                 }
                 // If we where not able to translate the default argument make it
                 // reset all default arguments before this one too.
                 for (int i=0; i<first_default_argument; ++i)
                     meta_arguments[i]->setDefaultValueExpression(QString());
                 if (ReportHandler::debugLevel() == ReportHandler::FullDebug)
                     foreach(AbstractMetaArgument *arg, meta_arguments)
                         ReportHandler::debugFull("   - " + arg->toString());
                 return meta_function;
             }
             AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, bool *ok, bool resolveType, bool resolveScope)
             {
                 Q_ASSERT(ok);
                 *ok = true;
                 // 1. Test the type info without resolving typedefs in case this is present in the
                 //    type system
                 TypeInfo typei;
                 if (resolveType) {
                     bool isok;
                     AbstractMetaType *t = translateType(_typei, &isok, false, resolveScope);
                     if (t != 0 && isok)
                         return t;
                 }
                 if (!resolveType)
                     typei = _typei;
                 else {
                     // Go through all parts of the current scope (including global namespace)
                     // to resolve typedefs. The parser does not properly resolve typedefs in
                     // the global scope when they are referenced from inside a namespace.
                     // This is a work around to fix this bug since fixing it in resolveType
                     // seemed non-trivial
                     int i = m_scopes.size() - 1;
                     while (i >= 0) {
                         typei = TypeInfo::resolveType(_typei, m_scopes.at(i--)->toItem());
                         if (typei.qualifiedName().join("::") != _typei.qualifiedName().join("::"))
                             break;
                     }
                 }
                 if (typei.isFunctionPointer()) {
                     *ok = false;
                     return 0;
                 }
                 TypeParser::Info typeInfo = TypeParser::parse(typei.toString());
                 if (typeInfo.is_busted) {
                     *ok = false;
                     return 0;
                 }
                 // 2. Handle pointers specified as arrays with unspecified size
                 bool array_of_unspecified_size = false;
                 if (typeInfo.arrays.size() > 0) {
                     array_of_unspecified_size = true;
                     for (int i=0; i<typeInfo.arrays.size(); ++i)
                         array_of_unspecified_size = array_of_unspecified_size && typeInfo.arrays.at(i).isEmpty();
                     if (!array_of_unspecified_size) {
                         TypeInfo newInfo;
                         //newInfo.setArguments(typei.arguments());
                         newInfo.setIndirections(typei.indirections());
                         newInfo.setConstant(typei.isConstant());
                         newInfo.setFunctionPointer(typei.isFunctionPointer());
                         newInfo.setQualifiedName(typei.qualifiedName());
                         newInfo.setReference(typei.isReference());
                         newInfo.setVolatile(typei.isVolatile());
                         AbstractMetaType *elementType = translateType(newInfo, ok);
                         if (!(*ok))
                             return 0;
                         for (int i=typeInfo.arrays.size()-1; i>=0; --i) {
                             QString s = typeInfo.arrays.at(i);
                             bool isok;
                             int elems = s.toInt(&isok);
                             if (!isok)
                                 return 0;
                             AbstractMetaType *arrayType = createMetaType();
                             arrayType->setArrayElementCount(elems);
                             arrayType->setArrayElementType(elementType);
                             arrayType->setTypeEntry(new ArrayTypeEntry(elementType->typeEntry()));
                             decideUsagePattern(arrayType);
                             elementType = arrayType;
                         }
                         return elementType;
                     }  else {
                         typeInfo.indirections += typeInfo.arrays.size();
                     }
                 }
                 QStringList qualifier_list = typeInfo.qualified_name;
                 if (qualifier_list.isEmpty()) {
                     ReportHandler::warning(QString("horribly broken type '%1'").arg(_typei.toString()));
                     *ok = false;
                     return 0;
                 }
                 QString qualified_name = qualifier_list.join("::");
                 QString name = qualifier_list.takeLast();
                 // 3. Special case 'void' type
                 if (name == "void" && typeInfo.indirections == 0) {
                     return 0;
                 }
                 // 4. Special case QFlags (include instantiation in name)
                 if (qualified_name == "QFlags")
                     qualified_name = typeInfo.toString();
                 // 5. Try to find the type
                 const TypeEntry *type = TypeDatabase::instance()->findType(qualified_name);
                 // 6. No? Try looking it up as a flags type
                 if (!type)
                     type = TypeDatabase::instance()->findFlagsType(qualified_name);
                 // 7. No? Try looking it up as a container type
                 if (!type)
                     type = TypeDatabase::instance()->findContainerType(name);
                 // 8. No? Check if the current class is a template and this type is one
                 //    of the parameters.
                 if (type == 0 && m_current_class != 0) {
                     QList<TypeEntry *> template_args = m_current_class->templateArguments();
                     foreach (TypeEntry *te, template_args) {
                         if (te->name() == qualified_name)
                             type = te;
                     }
                 }
                 // 9. Try finding the type by prefixing it with the current
                 //    context and all baseclasses of the current context
                 if (!type && !TypeDatabase::instance()->isClassRejected(qualified_name) && m_current_class != 0 && resolveScope) {
                     QStringList contexts;
                     contexts.append(m_current_class->qualifiedCppName());
                     contexts.append(currentScope()->qualifiedName().join("::"));
                     TypeInfo info = typei;
                     bool subclasses_done = false;
                     while (!contexts.isEmpty() && type == 0) {
                         //type = TypeDatabase::instance()->findType(contexts.at(0) + "::" + qualified_name);
                         bool isok;
                         info.setQualifiedName(QStringList() << contexts.at(0) << qualified_name);
                         AbstractMetaType *t = translateType(info, &isok, true, false);
                         if (t != 0 && isok)
                             return t;
                         ClassModelItem item = m_dom->findClass(contexts.at(0));
                         if (item != 0)
                             contexts += item->baseClasses();
                         contexts.pop_front();
                         // 10. Last resort: Special cased prefix of Qt namespace since the meta object implicitly inherits this, so
                         //     enum types from there may be addressed without any scope resolution in properties.
                         if (contexts.size() == 0 && !subclasses_done) {
                             contexts << "Qt";
                             subclasses_done = true;
                         }
                     }
                 }
                 if (!type) {
                     *ok = false;
                     return 0;
                 }
                 // Used to for diagnostics later...
                 m_used_types << type;
                 // These are only implicit and should not appear in code...
                 Q_ASSERT(!type->isInterface());
                 AbstractMetaType *meta_type = createMetaType();
                 meta_type->setTypeEntry(type);
                 meta_type->setIndirections(typeInfo.indirections);
                 meta_type->setReference(typeInfo.is_reference);
                 meta_type->setConstant(typeInfo.is_constant);
                 meta_type->setOriginalTypeDescription(_typei.toString());
                 decideUsagePattern(meta_type);
                 if (meta_type->typeEntry()->isContainer()) {
                     ContainerTypeEntry::Type container_type = static_cast<const ContainerTypeEntry *>(type)->type();
                     if (container_type == ContainerTypeEntry::StringListContainer) {
                         TypeInfo info;
                         info.setQualifiedName(QStringList() << "QString");
                         AbstractMetaType *targ_type = translateType(info, ok);
                         Q_ASSERT(*ok);
                         Q_ASSERT(targ_type);
                         meta_type->addInstantiation(targ_type);
                         meta_type->setInstantiationInCpp(false);
                     } else {
                         foreach (const TypeParser::Info &ta, typeInfo.template_instantiations) {
                             TypeInfo info;
                             info.setConstant(ta.is_constant);
                             info.setReference(ta.is_reference);
                             info.setIndirections(ta.indirections);
                             info.setFunctionPointer(false);
                             info.setQualifiedName(ta.instantiationName().split("::"));
                             AbstractMetaType *targ_type = translateType(info, ok);
                             if (!(*ok)) {
                                 delete meta_type;
                                 return 0;
                             }
                             meta_type->addInstantiation(targ_type);
                         }
                     }
                     if (container_type == ContainerTypeEntry::ListContainer
                         || container_type == ContainerTypeEntry::VectorContainer
                         || container_type == ContainerTypeEntry::StringListContainer) {
                         Q_ASSERT(meta_type->instantiations().size() == 1);
                     }
                 }
                 return meta_type;
             }
             void AbstractMetaBuilder::decideUsagePattern(AbstractMetaType *meta_type)
             {
                 const TypeEntry *type = meta_type->typeEntry();
                 if (type->isPrimitive() && (meta_type->actualIndirections() == 0
                                             || (meta_type->isConstant() && meta_type->isReference() && meta_type->indirections() == 0))) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::PrimitivePattern);
                 } else if (type->isVoid()) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::NativePointerPattern);
                 } else if (type->isString()
                            && meta_type->indirections() == 0
                            && (meta_type->isConstant() == meta_type->isReference()
                                || meta_type->isConstant())) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::StringPattern);
                 } else if (type->isChar()
                     && meta_type->indirections() == 0
                     && meta_type->isConstant() == meta_type->isReference()) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::CharPattern);
                 } else if (type->isJObjectWrapper()
                     && meta_type->indirections() == 0
                     && meta_type->isConstant() == meta_type->isReference()) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::JObjectWrapperPattern);
                 } else if (type->isVariant()
                     && meta_type->indirections() == 0
                     && meta_type->isConstant() == meta_type->isReference()) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::VariantPattern);
                 } else if (type->isEnum() && meta_type->actualIndirections() == 0) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::EnumPattern);
                 } else if (type->isObject()
                             && meta_type->indirections() == 0
                             && meta_type->isReference()) {
                     if (((ComplexTypeEntry *) type)->isQObject())
                         meta_type->setTypeUsagePattern(AbstractMetaType::QObjectPattern);
                     else
                         meta_type->setTypeUsagePattern(AbstractMetaType::ObjectPattern);
                 } else if (type->isObject()
                            && meta_type->indirections() == 1) {
                     if (((ComplexTypeEntry *) type)->isQObject())
                         meta_type->setTypeUsagePattern(AbstractMetaType::QObjectPattern);
                     else
                         meta_type->setTypeUsagePattern(AbstractMetaType::ObjectPattern);
                     // const-references to pointers can be passed as pointers
                     if (meta_type->isReference() && meta_type->isConstant()) {
                         meta_type->setReference(false);
                         meta_type->setConstant(false);
                     }
                 } else if (type->isContainer() && meta_type->indirections() == 0) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::ContainerPattern);
                 } else if (type->isTemplateArgument()) {
                 } else if (type->isFlags()
                            && meta_type->indirections() == 0
                            && (meta_type->isConstant() == meta_type->isReference())) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::FlagsPattern);
                 } else if (type->isArray()) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::ArrayPattern);
                 } else if (type->isThread()) {
                     Q_ASSERT(meta_type->indirections() == 1);
                     meta_type->setTypeUsagePattern(AbstractMetaType::ThreadPattern);
                 } else if (type->isValue()
                            && meta_type->indirections() == 0
                            && (meta_type->isConstant() == meta_type->isReference()
                                || !meta_type->isReference())) {
                     meta_type->setTypeUsagePattern(AbstractMetaType::ValuePattern);
                 } else {
                     meta_type->setTypeUsagePattern(AbstractMetaType::NativePointerPattern);
                     ReportHandler::debugFull(QString("native pointer pattern for '%1'")
                                              .arg(meta_type->cppSignature()));
                 }
             }
             QString AbstractMetaBuilder::translateDefaultValue(ArgumentModelItem item, AbstractMetaType *type,
                                                            AbstractMetaFunction *fnc, AbstractMetaClass *implementing_class,
                                                            int argument_index)
             {
                 QString function_name = fnc->name();
                 QString class_name = implementing_class->name();
                 QString replaced_expression = fnc->replacedDefaultExpression(implementing_class, argument_index + 1);
                 if (fnc->removedDefaultExpression(implementing_class, argument_index +1))
                     return "";
                 if (!replaced_expression.isEmpty())
                     return replaced_expression;
                 QString expr = item->defaultValueExpression();
                 if (type != 0 && type->isPrimitive()) {
                     if (type->name() == "boolean") {
                         if (expr == "false" || expr=="true") {
                             return expr;
                         } else {
                             bool ok = false;
                             int number = expr.toInt(&ok);
                             if (ok && number)
                                 return "true";
                             else
                                 return "false";
                         }
                     } else if (expr == "ULONG_MAX") {
                         return "Long.MAX_VALUE";
                     } else if (expr == "QVariant::Invalid") {
                         return QString::number(QVariant::Invalid);
                     } else {
                         // This can be an enum or flag so I need to delay the
                         // translation untill all namespaces are completly
                         // processed. This is done in figureOutEnumValues()
                         return expr;
                     }
                 } else if (type != 0 && (type->isFlags() || type->isEnum())) {
                     // Same as with enum explanation above...
                     return expr;
                 } else {
                     // constructor or functioncall can be a bit tricky...
                     if (expr == "QVariant()" || expr == "QModelIndex()") {
                         return "null";
                     } else if (expr == "QString()") {
                         return "null";
                     } else if (expr.endsWith(")") && expr.contains("::")) {
                         TypeEntry *typeEntry = TypeDatabase::instance()->findType(expr.left(expr.indexOf("::")));
                         if (typeEntry)
                             return typeEntry->qualifiedTargetLangName() + "." + expr.right(expr.length() - expr.indexOf("::") - 2);
                     } else if (expr.endsWith(")") && type != 0 && type->isValue()) {
                         int pos = expr.indexOf("(");
                         TypeEntry *typeEntry = TypeDatabase::instance()->findType(expr.left(pos));
                         if (typeEntry)
                             return "new " + typeEntry->qualifiedTargetLangName() + expr.right(expr.length() - pos);
                         else
                             return expr;
                     } else if (expr == "0") {
                         return "null";
                     } else if (type != 0 && (type->isObject() || type->isValue() || expr.contains("::"))) { // like Qt::black passed to a QColor
                         TypeEntry *typeEntry = TypeDatabase::instance()->findType(expr.left(expr.indexOf("::")));
                         expr = expr.right(expr.length() - expr.indexOf("::") - 2);
                         if (typeEntry) {
                             return "new " + type->typeEntry()->qualifiedTargetLangName() +
                                    "(" + typeEntry->qualifiedTargetLangName() + "." + expr + ")";
                         }
                     }
                 }
                 QString warn = QString("unsupported default value '%3' of argument in function '%1', class '%2'")
                     .arg(function_name).arg(class_name).arg(item->defaultValueExpression());
                 ReportHandler::warning(warn);
                 return QString();
             }
             bool AbstractMetaBuilder::isQObject(const QString &qualified_name)
             {
                 if (qualified_name == "QObject")
                     return true;
                 ClassModelItem class_item = m_dom->findClass(qualified_name);
                 if (!class_item) {
                   QStringList names = qualified_name.split(QLatin1String("::"));
                   NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(m_dom);
                   for (int i=0; i<names.size() - 1 && ns; ++i)
                       ns = ns->namespaceMap().value(names.at(i));
                   if (ns && names.size() >= 2)
                       class_item = ns->findClass(names.at(names.size() - 1));
                 }
                 bool isqobject = class_item && class_item->extendsClass("QObject");
                 if (class_item && !isqobject) {
                     QStringList baseClasses = class_item->baseClasses();
                     for (int i=0; i<baseClasses.count(); ++i) {
                         isqobject = isQObject(baseClasses.at(i));
                         if (isqobject)
                             break;
                     }
                 }
                 return isqobject;
             }
             bool AbstractMetaBuilder::isEnum(const QStringList &qualified_name)
             {
                 CodeModelItem item = m_dom->model()->findItem(qualified_name, m_dom->toItem());
                 return item && item->kind() == _EnumModelItem::__node_kind;
             }
             AbstractMetaType *AbstractMetaBuilder::inheritTemplateType(const QList<AbstractMetaType *> &template_types,
                                                                AbstractMetaType *meta_type, bool *ok)
             {
                 if (ok != 0)
                     *ok = true;
                 if (!meta_type || (!meta_type->typeEntry()->isTemplateArgument() && !meta_type->hasInstantiations()))
                     return meta_type ? meta_type->copy() : 0;
                 AbstractMetaType *returned = meta_type->copy();
                 returned->setOriginalTemplateType(meta_type->copy());
                 if (returned->typeEntry()->isTemplateArgument()) {
                     const TemplateArgumentEntry *tae = static_cast<const TemplateArgumentEntry *>(returned->typeEntry());
                     // If the template is intantiated with void we special case this as rejecting the functions that use this
                     // parameter from the instantiation.
                     if (template_types.size() <= tae->ordinal() || template_types.at(tae->ordinal())->typeEntry()->name() == "void") {
                         if (ok != 0)
                             *ok = false;
                         return 0;
                     }
                     AbstractMetaType *t = returned->copy();
                     t->setTypeEntry(template_types.at(tae->ordinal())->typeEntry());
                     t->setIndirections(template_types.at(tae->ordinal())->indirections() + t->indirections()
                                        ? 1
                                        : 0);
                     decideUsagePattern(t);
                     delete returned;
                     returned = inheritTemplateType(template_types, t, ok);
                     if (ok != 0 && !(*ok))
                         return 0;
                 }
                 if (returned->hasInstantiations()) {
                     QList<AbstractMetaType *> instantiations = returned->instantiations();
                     for (int i=0; i<instantiations.count(); ++i) {
                         instantiations[i] = inheritTemplateType(template_types, instantiations.at(i), ok);
                         if (ok != 0 && !(*ok))
                             return 0;
                     }
                     returned->setInstantiations(instantiations);
                 }
                 return returned;
             }
             bool AbstractMetaBuilder::inheritTemplate(AbstractMetaClass *subclass,
                                                   const AbstractMetaClass *template_class,
                                                   const TypeParser::Info &info)
             {
                 QList<TypeParser::Info> targs = info.template_instantiations;
                 QList<AbstractMetaType *> template_types;
                 foreach (const TypeParser::Info &i, targs) {
                     TypeEntry *t = TypeDatabase::instance()->findType(i.qualified_name.join("::"));
                     if (t != 0) {
                         AbstractMetaType *temporary_type = createMetaType();
                         temporary_type->setTypeEntry(t);
                         temporary_type->setConstant(i.is_constant);
                         temporary_type->setReference(i.is_reference);
                         temporary_type->setIndirections(i.indirections);
                         template_types << temporary_type;
                     }
                 }
                 AbstractMetaFunctionList funcs = subclass->functions();
                 foreach (const AbstractMetaFunction *function, template_class->functions()) {
                     if (function->isModifiedRemoved(TypeSystem::All))
                         continue;
                     AbstractMetaFunction *f = function->copy();
                     f->setArguments(AbstractMetaArgumentList());
                     bool ok = true;
                     AbstractMetaType *ftype = function->type();
                     f->setType(inheritTemplateType(template_types, ftype, &ok));
                     if (!ok) {
                         delete f;
                         continue;
                     }
                     foreach (AbstractMetaArgument *argument, function->arguments()) {
                         AbstractMetaType *atype = argument->type();
                         AbstractMetaArgument *arg = argument->copy();
                         arg->setType(inheritTemplateType(template_types, atype, &ok));
                         if (!ok)
                             break;
                         f->addArgument(arg);
                     }
                     if (!ok) {
                         delete f;
                         continue ;
                     }
                     // There is no base class in java to inherit from here, so the
                     // template instantiation is the class that implements the function..
                     f->setImplementingClass(subclass);
                     // We also set it as the declaring class, since the superclass is
                     // supposed to disappear. This allows us to make certain function modifications
                     // on the inherited functions.
                     f->setDeclaringClass(subclass);
                     if (f->isConstructor() && subclass->isTypeAlias()) {
                         f->setName(subclass->name());
                     } else if (f->isConstructor()) {
                         delete f;
                         continue;
                     }
                     // if the instantiation has a function named the same as an existing
                     // function we have shadowing so we need to skip it.
                     bool found = false;
                     for (int i=0; i<funcs.size(); ++i) {
                         if (funcs.at(i)->name() == f->name()) {
                             found = true;
                             continue;
                         }
                     }
                     if (found) {
                         delete f;
                         continue;
                     }
                     ComplexTypeEntry *te = subclass->typeEntry();
                     FunctionModificationList mods = function->modifications(template_class);
                     for (int i=0; i<mods.size(); ++i) {
                         FunctionModification mod = mods.at(i);
                         mod.signature = f->minimalSignature();
                         // If we ever need it... Below is the code to do
                         // substitution of the template instantation type inside
                         // injected code..
             #if 0
                         if (mod.modifiers & Modification::CodeInjection) {
                             for (int j=0; j<template_types.size(); ++j) {
                                 CodeSnip &snip = mod.snips.last();
                                 QString code = snip.code();
                                 code.replace(QString::fromLatin1("$$QT_TEMPLATE_%1$$").arg(j),
                                              template_types.at(j)->typeEntry()->qualifiedCppName());
                                 snip.codeList.clear();
                                 snip.addCode(code);
                             }
                         }
             #endif
                         te->addFunctionModification(mod);
                     }
                     subclass->addFunction(f);
                 }
                 // Clean up
                 foreach (AbstractMetaType *type, template_types) {
                     delete type;
                 }
                 {
                     subclass->setTemplateBaseClass(template_class);
                     subclass->setInterfaces(template_class->interfaces());
                     subclass->setBaseClass(template_class->baseClass());
                 }
                 return true;
             }
             void AbstractMetaBuilder::parseQ_Property(AbstractMetaClass *meta_class, const QStringList &declarations)
             {
                 for (int i=0; i<declarations.size(); ++i) {
                     QString p = declarations.at(i);
                     QStringList l = p.split(QLatin1String(" "));
                     QStringList qualifiedScopeName = currentScope()->qualifiedName();
                     bool ok = false;
                     AbstractMetaType *type = 0;
                     QString scope;
                     for (int j=qualifiedScopeName.size(); j>=0; --j) {
                         scope = j > 0 ? QStringList(qualifiedScopeName.mid(0, j)).join("::") + "::" : QString();
                         TypeInfo info;
                         info.setQualifiedName((scope + l.at(0)).split("::"));
                         type = translateType(info, &ok);
                         if (type != 0 && ok) {
                             break;
                         }
                     }
                     if (type == 0 || !ok) {
                         ReportHandler::warning(QString("Unable to decide type of property: '%1' in class '%2'")
                                                .arg(l.at(0)).arg(meta_class->name()));
                         continue;
                     }
                     QString typeName = scope + l.at(0);
                     QPropertySpec *spec = new QPropertySpec(type->typeEntry());
                     spec->setName(l.at(1));
                     spec->setIndex(i);
                     for (int pos=2; pos+1<l.size(); pos+=2) {
                         if (l.at(pos) == QLatin1String("READ"))
                             spec->setRead(l.at(pos+1));
                         else if (l.at(pos) == QLatin1String("WRITE"))
                             spec->setWrite(l.at(pos+1));
                         else if (l.at(pos) == QLatin1String("DESIGNABLE"))
                             spec->setDesignable(l.at(pos+1));
                         else if (l.at(pos) == QLatin1String("RESET"))
                             spec->setReset(l.at(pos+1));
                     }
                     meta_class->addPropertySpec(spec);
                     delete type;
                 }
             }
             static void hide_functions(const AbstractMetaFunctionList &l) {
                 foreach (AbstractMetaFunction *f, l) {
                     FunctionModification mod;
                     mod.signature = f->minimalSignature();
                     mod.modifiers = FunctionModification::Private;
                     ((ComplexTypeEntry *) f->implementingClass()->typeEntry())->addFunctionModification(mod);
                 }
             }
             static void remove_function(AbstractMetaFunction *f) {
                 FunctionModification mod;
                 mod.removal = TypeSystem::All;
                 mod.signature = f->minimalSignature();
                 ((ComplexTypeEntry *) f->implementingClass()->typeEntry())->addFunctionModification(mod);
             }
             static AbstractMetaFunctionList filter_functions(const AbstractMetaFunctionList &lst, QSet<QString> *signatures)
             {
                 AbstractMetaFunctionList functions;
                 foreach (AbstractMetaFunction *f, lst) {
                     QString signature = f->minimalSignature();
                     int start = signature.indexOf(QLatin1Char('(')) + 1;
                     int end = signature.lastIndexOf(QLatin1Char(')'));
                     signature = signature.mid(start, end - start);
                     if (signatures->contains(signature)) {
                         remove_function(f);
                         continue;
                     }
                     (*signatures) << signature;
                     functions << f;
                 }
                 return functions;
             }
             void AbstractMetaBuilder::setupEquals(AbstractMetaClass *cls)
             {
                 AbstractMetaFunctionList equals;
                 AbstractMetaFunctionList nequals;
                 QString op_equals = QLatin1String("operator_equal");
                 QString op_nequals = QLatin1String("operator_not_equal");
                 AbstractMetaFunctionList functions = cls->queryFunctions(AbstractMetaClass::ClassImplements
                                                                      | AbstractMetaClass::NotRemovedFromTargetLang);
                 foreach (AbstractMetaFunction *f, functions) {
                     if (f->name() == op_equals)
                         equals << f;
                     else if (f->name() == op_nequals)
                         nequals << f;
                 }
                 if (equals.size() || nequals.size()) {
                     if (!cls->hasHashFunction()) {
                         ReportHandler::warning(QString::fromLatin1("Class '%1' has equals operators but no qHash() function")
                                                .arg(cls->name()));
                     }
                     hide_functions(equals);
                     hide_functions(nequals);
                     // We only need == if we have both == and !=, and one == for
                     // each signature type, like QDateTime::==(QDate) and (QTime)
                     // if such a thing exists...
                     QSet<QString> func_signatures;
                     cls->setEqualsFunctions(filter_functions(equals, &func_signatures));
                     cls->setNotEqualsFunctions(filter_functions(nequals, &func_signatures));
                 }
             }
             void AbstractMetaBuilder::setupComparable(AbstractMetaClass *cls)
             {
                 AbstractMetaFunctionList greater;
                 AbstractMetaFunctionList greaterEquals;
                 AbstractMetaFunctionList less;
                 AbstractMetaFunctionList lessEquals;
                 QString op_greater = QLatin1String("operator_greater");
                 QString op_greater_eq = QLatin1String("operator_greater_or_equal");
                 QString op_less = QLatin1String("operator_less");
                 QString op_less_eq = QLatin1String("operator_less_or_equal");
                 AbstractMetaFunctionList functions = cls->queryFunctions(AbstractMetaClass::ClassImplements
                                                                      | AbstractMetaClass::NotRemovedFromTargetLang);
                 foreach (AbstractMetaFunction *f, functions) {
                     if (f->name() == op_greater)
                         greater << f;
                     else if (f->name() == op_greater_eq)
                         greaterEquals << f;
                     else if (f->name() == op_less)
                         less << f;
                     else if (f->name() == op_less_eq)
                         lessEquals << f;
                 }
                 bool hasEquals = cls->equalsFunctions().size() || cls->notEqualsFunctions().size();
                 // Conditions for comparable is:
                 //     >, ==, <             - The basic case
                 //     >, ==                - Less than becomes else case
                 //     <, ==                - Greater than becomes else case
                 //     >=, <=               - if (<= && >=) -> equal
                 bool mightBeComparable = greater.size() || greaterEquals.size() || less.size() || lessEquals.size()
                                     || greaterEquals.size() == 1 || lessEquals.size() == 1;
                 if (mightBeComparable) {
                     QSet<QString> signatures;
                     // We only hide the original functions if we are able to make a compareTo() method
                     bool wasComparable = false;
                     // The three upper cases, prefer the <, == approach
                     if (hasEquals && (greater.size() || less.size())) {
                         cls->setLessThanFunctions(filter_functions(less, &signatures));
                         cls->setGreaterThanFunctions(filter_functions(greater, &signatures));
                         filter_functions(greaterEquals, &signatures);
                         filter_functions(lessEquals, &signatures);
                         wasComparable = true;
                     } else if (hasEquals && (greaterEquals.size() || lessEquals.size())) {
                         cls->setLessThanEqFunctions(filter_functions(lessEquals, &signatures));
                         cls->setGreaterThanEqFunctions(filter_functions(greaterEquals, &signatures));
                         wasComparable = true;
                     } else if (greaterEquals.size() == 1 || lessEquals.size() == 1) {
                         cls->setGreaterThanEqFunctions(greaterEquals);
                         cls->setLessThanEqFunctions(lessEquals);
                         filter_functions(less, &signatures);
                         filter_functions(greater, &signatures);
                         wasComparable = true;
                     }
                     if (wasComparable) {
                         hide_functions(greater);
                         hide_functions(greaterEquals);
                         hide_functions(less);
                         hide_functions(lessEquals);
                     }
                 }
             }
             void AbstractMetaBuilder::setupClonable(AbstractMetaClass *cls)
             {
                 QString op_assign = QLatin1String("operator_assign");
                 AbstractMetaFunctionList functions = cls->queryFunctions(AbstractMetaClass::ClassImplements);
                 foreach (AbstractMetaFunction *f, functions) {
                     if ((f->name() == op_assign || f->isConstructor()) && f->isPublic()) {
                         AbstractMetaArgumentList arguments = f->arguments();
                         if (arguments.size() == 1) {
                             if (cls->typeEntry()->qualifiedCppName() == arguments.at(0)->type()->typeEntry()->qualifiedCppName()) {
                                 if (cls->typeEntry()->isValue()) {
                                     cls->setHasCloneOperator(true);
                                     return;
                                 }
                             }
                         }
                     }
                 }
             }
             static void write_reject_log_file(const QString &name,
                                               const QMap<QString, AbstractMetaBuilder::RejectReason> &rejects)
             {
                 QFile f(name);
                 if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
                     ReportHandler::warning(QString("failed to write log file: '%1'")
                                            .arg(f.fileName()));
                     return;
                 }
                 QTextStream s(&f);
                 for (int reason=0; reason<AbstractMetaBuilder::NoReason; ++reason) {
                     s << QString(72, '*') << endl;
                     switch (reason) {
                     case AbstractMetaBuilder::NotInTypeSystem:
                         s << "Not in type system";
                         break;
                     case AbstractMetaBuilder::GenerationDisabled:
                         s << "Generation disabled by type system";
                         break;
                     case AbstractMetaBuilder::RedefinedToNotClass:
                         s << "Type redefined to not be a class";
                         break;
                     case AbstractMetaBuilder::UnmatchedReturnType:
                         s << "Unmatched return type";
                         break;
                     case AbstractMetaBuilder::UnmatchedArgumentType:
                         s << "Unmatched argument type";
                         break;
                     default:
                         s << "unknown reason";
                         break;
                     }
                     s << endl;
                     for (QMap<QString, AbstractMetaBuilder::RejectReason>::const_iterator it = rejects.constBegin();
                          it != rejects.constEnd(); ++it) {
                         if (it.value() != reason)
                             continue;
                         s << " - " << it.key() << endl;
                     }
                     s << QString(72, '*') << endl << endl;
                 }
             }
             void AbstractMetaBuilder::dumpLog()
             {
                 write_reject_log_file("mjb_rejected_classes.log", m_rejected_classes);
                 write_reject_log_file("mjb_rejected_enums.log", m_rejected_enums);
                 write_reject_log_file("mjb_rejected_functions.log", m_rejected_functions);
                 write_reject_log_file("mjb_rejected_fields.log", m_rejected_fields);
             }
             AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted() const
             {
                 AbstractMetaClassList res;
                 AbstractMetaClassList classes = m_meta_classes;
                 qSort(classes);
                 QSet<AbstractMetaClass*> noDependency;
                 QHash<AbstractMetaClass*, QSet<AbstractMetaClass* >* > hash;
                 foreach (AbstractMetaClass *cls, classes) {
                     QSet<AbstractMetaClass* > *depends = new QSet<AbstractMetaClass* >();
                     if (cls->baseClass())
                         depends->insert(cls->baseClass());
                     foreach (AbstractMetaClass *interface, cls->interfaces()) {
                         AbstractMetaClass *impl = interface->primaryInterfaceImplementor();
                         if (impl == cls)
                             continue;
                         depends->insert(impl);
                     }
                     if (depends->empty()) {
                         noDependency.insert(cls);
                     } else {
                         hash.insert(cls, depends);
                     }
                 }
                 while (!noDependency.empty()) {
                     foreach (AbstractMetaClass *cls, noDependency.values()) {
                         if(!cls->isInterface())
                             res.append(cls);
                         noDependency.remove(cls);
                         QHashIterator<AbstractMetaClass*, QSet<AbstractMetaClass* >* > i(hash);
                         while (i.hasNext()) {
                             i.next();
                             i.value()->remove(cls);
                             if (i.value()->empty()) {
                                 AbstractMetaClass *key = i.key();
                                 noDependency.insert(key);
                                 hash.remove(key);
                                 delete(i.value());
                             }
                         }
                     }
                 }
                 if (!noDependency.empty() || !hash.empty()) {
                     qWarning("dependency graph was cyclic.");
                 }
                 return res;
             }

generator/abstractmetalang.cpp +10 0

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $QT_BEGIN_LICENSE:LGPL$
             ** No Commercial Usage
             ** This file contains pre-release code and may not be distributed.
             ** You may use this file in accordance with the terms and conditions
             ** contained in the Technology Preview License Agreement accompanying
             ** this package.
             **
             ** GNU Lesser General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU Lesser
             ** General Public License version 2.1 as published by the Free Software
             ** Foundation and appearing in the file LICENSE.LGPL included in the
             ** packaging of this file.  Please review the following information to
             ** ensure the GNU Lesser General Public License version 2.1 requirements
             ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
             **
             ** In addition, as a special exception, Nokia gives you certain additional
             ** rights.  These rights are described in the Nokia Qt LGPL Exception
             ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
             **
             ** If you have questions regarding the use of this file, please contact
             ** Nokia at qt-info@nokia.com.
             **
             **
             **
             **
             **
             **
             **
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "abstractmetalang.h"
             #include "reporthandler.h"
             /*******************************************************************************
              * AbstractMetaType
              */
             AbstractMetaType *AbstractMetaType::copy() const
             {
                 AbstractMetaType *cpy = new AbstractMetaType;
                 cpy->setTypeUsagePattern(typeUsagePattern());
                 cpy->setConstant(isConstant());
                 cpy->setReference(isReference());
                 cpy->setIndirections(indirections());
             	cpy->setInstantiations(instantiations());
                 cpy->setArrayElementCount(arrayElementCount());
                 cpy->setOriginalTypeDescription(originalTypeDescription());
                 cpy->setOriginalTemplateType(originalTemplateType() ? originalTemplateType()->copy() : 0);
                 cpy->setArrayElementType(arrayElementType() ? arrayElementType()->copy() : 0);
                 cpy->setTypeEntry(typeEntry());
                 return cpy;
             }
             QString AbstractMetaType::cppSignature() const
             {
                 QString s;
                 if (isConstant())
                     s += "const ";
                 s += typeEntry()->qualifiedCppName();
                 if (hasInstantiationInCpp()) {
                     QList<AbstractMetaType *> types = instantiations();
                     s += "<";
                     for (int i=0; i<types.count(); ++i) {
                         if (i > 0)
                             s += ", ";
                         s += types.at(i)->cppSignature();
                     }
                     s += " >";
                 }
                 if (actualIndirections()) {
                     s += ' ';
                     if (indirections())
                         s += QString(indirections(), '*');
                     if (isReference())
                         s += '&';
                 }
                 return s;
             }
             /*******************************************************************************
              * AbstractMetaArgument
              */
             AbstractMetaArgument *AbstractMetaArgument::copy() const
             {
                 AbstractMetaArgument *cpy = new AbstractMetaArgument;
                 cpy->setName(AbstractMetaVariable::name());
                 cpy->setDefaultValueExpression(defaultValueExpression());
                 cpy->setType(type()->copy());
                 cpy->setArgumentIndex(argumentIndex());
                 return cpy;
             }
             QString AbstractMetaArgument::argumentName() const
             {
                 QString n = AbstractMetaVariable::name();
                 if (n.isEmpty()) {
                     return QString("arg__%2").arg(m_argument_index + 1);
                 }
                 return n;
             }
             QString AbstractMetaArgument::indexedName() const
             {
                 QString n = AbstractMetaVariable::name();
                 if (n.isEmpty())
                     return argumentName();
                 return QString("%1%2").arg(n).arg(m_argument_index);
             }
             QString AbstractMetaArgument::name() const
             {
                 Q_ASSERT_X(0, "AbstractMetaArgument::name()", "use argumentName() or indexedName() instead");
                 return QString();
             }
             /*******************************************************************************
              * AbstractMetaFunction
              */
             AbstractMetaFunction::~AbstractMetaFunction()
             {
                 qDeleteAll(m_arguments);
                 delete m_type;
             }
             /*******************************************************************************
              * Indicates that this function has a modification that removes it
              */
             bool AbstractMetaFunction::isModifiedRemoved(int types) const
             {
                 FunctionModificationList mods = modifications(implementingClass());
                 foreach (FunctionModification mod, mods) {
                     if (!mod.isRemoveModifier())
                         continue;
                     if ((mod.removal & types) == types)
                         return true;
                 }
                 return false;
             }
             bool AbstractMetaFunction::needsCallThrough() const
             {
                 if (ownerClass()->isInterface())
                     return false;
                 if (referenceCounts(implementingClass()).size() > 0)
                     return true;
                 if (argumentsHaveNativeId() || !isStatic())
                     return true;
                 foreach (const AbstractMetaArgument *arg, arguments()) {
                     if (arg->type()->isArray() || arg->type()->isTargetLangEnum() || arg->type()->isTargetLangFlags())
                         return true;
                 }
                 if (type() && (type()->isArray() || type()->isTargetLangEnum() || type()->isTargetLangFlags()))
                     return true;
                 for (int i=-1; i<=arguments().size(); ++i) {
                     TypeSystem::Ownership owner = this->ownership(implementingClass(), TypeSystem::TargetLangCode, i);
                     if (owner != TypeSystem::InvalidOwnership)
                         return true;
                 }
                 return false;
             }
             bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
             {
                 for (int i=-1; i<=arguments().size(); ++i) {
                     QList<ReferenceCount> referenceCounts = this->referenceCounts(implementingClass(), i);
                     foreach (ReferenceCount referenceCount, referenceCounts) {
                         if (referenceCount.action != ReferenceCount::Set)
                             return true;
                     }
                 }
                 return false;
             }
             QString AbstractMetaFunction::marshalledName() const
             {
                 QString returned = "__qt_" + name();
                 AbstractMetaArgumentList arguments = this->arguments();
                 foreach (const AbstractMetaArgument *arg, arguments) {
                     returned += "_";
                     if (arg->type()->isNativePointer()) {
                         returned += "nativepointer";
                     } else if (arg->type()->isIntegerEnum() || arg->type()->isIntegerFlags()) {
                         returned += "int";
                     } else {
                         returned += arg->type()->name().replace("[]", "_3").replace(".", "_");
                     }
                 }
                 return returned;
             }
             bool AbstractMetaFunction::operator<(const AbstractMetaFunction &other) const
             {
                 uint result = compareTo(&other);
                 return result & NameLessThan;
             }
             /*!
                 Returns a mask of CompareResult describing how this function is
                 compares to another function
             */
             uint AbstractMetaFunction::compareTo(const AbstractMetaFunction *other) const
             {
                 uint result = 0;
                 // Enclosing class...
                 if (ownerClass() == other->ownerClass()) {
                     result |= EqualImplementor;
                 }
                 // Attributes
                 if (attributes() == other->attributes()) {
                     result |= EqualAttributes;
                 }
                 // Compare types
                 AbstractMetaType *t = type();
                 AbstractMetaType *ot = other->type();
                 if ((!t && !ot) || ((t && ot && t->name() == ot->name()))) {
                     result |= EqualReturnType;
                 }
                 // Compare names
                 int cmp = originalName().compare(other->originalName());
                 if (cmp < 0) {
                     result |= NameLessThan;
                 } else if (cmp == 0) {
                     result |= EqualName;
                 }
                 // compare name after modification...
                 cmp = modifiedName().compare(other->modifiedName());
                 if (cmp == 0)
                     result |= EqualModifiedName;
                 // Compare arguments...
                 AbstractMetaArgumentList min_arguments;
                 AbstractMetaArgumentList max_arguments;
                 if (arguments().size() < other->arguments().size()) {
                     min_arguments = arguments();
                     max_arguments = other->arguments();
                 } else {
                     min_arguments = other->arguments();
                     max_arguments = arguments();
                 }
                 int min_count = min_arguments.size();
                 int max_count = max_arguments.size();
                 bool same = true;
                 for (int i=0; i<max_count; ++i) {
                     if (i < min_count) {
                         const AbstractMetaArgument *min_arg = min_arguments.at(i);
                         const AbstractMetaArgument *max_arg = max_arguments.at(i);
                         if (min_arg->type()->name() != max_arg->type()->name()
                             && (min_arg->defaultValueExpression().isEmpty() || max_arg->defaultValueExpression().isEmpty())) {
                             same = false;
                             break;
                         }
                     } else {
                         if (max_arguments.at(i)->defaultValueExpression().isEmpty()) {
                             same = false;
                             break;
                         }
                     }
                 }
                 if (same)
                     result |= min_count == max_count ? EqualArguments : EqualDefaultValueOverload;
                 return result;
             }
             AbstractMetaFunction *AbstractMetaFunction::copy() const
             {
                 AbstractMetaFunction *cpy = new AbstractMetaFunction;
                 cpy->setName(name());
                 cpy->setOriginalName(originalName());
                 cpy->setOwnerClass(ownerClass());
                 cpy->setImplementingClass(implementingClass());
                 cpy->setInterfaceClass(interfaceClass());
                 cpy->setFunctionType(functionType());
                 cpy->setAttributes(attributes());
                 cpy->setDeclaringClass(declaringClass());
                 if (type())
                     cpy->setType(type()->copy());
                 cpy->setConstant(isConstant());
                 cpy->setOriginalAttributes(originalAttributes());
                 foreach (AbstractMetaArgument *arg, arguments())
                     cpy->addArgument(arg->copy());
                 Q_ASSERT((!type() && !cpy->type())
                          || (type()->instantiations() == cpy->type()->instantiations()));
                 return cpy;
             }
             QStringList AbstractMetaFunction::introspectionCompatibleSignatures(const QStringList &resolvedArguments) const
             {
                 AbstractMetaArgumentList arguments = this->arguments();
                 if (arguments.size() == resolvedArguments.size()) {
                     return (QStringList() << QMetaObject::normalizedSignature((name() + "(" + resolvedArguments.join(",") + ")").toUtf8().constData()));
                 } else {
                     QStringList returned;
                     AbstractMetaArgument *argument = arguments.at(resolvedArguments.size());
                     QStringList minimalTypeSignature = argument->type()->minimalSignature().split("::");
                     for (int i=0; i<minimalTypeSignature.size(); ++i) {
                         returned += introspectionCompatibleSignatures(QStringList(resolvedArguments)
                             << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join("::"));
                     }
                     return returned;
                 }
             }
             QString AbstractMetaFunction::signature() const
             {
                 QString s(m_original_name);
                 s += "(";
                 for (int i=0; i<m_arguments.count(); ++i) {
                     if (i > 0)
                         s += ", ";
                     AbstractMetaArgument *a = m_arguments.at(i);
                     s += a->type()->cppSignature();
                     // We need to have the argument names in the qdoc files
                     s += " ";
                     s += a->argumentName();
                 }
                 s += ")";
                 if (isConstant())
                     s += " const";
                 return s;
             }
             int AbstractMetaFunction::actualMinimumArgumentCount() const
             {
                 AbstractMetaArgumentList arguments = this->arguments();
                 int count = 0;
                 for (int i=0; i<arguments.size(); ++i && ++count) {
                     if (argumentRemoved(i + 1)) --count;
                     else if (!arguments.at(i)->defaultValueExpression().isEmpty()) break;
                 }
                 return count;
             }
             // Returns reference counts for argument at idx, or all arguments if idx == -2
             QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaClass *cls, int idx) const
             {
                 QList<ReferenceCount> returned;
                 FunctionModificationList mods = this->modifications(cls);
                 foreach (FunctionModification mod, mods) {
                     QList<ArgumentModification> argument_mods = mod.argument_mods;
                     foreach (ArgumentModification argument_mod, argument_mods) {
                         if (argument_mod.index != idx && idx != -2)
                             continue;
                         returned += argument_mod.referenceCounts;
                     }
                 }
                 return returned;
             }
             QString AbstractMetaFunction::replacedDefaultExpression(const AbstractMetaClass *cls, int key) const
             {
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key
                             && !argument_modification.replaced_default_expression.isEmpty()) {
                             return argument_modification.replaced_default_expression;
                         }
                     }
                 }
                 return QString();
             }
             bool AbstractMetaFunction::removedDefaultExpression(const AbstractMetaClass *cls, int key) const
             {
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key
                             && argument_modification.removed_default_expression) {
                             return true;
                         }
                     }
                 }
                 return false;
             }
             bool AbstractMetaFunction::resetObjectAfterUse(int argument_idx) const
             {
                 const AbstractMetaClass *cls = declaringClass();
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argumentModifications = modification.argument_mods;
                     foreach (ArgumentModification argumentModification, argumentModifications) {
                         if (argumentModification.index == argument_idx && argumentModification.reset_after_use)
                             return true;
                     }
                 }
                 return false;
             }
             QString AbstractMetaFunction::nullPointerDefaultValue(const AbstractMetaClass *mainClass, int argument_idx) const
             {
                 Q_ASSERT(nullPointersDisabled(mainClass, argument_idx));
                 const AbstractMetaClass *cls = mainClass;
                 if (cls == 0)
                     cls = implementingClass();
                 do {
                     FunctionModificationList modifications = this->modifications(cls);
                     foreach (FunctionModification modification, modifications) {
                         QList<ArgumentModification> argument_modifications = modification.argument_mods;
                         foreach (ArgumentModification argument_modification, argument_modifications) {
                             if (argument_modification.index == argument_idx
                                 && argument_modification.no_null_pointers) {
                                 return argument_modification.null_pointer_default_value;
                             }
                         }
                     }
                     cls = cls->baseClass();
                 } while (cls != 0 && mainClass == 0); // Once when mainClass != 0, or once for all base classes of implementing class
                 return QString();
             }
             bool AbstractMetaFunction::nullPointersDisabled(const AbstractMetaClass *mainClass, int argument_idx) const
             {
                 const AbstractMetaClass *cls = mainClass;
                 if (cls == 0)
                     cls = implementingClass();
                 do {
                     FunctionModificationList modifications = this->modifications(cls);
                     foreach (FunctionModification modification, modifications) {
                         QList<ArgumentModification> argument_modifications = modification.argument_mods;
                         foreach (ArgumentModification argument_modification, argument_modifications) {
                             if (argument_modification.index == argument_idx
                                 && argument_modification.no_null_pointers) {
                                 return true;
                             }
                         }
                     }
                     cls = cls->baseClass();
                 } while (cls != 0 && mainClass == 0); // Once when mainClass != 0, or once for all base classes of implementing class
                 return false;
             }
             QString AbstractMetaFunction::conversionRule(TypeSystem::Language language, int key) const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index != key)
                             continue;
                         foreach (CodeSnip snip, argument_modification.conversion_rules) {
                             if (snip.language == language && !snip.code().isEmpty())
                                 return snip.code();
                         }
                     }
                 }
                 return QString();
             }
             QString AbstractMetaFunction::argumentReplaced(int key) const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key && !argument_modification.replace_value.isEmpty()) {
                             return argument_modification.replace_value;
                         }
                     }
                 }
                 return "";
             }
             bool AbstractMetaFunction::argumentRemoved(int key) const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key) {
                             if (argument_modification.removed) {
                                 return true;
                             }
                         }
                     }
                 }
                 return false;
             }
             bool AbstractMetaFunction::isVirtualSlot() const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     if (modification.isVirtualSlot())
                         return true;
                 }
                 return false;
             }
             bool AbstractMetaFunction::disabledGarbageCollection(const AbstractMetaClass *cls, int key) const
             {
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index != key)
                             continue;
                         foreach (TypeSystem::Ownership ownership, argument_modification.ownerships.values()) {
                             if (ownership == TypeSystem::CppOwnership)
                                 return true;
                         }
                     }
                 }
                 return false;
             }
             bool AbstractMetaFunction::isDeprecated() const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     if (modification.isDeprecated())
                         return true;
                 }
                 return false;
             }
             TypeSystem::Ownership AbstractMetaFunction::ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int key) const
             {
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key)
                             return argument_modification.ownerships.value(language, TypeSystem::InvalidOwnership);
                     }
                 }
                 return TypeSystem::InvalidOwnership;
             }
             bool AbstractMetaFunction::isRemovedFromAllLanguages(const AbstractMetaClass *cls) const
             {
                 return isRemovedFrom(cls, TypeSystem::All);
             }
             bool AbstractMetaFunction::isRemovedFrom(const AbstractMetaClass *cls, TypeSystem::Language language) const
             {
                 FunctionModificationList modifications = this->modifications(cls);
                 foreach (FunctionModification modification, modifications) {
                     if ((modification.removal & language) == language)
                         return true;
                 }
                 return false;
             }
             QString AbstractMetaFunction::typeReplaced(int key) const
             {
                 FunctionModificationList modifications = this->modifications(declaringClass());
                 foreach (FunctionModification modification, modifications) {
                     QList<ArgumentModification> argument_modifications = modification.argument_mods;
                     foreach (ArgumentModification argument_modification, argument_modifications) {
                         if (argument_modification.index == key
                             && !argument_modification.modified_type.isEmpty()) {
                             return argument_modification.modified_type;
                         }
                     }
                 }
                 return QString();
             }
             QString AbstractMetaFunction::minimalSignature() const
             {
                 if (!m_cached_minimal_signature.isEmpty())
                     return m_cached_minimal_signature;
                 QString minimalSignature = originalName() + "(";
                 AbstractMetaArgumentList arguments = this->arguments();
                 for (int i=0; i<arguments.count(); ++i) {
                     AbstractMetaType *t = arguments.at(i)->type();
                     if (i > 0)
                         minimalSignature += ",";
                     minimalSignature += t->minimalSignature();
                 }
                 minimalSignature += ")";
                 if (isConstant())
                     minimalSignature += "const";
                 minimalSignature = QMetaObject::normalizedSignature(minimalSignature.toLocal8Bit().constData());
                 m_cached_minimal_signature = minimalSignature;
                 return minimalSignature;
             }
             FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass *implementor) const
             {
                 Q_ASSERT(implementor);
                 return implementor->typeEntry()->functionModifications(minimalSignature());
             }
             bool AbstractMetaFunction::hasModifications(const AbstractMetaClass *implementor) const
             {
                 FunctionModificationList mods = modifications(implementor);
                 return mods.count() > 0;
             }
             QString AbstractMetaFunction::modifiedName() const
             {
                 if (m_cached_modified_name.isEmpty()) {
                     FunctionModificationList mods = modifications(implementingClass());
                     foreach (FunctionModification mod, mods) {
                         if (mod.isRenameModifier()) {
                             m_cached_modified_name = mod.renamedToName;
                             break;
                         }
                     }
                     if (m_cached_modified_name.isEmpty())
                         m_cached_modified_name = name();
                 }
                 return m_cached_modified_name;
             }
             QString AbstractMetaFunction::targetLangSignature(bool minimal) const
             {
                 QString s;
                 // Attributes...
                 if (!minimal) {
             #if 0 // jambi
                     if (isPublic()) s += "public ";
                     else if (isProtected()) s += "protected ";
                     else if (isPrivate()) s += "private ";
             //     if (isNative()) s += "native ";
             //     else
                     if (isFinalInTargetLang()) s += "final ";
                     else if (isAbstract()) s += "abstract ";
                     if (isStatic()) s += "static ";
             #endif
                     // Return type
                     if (type())
                         s += type()->name() + " ";
                     else
                         s += "void ";
                 }
                 s += modifiedName();
                 s += "(";
                 int j = 0;
                 for (int i=0; i<m_arguments.size(); ++i) {
                     if (argumentRemoved(i+1))
                         continue;
                     if (j != 0) {
                         s += ",";
                         if (!minimal)
                             s += QLatin1Char(' ');
                     }
                     s += m_arguments.at(i)->type()->name();
                     if (!minimal) {
                         s += " ";
                         s += m_arguments.at(i)->argumentName();
                     }
                     ++j;
                 }
                 s += ")";
                 return s;
             }
             bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b)
             {
                 return a->signature() < b->signature();
             }
             /*******************************************************************************
              * AbstractMetaClass
              */
             AbstractMetaClass::~AbstractMetaClass()
             {
                 qDeleteAll(m_functions);
                 qDeleteAll(m_fields);
             }
             /*AbstractMetaClass *AbstractMetaClass::copy() const
             {
                 AbstractMetaClass *cls = new AbstractMetaClass;
                 cls->setAttributes(attributes());
                 cls->setBaseClass(baseClass());
                 cls->setTypeEntry(typeEntry());
                 foreach (AbstractMetaFunction *function, functions()) {
                     AbstractMetaFunction *copy = function->copy();
                     function->setImplementingClass(cls);
                     cls->addFunction(copy);
                 }
                 cls->setEnums(enums());
                 foreach (const AbstractMetaField *field, fields()) {
                     AbstractMetaField *copy = field->copy();
                     copy->setEnclosingClass(cls);
                     cls->addField(copy);
                 }
                 cls->setInterfaces(interfaces());
                 return cls;
             }*/
             /*******************************************************************************
              * Returns true if this class is a subclass of the given class
              */
             bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const
             {
                 Q_ASSERT(cls != 0);
                 const AbstractMetaClass *clazz = this;
                 while (clazz != 0) {
                     if (clazz == cls)
                         return true;
                     clazz = clazz->baseClass();
                 }
                 return false;
             }
             /*******************************************************************************
              * Constructs an interface based on the functions and enums in this
              * class and returns it...
              */
             AbstractMetaClass *AbstractMetaClass::extractInterface()
             {
                 Q_ASSERT(typeEntry()->designatedInterface());
                 if (m_extracted_interface == 0) {
                     AbstractMetaClass *iface = new AbstractMetaClass;
                     iface->setAttributes(attributes());
                     iface->setBaseClass(0);
                     iface->setPrimaryInterfaceImplementor(this);
                     iface->setTypeEntry(typeEntry()->designatedInterface());
                     foreach (AbstractMetaFunction *function, functions()) {
                         if (!function->isConstructor())
                             iface->addFunction(function->copy());
                     }
             //         iface->setEnums(enums());
             //         setEnums(AbstractMetaEnumList());
                     foreach (const AbstractMetaField *field, fields()) {
                         if (field->isPublic()) {
                             AbstractMetaField *new_field = field->copy();
                             new_field->setEnclosingClass(iface);
                             iface->addField(new_field);
                         }
                     }
                     m_extracted_interface = iface;
                     addInterface(iface);
                 }
                 return m_extracted_interface;
             }
             /*******************************************************************************
              * Returns a list of all the functions with a given name
              */
             AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
             {
                 AbstractMetaFunctionList returned;
                 AbstractMetaFunctionList functions = this->functions();
                 foreach (AbstractMetaFunction *function, functions) {
                     if (function->name() == name)
                         returned.append(function);
                 }
                 return returned;
             }
+            bool AbstractMetaClass::hasDefaultIsNull() const
+            {
+              foreach(const AbstractMetaFunction* fun, queryFunctionsByName("isNull")) {
+                if (fun->actualMinimumArgumentCount()==0) {
+                  return true;
+                }
+              }
+              return false;
+            }
             /*******************************************************************************
              * Returns all reference count modifications for any function in the class
              */
             QList<ReferenceCount> AbstractMetaClass::referenceCounts() const
             {
                 QList<ReferenceCount> returned;
                 AbstractMetaFunctionList functions = this->functions();
                 foreach (AbstractMetaFunction *function, functions) {
                     returned += function->referenceCounts(this);
                 }
                 return returned;
             }
             /*******************************************************************************
              * Returns a list of all the functions retrieved during parsing which should
              * be added to the Java API.
              */
             AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
             {
                 int default_flags = NormalFunctions | Visible | NotRemovedFromTargetLang;
                 // Interfaces don't implement functions
                 default_flags |= isInterface() ? 0 : ClassImplements;
                 // Only public functions in final classes
                 // default_flags |= isFinal() ? WasPublic : 0;
                 int public_flags = isFinal() ? WasPublic : 0;
                 // Constructors
                 AbstractMetaFunctionList returned = queryFunctions(Constructors | default_flags | public_flags);
                 // Final functions
                 returned += queryFunctions(FinalInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags);
                 // Virtual functions
                 returned += queryFunctions(VirtualInTargetLangFunctions | NonStaticFunctions | default_flags | public_flags);
                 // Static functions
                 returned += queryFunctions(StaticFunctions | default_flags | public_flags);
                 // Empty, private functions, since they aren't caught by the other ones
                 returned += queryFunctions(Empty | Invisible);
                 return returned;
             }
             AbstractMetaFunctionList AbstractMetaClass::virtualFunctions() const
             {
                 AbstractMetaFunctionList list = functionsInShellClass();
                 AbstractMetaFunctionList returned;
                 foreach (AbstractMetaFunction *f, list) {
                     if (!f->isFinalInCpp() || f->isVirtualSlot())
                         returned += f;
                 }
                 return returned;
             }
             AbstractMetaFunctionList AbstractMetaClass::nonVirtualShellFunctions() const
             {
                 AbstractMetaFunctionList list = functionsInShellClass();
                 AbstractMetaFunctionList returned;
                 foreach (AbstractMetaFunction *f, list) {
                     if (f->isFinalInCpp() && !f->isVirtualSlot())
                         returned += f;
                 }
                 return returned;
             }
             /*******************************************************************************
              * Returns a list of all functions that should be declared and implemented in
              * the shell class which is generated as a wrapper on top of the actual C++ class
              */
             AbstractMetaFunctionList AbstractMetaClass::functionsInShellClass() const
             {
                 // Only functions and only protected and public functions
                 int default_flags = NormalFunctions | Visible | WasVisible | NotRemovedFromShell;
                 // All virtual functions
                 AbstractMetaFunctionList returned = queryFunctions(VirtualFunctions | default_flags);
                 // All functions explicitly set to be implemented by the shell class
                 // (mainly superclass functions that are hidden by other declarations)
                 returned += queryFunctions(ForcedShellFunctions | default_flags);
                 // All functions explicitly set to be virtual slots
                 returned += queryFunctions(VirtualSlots | default_flags);
                 return returned;
             }
             /*******************************************************************************
              * Returns a list of all functions that require a public override function to
              * be generated in the shell class. This includes all functions that were originally
              * protected in the superclass.
              */
             AbstractMetaFunctionList AbstractMetaClass::publicOverrideFunctions() const
             {
                 return queryFunctions(NormalFunctions | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang)
                      + queryFunctions(Signals | WasProtected | FinalInCppFunctions | NotRemovedFromTargetLang);
             }
             AbstractMetaFunctionList AbstractMetaClass::virtualOverrideFunctions() const
             {
                 return queryFunctions(NormalFunctions | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell) +
                        queryFunctions(Signals | NonEmptyFunctions | Visible | VirtualInCppFunctions | NotRemovedFromShell);
             }
             void AbstractMetaClass::sortFunctions()
             {
                 qSort(m_functions.begin(), m_functions.end(), function_sorter);
             }
             void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
             {
                 m_functions = functions;
                 // Functions must be sorted by name before next loop
                 sortFunctions();
                 QString currentName;
                 bool hasVirtuals = false;
                 AbstractMetaFunctionList final_functions;
                 foreach (AbstractMetaFunction *f, m_functions) {
                     f->setOwnerClass(this);
                     m_has_virtual_slots |= f->isVirtualSlot();
                     m_has_virtuals |= !f->isFinal() || f->isVirtualSlot();
                     m_has_nonpublic |= !f->isPublic();
                     // If we have non-virtual overloads of a virtual function, we have to implement
                     // all the overloads in the shell class to override the hiding rule
                     if (currentName == f->name()) {
                         hasVirtuals = hasVirtuals || !f->isFinal();
                         if (f->isFinal())
                             final_functions += f;
                     } else {
                         if (hasVirtuals && final_functions.size() > 0) {
                             foreach (AbstractMetaFunction *final_function, final_functions) {
                                 *final_function += AbstractMetaAttributes::ForceShellImplementation;
                                 QString warn = QString("hiding of function '%1' in class '%2'")
                                     .arg(final_function->name()).arg(name());
                                 ReportHandler::warning(warn);
                             }
                         }
                         hasVirtuals = !f->isFinal();
                         final_functions.clear();
                         if (f->isFinal())
                             final_functions += f;
                         currentName = f->name();
                     }
                 }
             #ifndef QT_NO_DEBUG
                 bool duplicate_function = false;
                 for (int j=0; j<m_functions.size(); ++j) {
                     FunctionModificationList mods = m_functions.at(j)->modifications(m_functions.at(j)->implementingClass());
                     bool removed = false;
                     foreach (const FunctionModification &mod, mods) {
                         if (mod.isRemoveModifier()) {
                             removed = true;
                             break ;
                         }
                     }
                     if (removed)
                         continue ;
                     for (int i=0; i<m_functions.size() - 1; ++i) {
                         if (j == i)
                             continue;
                         mods = m_functions.at(i)->modifications(m_functions.at(i)->implementingClass());
                         bool removed = false;
                         foreach (const FunctionModification &mod, mods) {
                             if (mod.isRemoveModifier()) {
                                 removed = true;
                                 break ;
                             }
                         }
                         if (removed)
                             continue ;
                         uint cmp = m_functions.at(i)->compareTo(m_functions.at(j));
                         if ((cmp & AbstractMetaFunction::EqualName) && (cmp & AbstractMetaFunction::EqualArguments)) {
                             printf("%s.%s mostly equal to %s.%s\n",
                                    qPrintable(m_functions.at(i)->implementingClass()->typeEntry()->qualifiedCppName()),
                                    qPrintable(m_functions.at(i)->signature()),
                                    qPrintable(m_functions.at(j)->implementingClass()->typeEntry()->qualifiedCppName()),
                                    qPrintable(m_functions.at(j)->signature()));
                             duplicate_function = true;
                         }
                     }
                 }
                 //Q_ASSERT(!duplicate_function);
             #endif
             }
             bool AbstractMetaClass::hasFieldAccessors() const
             {
                 foreach (const AbstractMetaField *field, fields()) {
                     if (field->getter() || field->setter())
                         return true;
                 }
                 return false;
             }
             bool AbstractMetaClass::hasDefaultToStringFunction() const
             {
                 foreach (AbstractMetaFunction *f, queryFunctionsByName("toString")) {
                     if (f->actualMinimumArgumentCount() == 0) {
                         return true;
                     }
                 }
                 return false;
             }
             void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
             {
                 function->setOwnerClass(this);
                 if (!function->isDestructor()) {
                     m_functions << function;
                     qSort(m_functions.begin(), m_functions.end(), function_sorter);
                 }
                 m_has_virtual_slots |= function->isVirtualSlot();
                 m_has_virtuals |= !function->isFinal() || function->isVirtualSlot();
                 m_has_nonpublic |= !function->isPublic();
             }
             bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
             {
                 if (!other->isSignal())
                     return false;
                 foreach (const AbstractMetaFunction *f, functions()) {
                     if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName)
                         return other->modifiedName() == f->modifiedName();
                 }
                 return false;
             }
             QString AbstractMetaClass::name() const
             {
                 return QString(m_type_entry->targetLangName()).replace("::", "_");
             }
             bool AbstractMetaClass::hasFunction(const QString &str) const
             {
                 foreach (const AbstractMetaFunction *f, functions())
                     if (f->name() == str)
                         return true;
                 return false;
             }
             /* Returns true if this class has one or more functions that are
                protected. If a class has protected members we need to generate a
                shell class with public accessors to the protected functions, so
                they can be called from the native functions.
             */
             bool AbstractMetaClass::hasProtectedFunctions() const {
                 foreach (AbstractMetaFunction *func, m_functions) {
                     if (func->isProtected())
                         return true;
                 }
                 return false;
             }
             bool AbstractMetaClass::generateShellClass() const
             {
                 return m_force_shell_class ||
                     (!isFinal()
                      && (hasVirtualFunctions()
                          || hasProtectedFunctions()
                          || hasFieldAccessors()));
             }
             QPropertySpec *AbstractMetaClass::propertySpecForRead(const QString &name) const
             {
                 for (int i=0; i<m_property_specs.size(); ++i)
                     if (name == m_property_specs.at(i)->read())
                         return m_property_specs.at(i);
                 return 0;
             }
             QPropertySpec *AbstractMetaClass::propertySpecForWrite(const QString &name) const
             {
                 for (int i=0; i<m_property_specs.size(); ++i)
                     if (name == m_property_specs.at(i)->write())
                         return m_property_specs.at(i);
                 return 0;
             }
             QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) const
             {
                 for (int i=0; i<m_property_specs.size(); ++i) {
                     if (name == m_property_specs.at(i)->reset())
                         return m_property_specs.at(i);
                 }
                 return 0;
             }
             static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)
             {
                 foreach (const AbstractMetaFunction *f, l) {
             		if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar)
                         return true;
                 }
                 return false;
             }
             AbstractMetaField::AbstractMetaField() : m_getter(0), m_setter(0), m_class(0)
             {
             }
             AbstractMetaField::~AbstractMetaField()
             {
                 delete m_setter;
                 delete m_getter;
             }
             ushort        painters;                        // refcount
             AbstractMetaField *AbstractMetaField::copy() const
             {
                 AbstractMetaField *returned = new AbstractMetaField;
                 returned->setEnclosingClass(0);
                 returned->setAttributes(attributes());
                 returned->setName(name());
                 returned->setType(type()->copy());
                 returned->setOriginalAttributes(originalAttributes());
                 return returned;
             }
             static QString upCaseFirst(const QString &str) {
                 Q_ASSERT(!str.isEmpty());
                 QString s = str;
                 s[0] = s.at(0).toUpper();
                 return s;
             }
             static AbstractMetaFunction *createXetter(const AbstractMetaField *g, const QString &name, uint type) {
                 AbstractMetaFunction *f = new AbstractMetaFunction;
                 f->setName(name);
                 f->setOriginalName(name);
                 f->setOwnerClass(g->enclosingClass());
                 f->setImplementingClass(g->enclosingClass());
                 f->setDeclaringClass(g->enclosingClass());
                 uint attr = AbstractMetaAttributes::Native
                             | AbstractMetaAttributes::Final
                             | type;
                 if (g->isStatic())
                     attr |= AbstractMetaAttributes::Static;
                 if (g->isPublic())
                     attr |= AbstractMetaAttributes::Public;
                 else if (g->isProtected())
                     attr |= AbstractMetaAttributes::Protected;
                 else
                     attr |= AbstractMetaAttributes::Private;
                 f->setAttributes(attr);
                 f->setOriginalAttributes(attr);
                 FieldModificationList mods = g->modifications();
                 foreach (FieldModification mod, mods) {
                     if (mod.isRenameModifier())
                         f->setName(mod.renamedTo());
                     if (mod.isAccessModifier()) {
                         if (mod.isPrivate())
                             f->setVisibility(AbstractMetaAttributes::Private);
                         else if (mod.isProtected())
                             f->setVisibility(AbstractMetaAttributes::Protected);
                         else if (mod.isPublic())
                             f->setVisibility(AbstractMetaAttributes::Public);
                         else if (mod.isFriendly())
                             f->setVisibility(AbstractMetaAttributes::Friendly);
                     }
                 }
                 return f;
             }
             FieldModificationList AbstractMetaField::modifications() const
             {
                 FieldModificationList mods = enclosingClass()->typeEntry()->fieldModifications();
                 FieldModificationList returned;
                 foreach (FieldModification mod, mods) {
                     if (mod.name == name())
                         returned += mod;
                 }
                 return returned;
             }
             const AbstractMetaFunction *AbstractMetaField::setter() const
             {
                 if (m_setter == 0) {
                     m_setter = createXetter(this,
                                             name(),
                                             AbstractMetaAttributes::SetterFunction);
                     AbstractMetaArgumentList arguments;
                     AbstractMetaArgument *argument = new AbstractMetaArgument;
                     argument->setType(type()->copy());
                     argument->setName(name());
                     arguments.append(argument);
                     m_setter->setArguments(arguments);
                 }
                 return m_setter;
             }
             const AbstractMetaFunction *AbstractMetaField::getter() const
             {
                 if (m_getter == 0) {
                     m_getter = createXetter(this,
                                             name(),
                                             AbstractMetaAttributes::GetterFunction);
                     m_getter->setType(type());
                 }
                 return m_getter;
             }
             bool AbstractMetaClass::hasConstructors() const
             {
                 return queryFunctions(Constructors).size() != 0;
             }
             void AbstractMetaClass::addDefaultConstructor()
             {
                 AbstractMetaFunction *f = new AbstractMetaFunction;
                 f->setName(name());
                 f->setOwnerClass(this);
                 f->setFunctionType(AbstractMetaFunction::ConstructorFunction);
                 f->setArguments(AbstractMetaArgumentList());
                 f->setDeclaringClass(this);
                 uint attr = AbstractMetaAttributes::Native;
                 attr |= AbstractMetaAttributes::Public;
                 f->setAttributes(attr);
                 f->setImplementingClass(this);
                 f->setOriginalAttributes(f->attributes());
                 addFunction(f);
             }
             bool AbstractMetaClass::hasFunction(const AbstractMetaFunction *f) const
             {
                 return functions_contains(m_functions, f);
             }
             /* Goes through the list of functions and returns a list of all
                functions matching all of the criteria in \a query.
              */
             AbstractMetaFunctionList AbstractMetaClass::queryFunctions(uint query) const
             {
                 AbstractMetaFunctionList functions;
                 foreach (AbstractMetaFunction *f, m_functions) {
                     if ((query & VirtualSlots) && !f->isVirtualSlot())
                         continue;
                     if ((query & NotRemovedFromTargetLang) && f->isRemovedFrom(f->implementingClass(), TypeSystem::TargetLangCode)) {
                         continue;
                     }
                     if ((query & NotRemovedFromTargetLang) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::TargetLangCode)) {
                         continue;
                     }
                     if ((query & NotRemovedFromShell) && f->isRemovedFrom(f->implementingClass(), TypeSystem::ShellCode)) {
                         continue;
                     }
                     if ((query & NotRemovedFromShell) && !f->isFinal() && f->isRemovedFrom(f->declaringClass(), TypeSystem::ShellCode)) {
                         continue;
                     }
                     if ((query & Visible) && f->isPrivate()) {
                         continue;
                     }
                     if ((query & VirtualInTargetLangFunctions) && f->isFinalInTargetLang()) {
                         continue;
                     }
                     if ((query & Invisible) && !f->isPrivate()) {
                         continue;
                     }
                     if ((query & Empty) && !f->isEmptyFunction()) {
                         continue;
                     }
                     if ((query & WasPublic) && !f->wasPublic()) {
                         continue;
                     }
                     if ((query & WasVisible) && f->wasPrivate()) {
                         continue;
                     }
                     if ((query & WasProtected) && !f->wasProtected()) {
                         continue;
                     }
                     if ((query & ClassImplements) && f->ownerClass() != f->implementingClass()) {
                         continue;
                     }
                     if ((query & Inconsistent) && (f->isFinalInTargetLang() || !f->isFinalInCpp() || f->isStatic())) {
                         continue;
                     }
                     if ((query & FinalInTargetLangFunctions) && !f->isFinalInTargetLang()) {
                         continue;
                     }
                     if ((query & FinalInCppFunctions) && !f->isFinalInCpp()) {
                         continue;
                     }
                     if ((query & VirtualInCppFunctions) && f->isFinalInCpp()) {
                         continue;
                     }
                     if ((query & Signals) && (!f->isSignal())) {
                         continue;
                     }
                     if ((query & ForcedShellFunctions)
                         && (!f->isForcedShellImplementation()
                             || !f->isFinal())) {
                         continue;
                     }
                     if (((query & Constructors) && (!f->isConstructor()
                                                    || f->ownerClass() != f->implementingClass()))
                         || (f->isConstructor() && (query & Constructors) == 0)) {
                         continue;
                     }
                     // Destructors are never included in the functions of a class currently
                     /*
                        if ((query & Destructors) && (!f->isDestructor()
                                                    || f->ownerClass() != f->implementingClass())
                         || f->isDestructor() && (query & Destructors) == 0) {
                         continue;
                     }*/
                     if ((query & VirtualFunctions) && (f->isFinal() || f->isSignal() || f->isStatic())) {
                         continue;
                     }
                     if ((query & StaticFunctions) && (!f->isStatic() || f->isSignal())) {
                         continue;
                     }
                     if ((query & NonStaticFunctions) && (f->isStatic())) {
                         continue;
                     }
                     if ((query & NonEmptyFunctions) && (f->isEmptyFunction())) {
                         continue;
                     }
                     if ((query & NormalFunctions) && (f->isSignal())) {
                         continue;
                     }
                     if ((query & AbstractFunctions) && !f->isAbstract()) {
                         continue;
                     }
                     functions << f;
                 }
             //    qDebug() << "queried" << m_type_entry->qualifiedCppName() << "got" << functions.size() << "out of" << m_functions.size();
                 return functions;
             }
             bool AbstractMetaClass::hasInconsistentFunctions() const
             {
                 return cppInconsistentFunctions().size() > 0;
             }
             bool AbstractMetaClass::hasSignals() const
             {
                 return cppSignalFunctions().size() > 0;
             }
             /**
              * Adds the specified interface to this class by adding all the
              * functions in the interface to this class.
              */
             void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
             {
                 Q_ASSERT(!m_interfaces.contains(interface));
                 m_interfaces << interface;
                 if (m_extracted_interface != 0 && m_extracted_interface != interface)
                     m_extracted_interface->addInterface(interface);
                 foreach (AbstractMetaFunction *function, interface->functions())
                     if (!hasFunction(function) && !function->isConstructor()) {
                         AbstractMetaFunction *cpy = function->copy();
                         // We do not want this in PythonQt:
                         //cpy->setImplementingClass(this);
                         // Setup that this function is an interface class.
                         cpy->setInterfaceClass(interface);
                         *cpy += AbstractMetaAttributes::InterfaceFunction;
                         // Copy the modifications in interface into the implementing classes.
                         FunctionModificationList mods = function->modifications(interface);
                         foreach  (const FunctionModification &mod, mods) {
                             m_type_entry->addFunctionModification(mod);
                         }
                         // It should be mostly safe to assume that when we implement an interface
                         // we don't "pass on" pure virtual functions to our sublcasses...
             //             *cpy -= AbstractMetaAttributes::Abstract;
                         addFunction(cpy);
                     }
             }
             void AbstractMetaClass::setInterfaces(const AbstractMetaClassList &interfaces)
             {
                 m_interfaces = interfaces;
             }
             AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
             {
                 foreach (AbstractMetaEnum *e, m_enums) {
                     if (e->name() == enumName)
                         return e;
                 }
                 if (typeEntry()->designatedInterface())
                     return extractInterface()->findEnum(enumName);
                 return 0;
             }
             /*!  Recursivly searches for the enum value named \a enumValueName in
               this class and its superclasses and interfaces. Values belonging to
               \a meta_enum are excluded from the search.
             */
             AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValueName, AbstractMetaEnum *meta_enum)
             {
                 foreach (AbstractMetaEnum *e, m_enums) {
                     if (e == meta_enum)
                         continue;
                     foreach (AbstractMetaEnumValue *v, e->values()) {
                         if (v->name() == enumValueName)
                             return v;
                     }
                 }
                 if (typeEntry()->designatedInterface())
                     return extractInterface()->findEnumValue(enumValueName, meta_enum);
                 if (baseClass() != 0)
                     return baseClass()->findEnumValue(enumValueName, meta_enum);
                 return 0;
             }
             /*!
              * Searches through all of this class' enums for a value matching the
              * name \a enumValueName. The name is excluding the class/namespace
              * prefix. The function recursivly searches interfaces and baseclasses
              * of this class.
              */
             AbstractMetaEnum *AbstractMetaClass::findEnumForValue(const QString &enumValueName)
             {
                 foreach (AbstractMetaEnum *e, m_enums) {
                     foreach (AbstractMetaEnumValue *v, e->values()) {
                         if (v->name() == enumValueName)
                             return e;
                     }
                 }
                 if (typeEntry()->designatedInterface())
                     return extractInterface()->findEnumForValue(enumValueName);
                 if (baseClass() != 0)
                     return baseClass()->findEnumForValue(enumValueName);
                 return 0;
             }
             static void add_extra_include_for_type(AbstractMetaClass *meta_class, const AbstractMetaType *type)
             {
                 if (type == 0)
                     return;
                 Q_ASSERT(meta_class != 0);
                 const TypeEntry *entry = (type ? type->typeEntry() : 0);
                 if (entry != 0 && entry->isComplex()) {
                     const ComplexTypeEntry *centry = static_cast<const ComplexTypeEntry *>(entry);
                     ComplexTypeEntry *class_entry = meta_class->typeEntry();
                     if (class_entry != 0 && centry->include().isValid())
                         class_entry->addExtraInclude(centry->include());
                 }
                 if (type->hasInstantiations()) {
                     QList<AbstractMetaType *> instantiations = type->instantiations();
                     foreach (AbstractMetaType *instantiation, instantiations)
                         add_extra_include_for_type(meta_class, instantiation);
                 }
             }
             static void add_extra_includes_for_function(AbstractMetaClass *meta_class, const AbstractMetaFunction *meta_function)
             {
                 Q_ASSERT(meta_class != 0);
                 Q_ASSERT(meta_function != 0);
                 add_extra_include_for_type(meta_class, meta_function->type());
                 AbstractMetaArgumentList arguments = meta_function->arguments();
                 foreach (AbstractMetaArgument *argument, arguments)
                     add_extra_include_for_type(meta_class, argument->type());
             }
             void AbstractMetaClass::fixFunctions()
             {
                 if (m_functions_fixed)
                     return;
                 else
                     m_functions_fixed = true;
                 AbstractMetaClass *super_class = baseClass();
                 AbstractMetaFunctionList funcs = functions();
             //     printf("fix functions for %s\n", qPrintable(name()));
                 if (super_class != 0)
                     super_class->fixFunctions();
                 int iface_idx = 0;
                 while (super_class || iface_idx < interfaces().size()) {
             //         printf(" - base: %s\n", qPrintable(super_class->name()));
                     // Since we always traverse the complete hierarchy we are only
                     // interrested in what each super class implements, not what
                     // we may have propagated from their base classes again.
                     AbstractMetaFunctionList super_funcs;
                     if (super_class) {
                         // Super classes can never be final
                         if (super_class->isFinalInTargetLang()) {
                             ReportHandler::warning("Final class '" + super_class->name() + "' set to non-final, as it is extended by other classes");
                             *super_class -= AbstractMetaAttributes::FinalInTargetLang;
                         }
                         super_funcs = super_class->queryFunctions(AbstractMetaClass::ClassImplements);
                     } else {
                         super_funcs = interfaces().at(iface_idx)->queryFunctions(AbstractMetaClass::NormalFunctions);
                     }
                     QSet<AbstractMetaFunction *> funcs_to_add;
                     for (int sfi=0; sfi<super_funcs.size(); ++sfi) {
                         AbstractMetaFunction *sf = super_funcs.at(sfi);
                         if (sf->isRemovedFromAllLanguages(sf->implementingClass()))
                             continue;
                         // we generally don't care about private functions, but we have to get the ones that are
                         // virtual in case they override abstract functions.
                         bool add = (sf->isNormal() || sf->isSignal() || sf->isEmptyFunction());
                         for (int fi=0; fi<funcs.size(); ++fi) {
                             AbstractMetaFunction *f = funcs.at(fi);
                             if (f->isRemovedFromAllLanguages(f->implementingClass()))
                                 continue;
                             uint cmp = f->compareTo(sf);
                             if (cmp & AbstractMetaFunction::EqualModifiedName) {
             //                     printf("   - %s::%s similar to %s::%s %x vs %x\n",
             //                            qPrintable(sf->implementingClass()->typeEntry()->qualifiedCppName()),
             //                            qPrintable(sf->name()),
             //                            qPrintable(f->implementingClass()->typeEntry()->qualifiedCppName()),
             //                            qPrintable(f->name()),
             //                            sf->attributes(),
             //                            f->attributes());
                                 add = false;
                                 if (cmp & AbstractMetaFunction::EqualArguments) {
             //                         if (!(cmp & AbstractMetaFunction::EqualReturnType)) {
             //                             ReportHandler::warning(QString("%1::%2 and %3::%4 differ in retur type")
             //                                                    .arg(sf->implementingClass()->name())
             //                                                    .arg(sf->name())
             //                                                    .arg(f->implementingClass()->name())
             //                                                    .arg(f->name()));
             //                         }
                                     // Same function, propegate virtual...
                                     if (!(cmp & AbstractMetaFunction::EqualAttributes)) {
                                         if (!f->isEmptyFunction()) {
                                             if (!sf->isFinalInCpp() && f->isFinalInCpp()) {
                                                 *f -= AbstractMetaAttributes::FinalInCpp;
                 //                                 printf("   --- inherit virtual\n");
                                             }
                                             if (!sf->isFinalInTargetLang() && f->isFinalInTargetLang()) {
                                                 *f -= AbstractMetaAttributes::FinalInTargetLang;
                 //                                 printf("   --- inherit virtual\n");
                                             }
                                             if (!f->isFinalInTargetLang() && f->isPrivate()) {
                                                 f->setFunctionType(AbstractMetaFunction::EmptyFunction);
                                                 f->setVisibility(AbstractMetaAttributes::Protected);
                                                 *f += AbstractMetaAttributes::FinalInTargetLang;
                                                 ReportHandler::warning(QString("private virtual function '%1' in '%2'")
                                                     .arg(f->signature())
                                                     .arg(f->implementingClass()->name()));
                                             }
                                         }
                                     }
                                     if (f->visibility() != sf->visibility()) {
                                         QString warn = QString("visibility of function '%1' modified in class '%2'")
                                             .arg(f->name()).arg(name());
                                         ReportHandler::warning(warn);
                                         // If new visibility is private, we can't
                                         // do anything. If it isn't, then we
                                         // prefer the parent class's visibility
                                         // setting for the function.
                                         if (!f->isPrivate() && !sf->isPrivate())
                                             f->setVisibility(sf->visibility());
                                         // Private overrides of abstract functions have to go into the class or
                                         // the subclasses will not compile as non-abstract classes.
                                         // But they don't need to be implemented, since they can never be called.
                                         if (f->isPrivate() && sf->isAbstract()) {
                                             f->setFunctionType(AbstractMetaFunction::EmptyFunction);
                                             f->setVisibility(sf->visibility());
                                             *f += AbstractMetaAttributes::FinalInTargetLang;
                                             *f += AbstractMetaAttributes::FinalInCpp;
                                         }
                                     }
                                     // Set the class which first declares this function, afawk
                                     f->setDeclaringClass(sf->declaringClass());
                                     if (sf->isFinalInTargetLang() && !sf->isPrivate() && !f->isPrivate() && !sf->isStatic() && !f->isStatic()) {
                                         // Shadowed funcion, need to make base class
                                         // function non-virtual
                                         if (f->implementingClass() != sf->implementingClass() && f->implementingClass()->inheritsFrom(sf->implementingClass())) {
                                             // Check whether the superclass method has been redefined to non-final
                                             bool hasNonFinalModifier = false;
                                             bool isBaseImplPrivate = false;
                                             FunctionModificationList mods = sf->modifications(sf->implementingClass());
                                             foreach (FunctionModification mod, mods) {
                                                 if (mod.isNonFinal()) {
                                                     hasNonFinalModifier = true;
                                                     break;
                                                 } else if (mod.isPrivate()) {
                                                     isBaseImplPrivate = true;
                                                     break;
                                                 }
                                             }
                                             if (!hasNonFinalModifier && !isBaseImplPrivate) {
                                                 ReportHandler::warning(QString::fromLatin1("Shadowing: %1::%2 and %3::%4; Java code will not compile")
                                                                     .arg(sf->implementingClass()->name())
                                                                     .arg(sf->signature())
                                                                     .arg(f->implementingClass()->name())
                                                                     .arg(f->signature()));
                                             }
                                         }
                                     }
                                 }
                                 if (cmp & AbstractMetaFunction::EqualDefaultValueOverload) {
                                     AbstractMetaArgumentList arguments;
                                     if (f->arguments().size() < sf->arguments().size())
                                         arguments = sf->arguments();
                                     else
                                         arguments = f->arguments();
                                     for (int i=0; i<arguments.size(); ++i)
                                         arguments[i]->setDefaultValueExpression(QString());
                                 }
                                 // Otherwise we have function shadowing and we can
                                 // skip the thing...
                             } else if (cmp & AbstractMetaFunction::EqualName && !sf->isSignal()) {
                                 // In the case of function shadowing where the function name has been altered to
                                 // avoid conflict, we don't copy in the original.
                                 add = false;
                             }
                         }
                         if (add)
                             funcs_to_add << sf;
                     }
                     foreach (AbstractMetaFunction *f, funcs_to_add)
                         funcs << f->copy();
                     if (super_class)
                         super_class = super_class->baseClass();
                     else
                         iface_idx++;
                 }
                 bool hasPrivateConstructors = false;
                 bool hasPublicConstructors = false;
                 foreach (AbstractMetaFunction *func, funcs) {
                     FunctionModificationList mods = func->modifications(this);
                     foreach (const FunctionModification &mod, mods) {
                         if (mod.isRenameModifier()) {
             //                 qDebug() << name() << func->originalName() << func << " from "
             //                          << func->implementingClass()->name() << "renamed to" << mod.renamedTo();
                             func->setName(mod.renamedTo());
                         }
                     }
                     // Make sure class is abstract if one of the functions is
                     if (func->isAbstract()) {
                         (*this) += AbstractMetaAttributes::Abstract;
                         (*this) -= AbstractMetaAttributes::Final;
                     }
                     if (func->isConstructor()) {
                         if (func->isPrivate())
                             hasPrivateConstructors = true;
                         else
                             hasPublicConstructors = true;
                     }
                     // Make sure that we include files for all classes that are in use
                     if (!func->isRemovedFrom(this, TypeSystem::ShellCode))
                         add_extra_includes_for_function(this, func);
                 }
                 if (hasPrivateConstructors && !hasPublicConstructors) {
                     (*this) += AbstractMetaAttributes::Abstract;
                     (*this) -= AbstractMetaAttributes::Final;
                 }
                 foreach (AbstractMetaFunction *f1, funcs) {
                     foreach (AbstractMetaFunction *f2, funcs) {
                         if (f1 != f2) {
                             uint cmp = f1->compareTo(f2);
                             if ((cmp & AbstractMetaFunction::EqualName)
                                 && !f1->isFinalInCpp()
                                 && f2->isFinalInCpp()) {
                                 *f2 += AbstractMetaAttributes::FinalOverload;
             //                     qDebug() << f2 << f2->implementingClass()->name() << "::" << f2->name() << f2->arguments().size() << " vs " << f1 << f1->implementingClass()->name() << "::" << f1->name() << f1->arguments().size();
             //                     qDebug() << "    " << f2;
             //                     AbstractMetaArgumentList f2Args = f2->arguments();
             //                     foreach (AbstractMetaArgument *a, f2Args)
             //                         qDebug() << "        " << a->type()->name() << a->name();
             //                     qDebug() << "    " << f1;
             //                     AbstractMetaArgumentList f1Args = f1->arguments();
             //                     foreach (AbstractMetaArgument *a, f1Args)
             //                         qDebug() << "        " << a->type()->name() << a->name();
                             }
                         }
                     }
                 }
                 setFunctions(funcs);
             }
             QString AbstractMetaType::minimalSignature() const
             {
                 QString minimalSignature;
                 if (isConstant())
                     minimalSignature += "const ";
                 minimalSignature += typeEntry()->qualifiedCppName();
                 if (hasInstantiations()) {
                     QList<AbstractMetaType *> instantiations = this->instantiations();
                     minimalSignature += "<";
                     for (int i=0;i<instantiations.size();++i) {
                         if (i > 0)
                             minimalSignature += ",";
                         minimalSignature += instantiations.at(i)->minimalSignature();
                     }
                     minimalSignature += ">";
                 }
                 if (isReference())
                     minimalSignature += "&";
                 for (int j=0; j<indirections(); ++j)
                     minimalSignature += "*";
                 return minimalSignature;
             }
             bool AbstractMetaType::hasNativeId() const
             {
                 return (isQObject() || isValue() || isObject()) && typeEntry()->isNativeIdBased();
             }
             /*******************************************************************************
              * Other stuff...
              */
             AbstractMetaEnum *AbstractMetaClassList::findEnum(const EnumTypeEntry *entry) const
             {
                 Q_ASSERT(entry->isEnum());
                 QString qualified_name = entry->qualifiedCppName();
                 int pos = qualified_name.lastIndexOf("::");
                 QString enum_name;
                 QString class_name;
                 if (pos > 0) {
                     enum_name = qualified_name.mid(pos + 2);
                     class_name = qualified_name.mid(0, pos);
                 } else {
                     enum_name = qualified_name;
                     class_name = TypeDatabase::globalNamespaceClassName(entry);
                 }
                 AbstractMetaClass *meta_class = findClass(class_name);
                 if (!meta_class) {
                     ReportHandler::warning(QString("AbstractMeta::findEnum(), unknown class '%1' in '%2'")
                                            .arg(class_name).arg(entry->qualifiedCppName()));
                     return 0;
                 }
                 return meta_class->findEnum(enum_name);
             }
             AbstractMetaEnumValue *AbstractMetaEnumValueList::find(const QString &name) const
             {
                 for (int i=0; i<size(); ++i) {
                     if (name == at(i)->name())
                         return at(i);
                 }
                 return 0;
             }
             AbstractMetaEnumValue *AbstractMetaClassList::findEnumValue(const QString &name) const
             {
                 QStringList lst = name.split(QLatin1String("::"));
                 Q_ASSERT_X(lst.size() == 2, "AbstractMetaClassList::findEnumValue()", "Expected qualified enum");
                 QString prefixName = lst.at(0);
                 QString enumName = lst.at(1);
                 AbstractMetaClass *cl = findClass(prefixName);
                 if (cl)
                     return cl->findEnumValue(enumName, 0);
                 ReportHandler::warning(QString("no matching enum '%1'").arg(name));
                 return 0;
             }
             /*!
              * Searches the list after a class that mathces \a name; either as
              * C++, Java base name or complete Java package.class name.
              */
             AbstractMetaClass *AbstractMetaClassList::findClass(const QString &name) const
             {
                 if (name.isEmpty())
                     return 0;
                 foreach (AbstractMetaClass *c, *this) {
                     if (c->qualifiedCppName() == name)
                         return c;
                 }
                 foreach (AbstractMetaClass *c, *this) {
                     if (c->fullName() == name)
                         return c;
                 }
                 foreach (AbstractMetaClass *c, *this) {
                     if (c->name() == name)
                         return c;
                 }
                 return 0;
             }

generator/abstractmetalang.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $QT_BEGIN_LICENSE:LGPL$
             ** No Commercial Usage
             ** This file contains pre-release code and may not be distributed.
             ** You may use this file in accordance with the terms and conditions
             ** contained in the Technology Preview License Agreement accompanying
             ** this package.
             **
             ** GNU Lesser General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU Lesser
             ** General Public License version 2.1 as published by the Free Software
             ** Foundation and appearing in the file LICENSE.LGPL included in the
             ** packaging of this file.  Please review the following information to
             ** ensure the GNU Lesser General Public License version 2.1 requirements
             ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
             **
             ** In addition, as a special exception, Nokia gives you certain additional
             ** rights.  These rights are described in the Nokia Qt LGPL Exception
             ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
             **
             ** If you have questions regarding the use of this file, please contact
             ** Nokia at qt-info@nokia.com.
             **
             **
             **
             **
             **
             **
             **
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef ABSTRACTMETALANG_H
             #define ABSTRACTMETALANG_H
             #include "codemodel.h"
             #include "typesystem.h"
             #include <QSet>
             #include <QStringList>
             #include <QTextStream>
             class AbstractMeta;
             class AbstractMetaClass;
             class AbstractMetaField;
             class AbstractMetaFunction;
             class AbstractMetaType;
             class AbstractMetaVariable;
             class AbstractMetaArgument;
             class AbstractMetaEnumValue;
             class AbstractMetaEnum;
             class QPropertySpec;
             typedef QList<AbstractMetaField *> AbstractMetaFieldList;
             typedef QList<AbstractMetaArgument *> AbstractMetaArgumentList;
             typedef QList<AbstractMetaFunction *> AbstractMetaFunctionList;
             class AbstractMetaClassList : public  QList<AbstractMetaClass *>
             {
             public:
                 AbstractMetaClass *findClass(const QString &name) const;
                 AbstractMetaEnumValue *findEnumValue(const QString &string) const;
                 AbstractMetaEnum *findEnum(const EnumTypeEntry *entry) const;
             };
             class AbstractMetaAttributes
             {
             public:
                 AbstractMetaAttributes() : m_attributes(0) { };
                 enum Attribute {
                     None                        = 0x00000000,
                     Private                     = 0x00000001,
                     Protected                   = 0x00000002,
                     Public                      = 0x00000004,
                     Friendly                    = 0x00000008,
                     Visibility                  = 0x0000000f,
                     Native                      = 0x00000010,
                     Abstract                    = 0x00000020,
                     Static                      = 0x00000040,
                     FinalInTargetLang           = 0x00000080,
                     FinalInCpp                  = 0x00000100,
                     ForceShellImplementation    = 0x00000200,
                     GetterFunction              = 0x00000400,
                     SetterFunction              = 0x00000800,
                     FinalOverload               = 0x00001000,
                     InterfaceFunction           = 0x00002000,
                     PropertyReader              = 0x00004000,
                     PropertyWriter              = 0x00008000,
                     PropertyResetter            = 0x00010000,
                     Fake                        = 0x00020000,
                     Invokable                   = 0x00040000,
                     Final                       = FinalInTargetLang | FinalInCpp
                 };
                 uint attributes() const { return m_attributes; }
                 void setAttributes(uint attributes) { m_attributes = attributes; }
                 uint originalAttributes() const { return m_originalAttributes; }
                 void setOriginalAttributes(uint attributes) { m_originalAttributes = attributes; }
                 uint visibility() const { return m_attributes & Visibility; }
                 void setVisibility(uint visi) { m_attributes = (m_attributes & ~Visibility) | visi; }
                 void operator+=(Attribute attribute) { m_attributes |= attribute; }
                 void operator-=(Attribute attribute) { m_attributes &= ~attribute; }
                 bool isNative() const { return m_attributes & Native; }
                 bool isFinal() const { return (m_attributes & Final) == Final; }
                 bool isFinalInTargetLang() const { return m_attributes & FinalInTargetLang; }
                 bool isFinalInCpp() const { return m_attributes & FinalInCpp; }
                 bool isAbstract() const { return m_attributes & Abstract; }
                 bool isStatic() const { return m_attributes & Static; }
                 bool isForcedShellImplementation() const { return m_attributes & ForceShellImplementation; }
                 bool isInterfaceFunction() const { return m_attributes & InterfaceFunction; }
                 bool isFinalOverload() const { return m_attributes & FinalOverload; }
                 bool isInvokable() const { return m_attributes & Invokable; }
                 bool isPropertyReader() const { return m_attributes & PropertyReader; }
                 bool isPropertyWriter() const { return m_attributes & PropertyWriter; }
                 bool isPropertyResetter() const { return m_attributes & PropertyResetter; }
                 bool isPrivate() const { return m_attributes & Private; }
                 bool isProtected() const { return m_attributes & Protected; }
                 bool isPublic() const { return m_attributes & Public; }
                 bool isFriendly() const { return m_attributes & Friendly; }
                 bool wasPrivate() const { return m_originalAttributes & Private; }
                 bool wasProtected() const { return m_originalAttributes & Protected; }
                 bool wasPublic() const { return m_originalAttributes & Public; }
                 bool wasFriendly() const { return m_originalAttributes & Friendly; }
             private:
                 uint m_attributes;
                 uint m_originalAttributes;
             };
             class AbstractMetaType
             {
             public:
                 enum TypeUsagePattern {
                     InvalidPattern,
                     PrimitivePattern,
                     FlagsPattern,
                     EnumPattern,
                     ValuePattern,
                     StringPattern,
                     CharPattern,
                     ObjectPattern,
                     QObjectPattern,
                     NativePointerPattern,
                     ContainerPattern,
                     VariantPattern,
                     JObjectWrapperPattern,
                     ArrayPattern,
                     ThreadPattern
                 };
                 AbstractMetaType() :
                     m_type_entry(0),
                     m_array_element_count(0),
                     m_array_element_type(0),
                     m_original_template_type(0),
                     m_pattern(InvalidPattern),
                     m_constant(false),
                     m_reference(false),
                     m_cpp_instantiation(true),
                     m_indirections(0),
                     m_reserved(0)
                 {
                 }
                 QString package() const { return m_type_entry->javaPackage(); }
                 QString name() const { return m_type_entry->targetLangName(); }
                 QString fullName() const { return m_type_entry->qualifiedTargetLangName(); }
                 void setTypeUsagePattern(TypeUsagePattern pattern) { m_pattern = pattern; }
                 TypeUsagePattern typeUsagePattern() const { return m_pattern; }
                 // true when use pattern is container
                 bool hasInstantiations() const { return !m_instantiations.isEmpty(); }
                 void addInstantiation(AbstractMetaType *inst) { m_instantiations << inst; }
             	void setInstantiations(const QList<AbstractMetaType *> &insts) { m_instantiations = insts; }
                 QList<AbstractMetaType *> instantiations() const { return m_instantiations; }
                 void setInstantiationInCpp(bool incpp) { m_cpp_instantiation = incpp; }
                 bool hasInstantiationInCpp() const { return hasInstantiations() && m_cpp_instantiation; }
                 QString minimalSignature() const;
                 // true when the type is a QtJambiObject subclass
                 bool hasNativeId() const;
                 // returns true if the typs is used as a non complex primitive, no & or *'s
                 bool isPrimitive() const { return m_pattern == PrimitivePattern; }
                 // returns true if the type is used as an enum
                 bool isEnum() const { return m_pattern == EnumPattern; }
                 // returns true if the type is used as a QObject *
                 bool isQObject() const { return m_pattern == QObjectPattern; }
                 // returns true if the type is used as an object, e.g. Xxx *
                 bool isObject() const { return m_pattern == ObjectPattern; }
                 // returns true if the type is used as an array, e.g. Xxx[42]
                 bool isArray() const { return m_pattern == ArrayPattern; }
                 // returns true if the type is used as a value type (X or const X &)
                 bool isValue() const { return m_pattern == ValuePattern; }
                 // returns true for more complex types...
                 bool isNativePointer() const { return m_pattern == NativePointerPattern; }
                 // returns true if the type was originally a QString or const QString & or equivalent for QLatin1String
                 bool isTargetLangString() const { return m_pattern == StringPattern; }
                 // returns true if the type was originally a QChar or const QChar &
                 bool isTargetLangChar() const { return m_pattern == CharPattern; }
                 // return true if the type was originally a QVariant or const QVariant &
                 bool isVariant() const { return m_pattern == VariantPattern; }
                 // return true if the type was originally a JObjectWrapper or const JObjectWrapper &
                 bool isJObjectWrapper() const { return m_pattern == JObjectWrapperPattern; }
                 // returns true if the type was used as a container
                 bool isContainer() const { return m_pattern == ContainerPattern; }
                 // returns true if the type was used as a flag
                 bool isFlags() const { return m_pattern == FlagsPattern; }
                 // returns true if the type was used as a thread
                 bool isThread() const { return m_pattern == ThreadPattern; }
                 bool isConstant() const { return m_constant; }
                 void setConstant(bool constant) { m_constant = constant; }
                 bool isReference() const { return m_reference; }
                 void setReference(bool ref) { m_reference = ref; }
                 // Returns true if the type is to be implemented using Java enums, e.g. not plain ints.
                 bool isTargetLangEnum() const { return isEnum() && !((EnumTypeEntry *) typeEntry())->forceInteger(); }
                 bool isIntegerEnum() const { return isEnum() && !isTargetLangEnum(); }
                 // Returns true if the type is to be implemented using Java QFlags, e.g. not plain ints.
                 bool isTargetLangFlags() const {
                     return isFlags() && !((FlagsTypeEntry *) typeEntry())->forceInteger(); }
                 bool isIntegerFlags() const { return isFlags() && !isTargetLangFlags(); }
                 int actualIndirections() const { return m_indirections + (isReference() ? 1 : 0); }
                 int indirections() const { return m_indirections; }
                 void setIndirections(int indirections) { m_indirections = indirections; }
                 void setArrayElementCount(int n) { m_array_element_count = n; }
                 int arrayElementCount() const { return m_array_element_count; }
                 AbstractMetaType *arrayElementType() const { return m_array_element_type; }
                 void setArrayElementType(AbstractMetaType *t) { m_array_element_type = t; }
                 QString cppSignature() const;
                 AbstractMetaType *copy() const;
                 const TypeEntry *typeEntry() const { return m_type_entry; }
                 void setTypeEntry(const TypeEntry *type) { m_type_entry = type; }
                 void setOriginalTypeDescription(const QString &otd) { m_original_type_description = otd; }
                 QString originalTypeDescription() const { return m_original_type_description; }
                 void setOriginalTemplateType(const AbstractMetaType *type) { m_original_template_type = type; }
                 const AbstractMetaType *originalTemplateType() const { return m_original_template_type; }
             private:
                 const TypeEntry *m_type_entry;
                 QList <AbstractMetaType *> m_instantiations;
                 QString m_package;
                 QString m_original_type_description;
                 int m_array_element_count;
                 AbstractMetaType *m_array_element_type;
                 const AbstractMetaType *m_original_template_type;
                 TypeUsagePattern m_pattern;
                 uint m_constant : 1;
                 uint m_reference : 1;
                 uint m_cpp_instantiation : 1;
                 int m_indirections : 4;
                 uint m_reserved : 25; // unused
             };
             class AbstractMetaVariable
             {
             public:
                 AbstractMetaVariable() : m_type(0) { }
                 AbstractMetaType *type() const { return m_type; }
                 void setType(AbstractMetaType *type) { m_type = type; }
                 QString name() const { return m_name; }
                 void setName(const QString &name) { m_name = name; }
             private:
                 QString m_name;
                 AbstractMetaType *m_type;
             };
             class AbstractMetaArgument : public AbstractMetaVariable
             {
             public:
                 AbstractMetaArgument() : m_argument_index(0) { };
                 QString defaultValueExpression() const { return m_expression; }
                 void setDefaultValueExpression(const QString &expr) { m_expression = expr; }
                 QString originalDefaultValueExpression() const { return m_original_expression; }
                 void setOriginalDefaultValueExpression(const QString &expr) { m_original_expression = expr; }
                 QString toString() const { return type()->name() + " " + AbstractMetaVariable::name() +
                                                        (m_expression.isEmpty() ? "" :  " = " + m_expression); }
                 int argumentIndex() const { return m_argument_index; }
                 void setArgumentIndex(int argIndex) { m_argument_index = argIndex; }
                 QString argumentName() const;
                 QString indexedName() const;
                 AbstractMetaArgument *copy() const;
             private:
                 // Just to force people to call argumentName() And indexedName();
                 QString name() const;
                 QString m_expression;
                 QString m_original_expression;
                 int m_argument_index;
             };
             class AbstractMetaField : public AbstractMetaVariable, public AbstractMetaAttributes
             {
             public:
                 AbstractMetaField();
                 ~AbstractMetaField();
                 const AbstractMetaClass *enclosingClass() const { return m_class; }
                 void setEnclosingClass(const AbstractMetaClass *cls) { m_class = cls; }
                 const AbstractMetaFunction *getter() const;
                 const AbstractMetaFunction *setter() const;
                 FieldModificationList modifications() const;
                 AbstractMetaField *copy() const;
             private:
                 mutable AbstractMetaFunction *m_getter;
                 mutable AbstractMetaFunction *m_setter;
                 const AbstractMetaClass *m_class;
             };
             class AbstractMetaFunction : public AbstractMetaAttributes
             {
             public:
                 enum FunctionType {
                     ConstructorFunction,
                     DestructorFunction,
                     NormalFunction,
                     SignalFunction,
                     EmptyFunction,
                     SlotFunction,
                     GlobalScopeFunction
                 };
                 enum CompareResult {
                     EqualName                   = 0x00000001,
                     EqualArguments              = 0x00000002,
                     EqualAttributes             = 0x00000004,
                     EqualImplementor            = 0x00000008,
                     EqualReturnType             = 0x00000010,
                     EqualDefaultValueOverload   = 0x00000020,
                     EqualModifiedName           = 0x00000040,
                     NameLessThan                = 0x00001000,
                     PrettySimilar               = EqualName | EqualArguments,
                     Equal                       = 0x0000001f,
                     NotEqual                    = 0x00001000
                 };
                 AbstractMetaFunction()
                     : m_function_type(NormalFunction),
                       m_type(0),
                       m_class(0),
                       m_implementing_class(0),
                       m_declaring_class(0),
                       m_interface_class(0),
                       m_property_spec(0),
                       m_constant(false),
                       m_invalid(false)
                 {
                 }
                 ~AbstractMetaFunction();
                 QString name() const { return m_name; }
                 void setName(const QString &name) { m_name = name; }
                 QString originalName() const { return m_original_name.isEmpty() ? name() : m_original_name; }
                 void setOriginalName(const QString &name) { m_original_name = name; }
                 QString modifiedName() const;
                 QString minimalSignature() const;
                 QStringList possibleIntrospectionCompatibleSignatures() const;
                 QString marshalledName() const;
                 // true if one or more of the arguments are of QtJambiObject subclasses
                 bool argumentsHaveNativeId() const
                 {
                     foreach (const AbstractMetaArgument *arg, m_arguments) {
                         if (arg->type()->hasNativeId())
                             return true;
                     }
                     return false;
                 }
                 bool isModifiedRemoved(int types = TypeSystem::All) const;
                 AbstractMetaType *type() const { return m_type; }
                 void setType(AbstractMetaType *type) { m_type = type; }
                 // The class that has this function as a member.
                 const AbstractMetaClass *ownerClass() const { return m_class; }
                 void setOwnerClass(const AbstractMetaClass *cls) { m_class = cls; }
                 // The first class in a hierarchy that declares the function
                 const AbstractMetaClass *declaringClass() const { return m_declaring_class; }
                 void setDeclaringClass(const AbstractMetaClass *cls) { m_declaring_class = cls; }
                 // The class that actually implements this function
                 const AbstractMetaClass *implementingClass() const { return m_implementing_class; }
                 void setImplementingClass(const AbstractMetaClass *cls) { m_implementing_class = cls; }
                 bool needsCallThrough() const;
                 AbstractMetaArgumentList arguments() const { return m_arguments; }
                 void setArguments(const AbstractMetaArgumentList &arguments) { m_arguments = arguments; }
                 void addArgument(AbstractMetaArgument *argument) { m_arguments << argument; }
                 int actualMinimumArgumentCount() const;
                 void setInvalid(bool on) { m_invalid = on; }
                 bool isInvalid() const { return m_invalid; }
                 bool isDeprecated() const;
                 bool isDestructor() const { return functionType() == DestructorFunction; }
                 bool isConstructor() const { return functionType() == ConstructorFunction; }
                 bool isNormal() const { return functionType() == NormalFunction || isSlot() || isInGlobalScope(); }
                 bool isInGlobalScope() const { return functionType() == GlobalScopeFunction; }
                 bool isSignal() const { return functionType() == SignalFunction; }
                 bool isSlot() const { return functionType() == SlotFunction; }
                 bool isEmptyFunction() const { return functionType() == EmptyFunction; }
                 FunctionType functionType() const { return m_function_type; }
                 void setFunctionType(FunctionType type) { m_function_type = type; }
                 bool isVirtual() { return !(isFinal() || isSignal() || isStatic()); }
                 QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
                 QString signature() const;
                 QString targetLangSignature(bool minimal = false) const;
                 bool shouldReturnThisObject() const { return QLatin1String("this") == argumentReplaced(0); }
                 bool shouldIgnoreReturnValue() const { return QLatin1String("void") == argumentReplaced(0); }
                 bool isConstant() const { return m_constant; }
                 void setConstant(bool constant) { m_constant = constant; }
                 QString toString() const { return m_name; }
                 uint compareTo(const AbstractMetaFunction *other) const;
                 bool operator <(const AbstractMetaFunction &a) const;
                 AbstractMetaFunction *copy() const;
                 QString replacedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
                 bool removedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
                 QString conversionRule(TypeSystem::Language language, int idx) const;
                 QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
                 bool nullPointersDisabled(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
                 QString nullPointerDefaultValue(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
                 bool resetObjectAfterUse(int argument_idx) const;
                 // Returns whether garbage collection is disabled for the argument in any context
                 bool disabledGarbageCollection(const AbstractMetaClass *cls, int key) const;
                 // Returns the ownership rules for the given argument in the given context
                 TypeSystem::Ownership ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int idx) const;
                 bool isVirtualSlot() const;
                 QString typeReplaced(int argument_index) const;
                 bool isRemovedFromAllLanguages(const AbstractMetaClass *) const;
                 bool isRemovedFrom(const AbstractMetaClass *, TypeSystem::Language language) const;
                 bool argumentRemoved(int) const;
                 QString argumentReplaced(int key) const;
                 bool needsSuppressUncheckedWarning() const;
                 bool hasModifications(const AbstractMetaClass *implementor) const;
                 FunctionModificationList modifications(const AbstractMetaClass *implementor) const;
                 // If this function stems from an interface, this returns the
                 // interface that declares it.
                 const AbstractMetaClass *interfaceClass() const { return m_interface_class; }
                 void setInterfaceClass(const AbstractMetaClass *cl) { m_interface_class = cl; }
                 void setPropertySpec(QPropertySpec *spec) { m_property_spec = spec; }
                 QPropertySpec *propertySpec() const { return m_property_spec; }
             private:
                 QString m_name;
                 QString m_original_name;
                 mutable QString m_cached_minimal_signature;
                 mutable QString m_cached_modified_name;
                 FunctionType m_function_type;
                 AbstractMetaType *m_type;
                 const AbstractMetaClass *m_class;
                 const AbstractMetaClass *m_implementing_class;
                 const AbstractMetaClass *m_declaring_class;
                 const AbstractMetaClass *m_interface_class;
                 QPropertySpec *m_property_spec;
                 AbstractMetaArgumentList m_arguments;
                 uint m_constant                 : 1;
                 uint m_invalid                  : 1;
             };
             class AbstractMetaEnumValue
             {
             public:
                 AbstractMetaEnumValue()
                     : m_value_set(false), m_value(0)
                 {
                 }
                 int value() const { return m_value; }
                 void setValue(int value) { m_value_set = true; m_value = value; }
                 QString stringValue() const { return m_string_value; }
                 void setStringValue(const QString &v) { m_string_value = v; }
                 QString name() const { return m_name; }
                 void setName(const QString &name) { m_name = name; }
                 bool isValueSet() const { return m_value_set; }
             private:
                 QString m_name;
                 QString m_string_value;
                 bool m_value_set;
                 int m_value;
             };
             class AbstractMetaEnumValueList : public QList<AbstractMetaEnumValue *>
             {
             public:
                 AbstractMetaEnumValue *find(const QString &name) const;
             };
             class AbstractMetaEnum : public AbstractMetaAttributes
             {
             public:
                 AbstractMetaEnum() : m_type_entry(0), m_class(0), m_has_qenums_declaration(false) {}
                 AbstractMetaEnumValueList values() const { return m_enum_values; }
                 void addEnumValue(AbstractMetaEnumValue *enumValue) { m_enum_values << enumValue; }
                 QString name() const { return m_type_entry->targetLangName(); }
                 QString qualifier() const { return m_type_entry->javaQualifier(); }
                 QString package() const { return m_type_entry->javaPackage(); }
                 QString fullName() const { return package() + "." + qualifier()  + "." + name(); }
                 // Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
                 void setHasQEnumsDeclaration(bool on) { m_has_qenums_declaration = on; }
                 bool hasQEnumsDeclaration() const { return m_has_qenums_declaration; }
                 EnumTypeEntry *typeEntry() const { return m_type_entry; }
                 void setTypeEntry(EnumTypeEntry *entry) { m_type_entry = entry; }
                 AbstractMetaClass *enclosingClass() const { return m_class; }
                 void setEnclosingClass(AbstractMetaClass *c) { m_class = c; }
             private:
                 AbstractMetaEnumValueList m_enum_values;
                 EnumTypeEntry *m_type_entry;
                 AbstractMetaClass *m_class;
                 uint m_has_qenums_declaration : 1;
                 uint m_reserved : 31;
             };
             typedef QList<AbstractMetaEnum *> AbstractMetaEnumList;
             class AbstractMetaClass : public AbstractMetaAttributes
             {
             public:
                 enum FunctionQueryOption {
                     Constructors            = 0x000001,   // Only constructors
                     //Destructors             = 0x000002,   // Only destructors. Not included in class.
                     VirtualFunctions        = 0x000004,   // Only virtual functions (virtual in both TargetLang and C++)
                     FinalInTargetLangFunctions    = 0x000008,   // Only functions that are non-virtual in TargetLang
                     FinalInCppFunctions     = 0x000010,   // Only functions that are non-virtual in C++
                     ClassImplements         = 0x000020,   // Only functions implemented by the current class
                     Inconsistent            = 0x000040,   // Only inconsistent functions (inconsistent virtualness in TargetLang/C++)
                     StaticFunctions         = 0x000080,   // Only static functions
                     Signals                 = 0x000100,   // Only signals
                     NormalFunctions         = 0x000200,   // Only functions that aren't signals
                     Visible                 = 0x000400,   // Only public and protected functions
                     ForcedShellFunctions    = 0x000800,   // Only functions that are overridden to be implemented in the shell class
                     WasPublic               = 0x001000,   // Only functions that were originally public
                     WasProtected            = 0x002000,   // Only functions that were originally protected
                     NonStaticFunctions      = 0x004000,   // No static functions
                     Empty                   = 0x008000,   // Empty overrides of abstract functions
                     Invisible               = 0x010000,   // Only private functions
                     VirtualInCppFunctions   = 0x020000,   // Only functions that are virtual in C++
                     NonEmptyFunctions       = 0x040000,   // Only functions with JNI implementations
                     VirtualInTargetLangFunctions  = 0x080000,   // Only functions which are virtual in TargetLang
                     AbstractFunctions       = 0x100000,   // Only abstract functions
                     WasVisible              = 0x200000,   // Only functions that were public or protected in the original code
                     NotRemovedFromTargetLang      = 0x400000,   // Only functions that have not been removed from TargetLang
                     NotRemovedFromShell     = 0x800000,    // Only functions that have not been removed from the shell class
                     VirtualSlots           = 0x1000000     // Only functions that are set as virtual slots in the type system
                 };
                 AbstractMetaClass()
                     : m_namespace(false),
                       m_qobject(false),
                       m_has_virtuals(false),
                       m_has_nonpublic(false),
                       m_has_virtual_slots(false),
                       m_has_nonprivateconstructor(false),
                       m_functions_fixed(false),
                       m_has_public_destructor(true),
                       m_force_shell_class(false),
                       m_has_hash_function(false),
                       m_has_equals_operator(false),
                       m_has_clone_operator(false),
                       m_is_type_alias(false),
                       m_enclosing_class(0),
                       m_base_class(0),
                       m_template_base_class(0),
                       m_extracted_interface(0),
                       m_primary_interface_implementor(0),
                       m_type_entry(0),
                       m_qDebug_stream_function(0)
                 {
                 }
                 virtual ~AbstractMetaClass();
                 AbstractMetaClass *extractInterface();
                 void fixFunctions();
                 AbstractMetaFunctionList functions() const { return m_functions; }
                 void setFunctions(const AbstractMetaFunctionList &functions);
                 void addFunction(AbstractMetaFunction *function);
                 bool hasFunction(const AbstractMetaFunction *f) const;
                 bool hasFunction(const QString &str) const;
                 bool hasSignal(const AbstractMetaFunction *f) const;
                 bool hasConstructors() const;
                 void addDefaultConstructor();
                 bool hasNonPrivateConstructor() const { return m_has_nonprivateconstructor; }
                 void setHasNonPrivateConstructor(bool on) { m_has_nonprivateconstructor = on; }
                 bool hasPublicDestructor() const { return m_has_public_destructor; }
                 void setHasPublicDestructor(bool on) { m_has_public_destructor = on; }
                 AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
                 AbstractMetaFunctionList queryFunctions(uint query) const;
                 inline AbstractMetaFunctionList allVirtualFunctions() const;
                 inline AbstractMetaFunctionList allFinalFunctions() const;
                 AbstractMetaFunctionList functionsInTargetLang() const;
                 AbstractMetaFunctionList functionsInShellClass() const;
                 inline AbstractMetaFunctionList cppInconsistentFunctions() const;
                 inline AbstractMetaFunctionList cppSignalFunctions() const;
                 AbstractMetaFunctionList publicOverrideFunctions() const;
                 AbstractMetaFunctionList virtualOverrideFunctions() const;
                 AbstractMetaFunctionList virtualFunctions() const;
                 AbstractMetaFunctionList nonVirtualShellFunctions() const;
                 AbstractMetaFieldList fields() const { return m_fields; }
                 void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; }
                 void addField(AbstractMetaField *field) { m_fields << field; }
                 AbstractMetaEnumList enums() const { return m_enums; }
                 void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
                 void addEnum(AbstractMetaEnum *e) { m_enums << e; }
                 AbstractMetaEnum *findEnum(const QString &enumName);
                 AbstractMetaEnum *findEnumForValue(const QString &enumName);
                 AbstractMetaEnumValue *findEnumValue(const QString &enumName, AbstractMetaEnum *meta_enum);
                 AbstractMetaClassList interfaces() const { return m_interfaces; }
                 void addInterface(AbstractMetaClass *interface);
                 void setInterfaces(const AbstractMetaClassList &interface);
                 QString fullName() const { return package() + "." + name(); }
                 QString name() const;
                 QString baseClassName() const { return m_base_class ? m_base_class->name() : QString(); }
                 AbstractMetaClass *baseClass() const { return m_base_class; }
                 void setBaseClass(AbstractMetaClass *base_class) { m_base_class = base_class; }
                 const AbstractMetaClass *enclosingClass() const { return m_enclosing_class; }
                 void setEnclosingClass(AbstractMetaClass *cl) { m_enclosing_class = cl; }
                 QString package() const { return m_type_entry->javaPackage(); }
                 bool isInterface() const { return m_type_entry->isInterface(); }
                 bool isNamespace() const { return m_type_entry->isNamespace(); }
                 bool isQObject() const { return m_type_entry->isQObject(); }
                 bool isQtNamespace() const { return isNamespace() && name() == "Qt"; }
                 QString qualifiedCppName() const { return m_type_entry->qualifiedCppName(); }
                 bool hasInconsistentFunctions() const;
                 bool hasSignals() const;
                 bool inheritsFrom(const AbstractMetaClass *other) const;
                 void setForceShellClass(bool on) { m_force_shell_class = on; }
                 bool generateShellClass() const;
                 bool hasVirtualSlots() const { return m_has_virtual_slots; }
                 bool hasVirtualFunctions() const { return !isFinal() && m_has_virtuals; }
                 bool hasProtectedFunctions() const;
                 QList<TypeEntry *> templateArguments() const { return m_template_args; }
                 void setTemplateArguments(const QList<TypeEntry *> &args) { m_template_args = args; }
                 bool hasFieldAccessors() const;
                 // only valid during metajavabuilder's run
                 QStringList baseClassNames() const { return m_base_class_names; }
                 void setBaseClassNames(const QStringList &names) { m_base_class_names = names; }
                 AbstractMetaClass *primaryInterfaceImplementor() const { return m_primary_interface_implementor; }
                 void setPrimaryInterfaceImplementor(AbstractMetaClass *cl) { m_primary_interface_implementor = cl; }
                 const ComplexTypeEntry *typeEntry() const { return m_type_entry; }
                 ComplexTypeEntry *typeEntry() { return m_type_entry; }
                 void setTypeEntry(ComplexTypeEntry *type) { m_type_entry = type; }
                 void setHasHashFunction(bool on) { m_has_hash_function = on; }
                 bool hasHashFunction() const { return m_has_hash_function; }
                 void setToStringCapability(FunctionModelItem fun) { m_qDebug_stream_function= fun; }
                 FunctionModelItem hasToStringCapability() const { return m_qDebug_stream_function; }
                 virtual bool hasDefaultToStringFunction() const;
                 void setHasEqualsOperator(bool on) { m_has_equals_operator = on; }
                 bool hasEqualsOperator() const { return m_has_equals_operator; }
                 void setHasCloneOperator(bool on) { m_has_clone_operator = on; }
                 bool hasCloneOperator() const { return m_has_clone_operator; }
+                bool hasDefaultIsNull() const;
                 void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
                 QList<QPropertySpec *> propertySpecs() const { return m_property_specs; }
                 QPropertySpec *propertySpecForRead(const QString &name) const;
                 QPropertySpec *propertySpecForWrite(const QString &name) const;
                 QPropertySpec *propertySpecForReset(const QString &name) const;
                 QList<ReferenceCount> referenceCounts() const;
                 void setEqualsFunctions(const AbstractMetaFunctionList &lst) { m_equals_functions = lst; }
                 AbstractMetaFunctionList equalsFunctions() const { return m_equals_functions; }
                 void setNotEqualsFunctions(const AbstractMetaFunctionList &lst) { m_nequals_functions = lst; }
                 AbstractMetaFunctionList notEqualsFunctions() const { return m_nequals_functions; }
                 void setLessThanFunctions(const AbstractMetaFunctionList &lst) { m_less_than_functions = lst; }
                 AbstractMetaFunctionList lessThanFunctions() const { return m_less_than_functions; }
                 void setGreaterThanFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_functions = lst; }
                 AbstractMetaFunctionList greaterThanFunctions() const { return m_greater_than_functions; }
                 void setLessThanEqFunctions(const AbstractMetaFunctionList &lst) { m_less_than_eq_functions = lst; }
                 AbstractMetaFunctionList lessThanEqFunctions() const { return m_less_than_eq_functions; }
                 void setGreaterThanEqFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_eq_functions = lst; }
                 AbstractMetaFunctionList greaterThanEqFunctions() const { return m_greater_than_eq_functions; }
                 void sortFunctions();
                 const AbstractMetaClass *templateBaseClass() const { return m_template_base_class; }
                 void setTemplateBaseClass(const AbstractMetaClass *cls) { m_template_base_class = cls; }
                 void setTypeAlias(bool typeAlias) { m_is_type_alias = typeAlias; }
                 bool isTypeAlias() const { return m_is_type_alias; }
                 bool operator <(const AbstractMetaClass &a) const {
                   return qualifiedCppName() < a.qualifiedCppName();
                 }
             private:
                 uint m_namespace : 1;
                 uint m_qobject : 1;
                 uint m_has_virtuals : 1;
                 uint m_has_nonpublic : 1;
                 uint m_has_virtual_slots : 1;
                 uint m_has_nonprivateconstructor : 1;
                 uint m_functions_fixed : 1;
                 uint m_has_public_destructor : 1;
                 uint m_force_shell_class : 1;
                 uint m_has_hash_function : 1;
                 uint m_has_equals_operator : 1;
                 uint m_has_clone_operator :1;
                 uint m_is_type_alias : 1;
                 uint m_reserved : 19;
                 const AbstractMetaClass *m_enclosing_class;
                 AbstractMetaClass *m_base_class;
                 const AbstractMetaClass *m_template_base_class;
                 AbstractMetaFunctionList m_functions;
                 AbstractMetaFieldList m_fields;
                 AbstractMetaEnumList m_enums;
                 AbstractMetaClassList m_interfaces;
                 AbstractMetaClass *m_extracted_interface;
                 AbstractMetaClass *m_primary_interface_implementor;
                 QList<QPropertySpec *> m_property_specs;
                 AbstractMetaFunctionList m_equals_functions;
                 AbstractMetaFunctionList m_nequals_functions;
                 AbstractMetaFunctionList m_less_than_functions;
                 AbstractMetaFunctionList m_greater_than_functions;
                 AbstractMetaFunctionList m_less_than_eq_functions;
                 AbstractMetaFunctionList m_greater_than_eq_functions;
                 QStringList m_base_class_names;
                 QList<TypeEntry *> m_template_args;
                 ComplexTypeEntry *m_type_entry;
                 FunctionModelItem m_qDebug_stream_function;
             };
             class QPropertySpec {
             public:
                 QPropertySpec(const TypeEntry *type)
                     : m_type(type),
                       m_index(-1)
                 {
                 }
                 const TypeEntry *type() const { return m_type; }
                 QString name() const { return m_name; }
                 void setName(const QString &name) { m_name = name; }
                 QString read() const { return m_read; }
                 void setRead(const QString &read) { m_read = read; }
                 QString write() const { return m_write; }
                 void setWrite(const QString &write) { m_write = write; }
                 QString designable() const { return m_designable; }
                 void setDesignable(const QString &designable) { m_designable = designable; }
                 QString reset() const { return m_reset; }
                 void setReset(const QString &reset) { m_reset = reset; }
                 int index() const { return m_index; }
                 void setIndex(int index) { m_index = index; }
             private:
                 QString m_name;
                 QString m_read;
                 QString m_write;
                 QString m_designable;
                 QString m_reset;
                 const TypeEntry *m_type;
                 int m_index;
             };
             inline AbstractMetaFunctionList AbstractMetaClass::allVirtualFunctions() const
             {
                 return queryFunctions(VirtualFunctions
                                       | NotRemovedFromTargetLang);
             }
             inline AbstractMetaFunctionList AbstractMetaClass::allFinalFunctions() const
             {
                 return queryFunctions(FinalInTargetLangFunctions
                                       | FinalInCppFunctions
                                       | NotRemovedFromTargetLang);
             }
             inline AbstractMetaFunctionList AbstractMetaClass::cppInconsistentFunctions() const
             {
                 return queryFunctions(Inconsistent
                                       | NormalFunctions
                                       | Visible
                                       | NotRemovedFromTargetLang);
             }
             inline AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
             {
                 return queryFunctions(Signals
                                       | Visible
                                       | NotRemovedFromTargetLang);
             }
             #endif // ABSTRACTMETALANG_H

generator/setupgenerator.cpp +64 -2

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $QT_BEGIN_LICENSE:LGPL$
             ** No Commercial Usage
             ** This file contains pre-release code and may not be distributed.
             ** You may use this file in accordance with the terms and conditions
             ** contained in the Technology Preview License Agreement accompanying
             ** this package.
             **
             ** GNU Lesser General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU Lesser
             ** General Public License version 2.1 as published by the Free Software
             ** Foundation and appearing in the file LICENSE.LGPL included in the
             ** packaging of this file.  Please review the following information to
             ** ensure the GNU Lesser General Public License version 2.1 requirements
             ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
             **
             ** In addition, as a special exception, Nokia gives you certain additional
             ** rights.  These rights are described in the Nokia Qt LGPL Exception
             ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
             **
             ** If you have questions regarding the use of this file, please contact
             ** Nokia at qt-info@nokia.com.
             **
             **
             **
             **
             **
             **
             **
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "setupgenerator.h"
             #include "shellgenerator.h"
             #include "reporthandler.h"
             #include "fileout.h"
             //#define Q_SCRIPT_LAZY_GENERATOR
             void SetupGenerator::addClass(const QString& package, const AbstractMetaClass *cls)
             {
               packHash[package].append(cls);
             }
             void maybeDeclareMetaType(QTextStream &stream, const QString &typeName,
                                       QSet<QString> &registeredTypeNames);
             bool hasDefaultConstructor(const AbstractMetaClass *meta_class);
+            static QStringList getOperatorCodes(const AbstractMetaClass* cls) {
+              QSet<QString> operatorCodes;
+              AbstractMetaFunctionList returned;
+              AbstractMetaFunctionList functions = cls->functions();
+              foreach (AbstractMetaFunction *function, functions) {
+                if (function->originalName().startsWith("operator")) {
+                  QString op = function->originalName().mid(8);
+                  operatorCodes.insert(op);
+                }
+              }
+              QSet<QString> r;
+              foreach(QString op, operatorCodes.toList()) {
+                if (op == ">" || op == "<" || op == ">=" || op == "<=" || op == "==" || op == "!=") {
+                  r.insert("PythonQt::Type_RichCompare");
+                } else if (op == "+") {
+                  r.insert("PythonQt::Type_Add");
+                } else if (op == "-") {
+                  r.insert("PythonQt::Type_Subtract");
+                } else if (op == "/") {
+                  r.insert("PythonQt::Type_Divide");
+                } else if (op == "*") {
+                  r.insert("PythonQt::Type_Multiply");
+                } else if (op == "%") {
+                  r.insert("PythonQt::Type_Mod");
+                } else if (op == "&") {
+                  r.insert("PythonQt::Type_And");
+                } else if (op == "|") {
+                  r.insert("PythonQt::Type_Or");
+                } else if (op == "^") {
+                  r.insert("PythonQt::Type_Xor");
+                } else if (op == "~") {
+                  r.insert("PythonQt::Type_Invert");
+                } else if (op == "+=") {
+                  r.insert("PythonQt::Type_InplaceAdd");
+                } else if (op == "-=") {
+                  r.insert("PythonQt::Type_InplaceSubtract");
+                } else if (op == "/=") {
+                  r.insert("PythonQt::Type_InplaceDivide");
+                } else if (op == "*=") {
+                  r.insert("PythonQt::Type_InplaceMultiply");
+                } else if (op == "%=") {
+                  r.insert("PythonQt::Type_InplaceMod");
+                } else if (op == "&=") {
+                  r.insert("PythonQt::Type_InplaceAnd");
+                } else if (op == "|=") {
+                  r.insert("PythonQt::Type_InplaceOr");
+                } else if (op == "^=") {
+                  r.insert("PythonQt::Type_InplaceXor");
+                }
+              }
+              if (cls->hasDefaultIsNull()) {
+                r.insert("PythonQt::Type_NonZero");
+              }
+              QStringList result = r.toList();
+              return result;
+            }
             void SetupGenerator::generate()
             {
               AbstractMetaClassList classes_with_polymorphic_id;
               {
                 QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
                 while (pack.hasNext()) {
                   pack.next();
                   QList<const AbstractMetaClass*> list = pack.value();
                   foreach (const AbstractMetaClass *cls, list) {
                     if (cls->typeEntry()->isPolymorphicBase()) {
                       classes_with_polymorphic_id.append((AbstractMetaClass*)cls);
                     }
                   }
                 }
               }
               QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
               while (pack.hasNext()) {
                 pack.next();
                 QList<const AbstractMetaClass*> list = pack.value();
                 if (list.isEmpty())
                   continue;
                 QString packKey = pack.key();
                 QString packName = pack.key();
                 QStringList components = packName.split("_");
                 if ((components.size() > 2) && (components.at(0) == "com")
                   && (components.at(1) == "trolltech")) {
                     // kill com.trolltech in key
                     components.removeAt(0);
                     components.removeAt(0);
                 }
                 QString shortPackName;
                 foreach (QString comp, components) {
                   comp[0] = comp[0].toUpper();
                   shortPackName += comp;
                 }
                 // add missing camel case (workaround..)
                 if (shortPackName == "QtWebkit") {
                   shortPackName = "QtWebKit";
                 } else if (shortPackName == "QtXmlpatterns") {
                   shortPackName = "QtXmlPatterns";
                 } else if (shortPackName == "QtOpengl") {
                   shortPackName = "QtOpenGL";
                 } else if (shortPackName == "QtUitools") {
                   shortPackName = "QtUiTools";
                 }
                 {
                   FileOut initFile(m_out_dir + "/generated_cpp/" + packName + "/" + packKey + "_init.cpp");
                   QTextStream &s = initFile.stream;
                   s << "#include <PythonQt.h>" << endl;
                   for (int i=0; i<(list.count()+MAX_CLASSES_PER_FILE-1) / MAX_CLASSES_PER_FILE; i++) {
                     s << "#include \"" << packKey << QString::number(i) << ".h\"" << endl;
                   }
                   s << endl;
                   QStringList polymorphicHandlers;
                   if (!packName.endsWith("_builtin")) {
                     polymorphicHandlers = writePolymorphicHandler(s, list.at(0)->package(), classes_with_polymorphic_id);
                     s << endl;
                   }
                   // declare individual class creation functions
                   s << "void PythonQt_init_" << shortPackName << "(PyObject* module) {" << endl;
                   if (shortPackName.endsWith("Builtin")) {
                     shortPackName = shortPackName.mid(0, shortPackName.length()-strlen("builtin"));
                   }
                   QStringList cppClassNames;
                   foreach (const AbstractMetaClass *cls, list) {
                     QString shellCreator;
                     if (cls->generateShellClass()) {
                       shellCreator = ", PythonQtSetInstanceWrapperOnShell<" + ShellGenerator::shellClassName(cls) + ">";
                     } else {
                       shellCreator = ", NULL";
                     }
+                    QString operatorCodes = getOperatorCodes(cls).join("|");
+                    if (operatorCodes.isEmpty()) {
+                      operatorCodes = "0";
+                    }
                     if (cls->isQObject()) {
-                      s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module);" << endl;
+                      s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
                     } else {
                       QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";
-                      s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module);" << endl;
+                      s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
                     }
                     foreach(AbstractMetaClass* interface, cls->interfaces()) {
                       // the interface might be our own class... (e.g. QPaintDevice)
                       if (interface->qualifiedCppName() != cls->qualifiedCppName()) {
                         s << "PythonQt::self()->addParentClass(\""<< cls->qualifiedCppName() << "\", \"" << interface->qualifiedCppName() << "\",PythonQtUpcastingOffset<" << cls->qualifiedCppName() <<","<<interface->qualifiedCppName()<<">());" << endl;
                       }
                     }
                   }
                   s << endl;
                   foreach (QString handler, polymorphicHandlers) {
                     s << "PythonQt::self()->addPolymorphicHandler(\""<< handler << "\", polymorphichandler_" << handler << ");" << endl;
                   }
                   s << "}";
                   s << endl;
                 }
               }
             }
             QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QString &package,
                                                                 const AbstractMetaClassList &classes)
             {
               QStringList handlers;
               foreach (AbstractMetaClass *cls, classes) {
                 const ComplexTypeEntry *centry = cls->typeEntry();
                 if (!centry->isPolymorphicBase())
                   continue;
                 bool isGraphicsItem = (cls->qualifiedCppName()=="QGraphicsItem");
                 AbstractMetaClassList classList = this->classes();
                 bool first = true;
                 foreach (AbstractMetaClass *clazz, classList) {
                   bool inherits = false;
                   if (isGraphicsItem) {
                     foreach(AbstractMetaClass* interfaze, clazz->interfaces()) {
                       if (interfaze->qualifiedCppName()=="QGraphicsItem") {
                         inherits = true;
                         break;
                       }
                     }
                   } else {
                     inherits = clazz->inheritsFrom(cls);
                   }
                   if (clazz->package() == package && inherits) {
                     if (!clazz->typeEntry()->polymorphicIdValue().isEmpty() || isGraphicsItem) {
                       // On first find, open the function
                       if (first) {
                         first = false;
                         QString handler = cls->name();
                         handlers.append(handler);
                         s << "static void* polymorphichandler_" << handler
                           << "(const void *ptr, char **class_name)" << endl
                           << "{" << endl
                           << "    Q_ASSERT(ptr != 0);" << endl
                           << "    " << cls->qualifiedCppName() << " *object = ("
                           << cls->qualifiedCppName() << " *)ptr;" << endl;
                       }
                       // For each, add case label
                       QString polyId = clazz->typeEntry()->polymorphicIdValue();
                       if (isGraphicsItem) {
                         polyId = "%1->type() == " + clazz->qualifiedCppName() + "::Type";
                       }
                       s << "    if ("
                         << polyId.replace("%1", "object")
                         << ") {" << endl
                         << "        *class_name = \"" << clazz->name() << "\";" << endl
                         << "        return (" << clazz->qualifiedCppName() << "*)object;" << endl
                         << "    }" << endl;
                     } else {
                       QString warning = QString("class '%1' inherits from polymorphic class '%2', but has no polymorphic id set")
                         .arg(clazz->name())
                         .arg(cls->name());
                       ReportHandler::warning(warning);
                     }
                   }
                 }
                 // Close the function if it has been opened
                 if (!first) {
                   s << "    return NULL;" << endl
                     << "}" << endl;
                 }
               }
               return handlers;
             }

generator/shellheadergenerator.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $QT_BEGIN_LICENSE:LGPL$
             ** No Commercial Usage
             ** This file contains pre-release code and may not be distributed.
             ** You may use this file in accordance with the terms and conditions
             ** contained in the Technology Preview License Agreement accompanying
             ** this package.
             **
             ** GNU Lesser General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU Lesser
             ** General Public License version 2.1 as published by the Free Software
             ** Foundation and appearing in the file LICENSE.LGPL included in the
             ** packaging of this file.  Please review the following information to
             ** ensure the GNU Lesser General Public License version 2.1 requirements
             ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
             **
             ** In addition, as a special exception, Nokia gives you certain additional
             ** rights.  These rights are described in the Nokia Qt LGPL Exception
             ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
             **
             ** If you have questions regarding the use of this file, please contact
             ** Nokia at qt-info@nokia.com.
             **
             **
             **
             **
             **
             **
             **
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "shellheadergenerator.h"
             #include "fileout.h"
             #include <QtCore/QDir>
             #include <qdebug.h>
             QString ShellHeaderGenerator::fileNameForClass(const AbstractMetaClass *meta_class) const
             {
               return QString("PythonQtWrapper_%1.h").arg(meta_class->name());
             }
             void ShellHeaderGenerator::writeFieldAccessors(QTextStream &s, const AbstractMetaField *field)
             {
               const AbstractMetaFunction *setter = field->setter();
               const AbstractMetaFunction *getter = field->getter();
               // static fields are not supported (yet?)
               if (setter->isStatic()) return;
               // Uuid data4 did not work (TODO: move to typesystem...(
               if (field->enclosingClass()->name()=="QUuid" &&  setter->name()=="data4") return;
               if (field->enclosingClass()->name()=="QIPv6Address") return;
               if (!field->type()->isConstant()) {
                 writeFunctionSignature(s, setter, 0, QString(),
                                        Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | ShowStatic | UnderscoreSpaces));
                 s << "{ theWrappedObject->" << field->name() << " = " << setter->arguments()[0]->argumentName() << "; }\n";
               }
               writeFunctionSignature(s, getter, 0, QString(),
                                      Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
               s << "{ return theWrappedObject->" << field->name() << "; }\n";
             }
             void ShellHeaderGenerator::write(QTextStream &s, const AbstractMetaClass *meta_class)
             {
               QString builtIn = ShellGenerator::isBuiltIn(meta_class->name())?"_builtin":"";
               QString pro_file_name = meta_class->package().replace(".", "_") + builtIn + "/" + meta_class->package().replace(".", "_") + builtIn + ".pri";
               priGenerator->addHeader(pro_file_name, fileNameForClass(meta_class));
               setupGenerator->addClass(meta_class->package().replace(".", "_") + builtIn, meta_class);
               QString include_block = "PYTHONQTWRAPPER_" + meta_class->name().toUpper() + "_H";
               s << "#ifndef " << include_block << endl
                 << "#define " << include_block << endl << endl;
               Include inc = meta_class->typeEntry()->include();
               ShellGenerator::writeInclude(s, inc);
               s << "#include <QObject>" << endl << endl;
               s << "#include <PythonQt.h>" << endl << endl;
               IncludeList list = meta_class->typeEntry()->extraIncludes();
               qSort(list.begin(), list.end());
               foreach (const Include &inc, list) {
                 ShellGenerator::writeInclude(s, inc);
               }
               s << endl;
               AbstractMetaFunctionList ctors = meta_class->queryFunctions(AbstractMetaClass::Constructors
                 | AbstractMetaClass::WasVisible
                 | AbstractMetaClass::NotRemovedFromTargetLang);
               // Shell-------------------------------------------------------------------
               if (meta_class->generateShellClass()) {
                 AbstractMetaFunctionList virtualsForShell = getVirtualFunctionsForShell(meta_class);
                 s << "class " << shellClassName(meta_class)
                   << " : public " << meta_class->qualifiedCppName() << endl << "{" << endl;
                 s << "public:" << endl;
                 foreach(AbstractMetaFunction* fun, ctors) {
                   s << "    ";
                   writeFunctionSignature(s, fun, 0,"PythonQtShell_",
                     Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
                   s << ":" << meta_class->qualifiedCppName() << "(";
                   QString scriptFunctionName = fun->originalName();
                   AbstractMetaArgumentList args = fun->arguments();
                   for (int i = 0; i < args.size(); ++i) {
                     if (i > 0)
                       s << ", ";
                     s << args.at(i)->argumentName();
                   }
                   s << "),_wrapper(NULL) {};" << endl;
                 }
                 s << endl;
                 foreach(AbstractMetaFunction* fun, virtualsForShell) {
                   s << "virtual ";
                   writeFunctionSignature(s, fun, 0, QString(),
                     Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
                   s << ";" << endl;
                 }
                 s << endl;
                 s << "  PythonQtInstanceWrapper* _wrapper; " << endl;
                 s << "};" << endl << endl;
               }
               // Promoter-------------------------------------------------------------------
               AbstractMetaFunctionList promoteFunctions = getProtectedFunctionsThatNeedPromotion(meta_class);
               if (!promoteFunctions.isEmpty()) {
                 s << "class " << promoterClassName(meta_class)
                   << " : public " << meta_class->qualifiedCppName() << endl << "{ public:" << endl;
                 foreach(AbstractMetaFunction* fun, promoteFunctions) {
                   s << "inline ";
                   writeFunctionSignature(s, fun, 0, "promoted_",
                     Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
                   s << " { ";
                   QString scriptFunctionName = fun->originalName();
                   AbstractMetaArgumentList args = fun->arguments();
                   if (fun->type())
                     s << "return ";
                   s << meta_class->qualifiedCppName() << "::";
                   s << fun->originalName() << "(";
                   for (int i = 0; i < args.size(); ++i) {
                     if (i > 0)
                       s << ", ";
                     s << args.at(i)->argumentName();
                   }
                   s << "); }" << endl;
                 }
                 s << "};" << endl << endl;
               }
               // Wrapper-------------------------------------------------------------------
               s << "class " << wrapperClassName(meta_class)
                 << " : public QObject" << endl
                 << "{ Q_OBJECT" << endl;
               s << "public:" << endl;
               AbstractMetaEnumList enums1 = meta_class->enums();
               AbstractMetaEnumList enums;
               QList<FlagsTypeEntry*> flags;
               foreach(AbstractMetaEnum* enum1, enums1) {
                 // catch gadgets and enums that are not exported on QObjects...
                 if (enum1->wasPublic() && (!meta_class->isQObject() || !enum1->hasQEnumsDeclaration())) {
                   enums << enum1;
                   if (enum1->typeEntry()->flags()) {
                     flags << enum1->typeEntry()->flags();
                   }
                 }
               }
               if (enums.count()) {
                 s << "Q_ENUMS(";
                 foreach(AbstractMetaEnum* enum1, enums) {
                   s << enum1->name() << " ";
                 }
                 s << ")" << endl;
                 if (flags.count()) {
                   s << "Q_FLAGS(";
                   foreach(FlagsTypeEntry* flag1, flags) {
                     QString origName = flag1->originalName();
                     int idx = origName.lastIndexOf("::");
                     if (idx!= -1) {
                       origName = origName.mid(idx+2);
                     }
                     s << origName << " ";
                   }
                   s << ")" << endl;
                 }
                 foreach(AbstractMetaEnum* enum1, enums) {
                   s << "enum " << enum1->name() << "{" << endl;
                   bool first = true;
                   foreach(AbstractMetaEnumValue* value, enum1->values()) {
                     if (first) { first = false; }
                     else { s << ", "; }
                     s << "  " << value->name() << " = " << meta_class->qualifiedCppName() << "::" << value->name();
                   }
                   s << "};" << endl;
                 }
                 if (flags.count()) {
                   foreach(AbstractMetaEnum* enum1, enums) {
                     if (enum1->typeEntry()->flags()) {
                       QString origName = enum1->typeEntry()->flags()->originalName();
                       int idx = origName.lastIndexOf("::");
                       if (idx!= -1) {
                         origName = origName.mid(idx+2);
                       }
                       s << "Q_DECLARE_FLAGS("<< origName << ", " << enum1->name() <<")"<<endl;
                     }
                   }
                 }
               }
               s << "public slots:" << endl;
               if (meta_class->generateShellClass() || !meta_class->isAbstract()) {
                 bool copyConstructorSeen = false;
                 bool defaultConstructorSeen = false;
                 foreach (const AbstractMetaFunction *fun, ctors) {
                   if (!fun->isPublic() || fun->isAbstract()) { continue; }
                   s << meta_class->qualifiedCppName() << "* ";
                   writeFunctionSignature(s, fun, 0, "new_",
                     Option(IncludeDefaultExpression | OriginalName | ShowStatic));
                   s << ";" << endl;
                   if (fun->arguments().size()==1 && meta_class->qualifiedCppName() == fun->arguments().at(0)->type()->typeEntry()->qualifiedCppName()) {
                     copyConstructorSeen = true;
                   }
                   if (fun->arguments().size()==0) {
                     defaultConstructorSeen = true;
                   }
                 }
                 if (meta_class->typeEntry()->isValue()
                     && !copyConstructorSeen && defaultConstructorSeen) {
                   QString className = meta_class->generateShellClass()?shellClassName(meta_class):meta_class->qualifiedCppName();
                   s << meta_class->qualifiedCppName() << "* new_" << meta_class->name() << "(const " << meta_class->qualifiedCppName() << "& other) {" << endl;
                   s << className << "* a = new " << className << "();" << endl;
                   s << "*((" << meta_class->qualifiedCppName() << "*)a) = other;" << endl;
                   s << "return a; }" << endl;
                 }
               }
               if (meta_class->hasPublicDestructor() && !meta_class->isNamespace()) {
                 s << "void delete_" << meta_class->name() << "(" << meta_class->qualifiedCppName() << "* obj) { delete obj; } ";
                 s << endl;
               }
               if (meta_class->name()=="QTreeWidgetItem") {
                 s << "bool py_hasOwner(QTreeWidgetItem* theWrappedObject) { return theWrappedObject->treeWidget()!=NULL || theWrappedObject->parent()!=NULL; }" << endl;
               } else if (meta_class->name()=="QGraphicsItem") {
                 s << "bool py_hasOwner(QGraphicsItem* theWrappedObject) { return theWrappedObject->scene()!=NULL || theWrappedObject->parentItem()!=NULL; }" << endl;
               }
               AbstractMetaFunctionList functions = getFunctionsToWrap(meta_class);
               foreach (const AbstractMetaFunction *function, functions) {
                 if (!function->isSlot()) {
                   s << "   ";
                   writeFunctionSignature(s, function, 0, QString(),
                     Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
                   s << ";" << endl;
                 }
               }
               if (meta_class->hasDefaultToStringFunction() || meta_class->hasToStringCapability()) {
                 s << "    QString py_toString(" << meta_class->qualifiedCppName() << "*);" << endl;
               }
+              if (meta_class->hasDefaultIsNull()) {
+                s << "    bool __nonzero__(" << meta_class->qualifiedCppName() << "* obj) { return !obj->isNull(); }" << endl;
+              }
               // Field accessors
               foreach (const AbstractMetaField *field, meta_class->fields()) {
                 if (field->isPublic()) {
                   writeFieldAccessors(s, field);
                 }
               }
               //    writeInjectedCode(s, meta_class);
               //  s  << endl << "    QScriptValue __qtscript_self;" << endl;
               s  << "};" << endl << endl
                 << "#endif // " << include_block << endl;
             }
             void ShellHeaderGenerator::writeInjectedCode(QTextStream &s, const AbstractMetaClass *meta_class)
             {
               CodeSnipList code_snips = meta_class->typeEntry()->codeSnips();
               foreach (const CodeSnip &cs, code_snips) {
                 if (cs.language == TypeSystem::ShellDeclaration) {
                   s << cs.code() << endl;
                 }
               }
             }

src/PythonQt.cpp +4 -2

             /*
             *
             *  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 "PythonQt.h"
             #include "PythonQtImporter.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtConversion.h"
             #include "PythonQtStdOut.h"
             #include "PythonQtCppWrapperFactory.h"
             #include "PythonQtVariants.h"
             #include "PythonQtStdDecorators.h"
             #include "PythonQtQFileImporter.h"
             #include <pydebug.h>
             #include <vector>
             PythonQt* PythonQt::_self = NULL;
             int       PythonQt::_uniqueModuleCount = 0;
             void PythonQt_init_QtGuiBuiltin(PyObject*);
             void PythonQt_init_QtCoreBuiltin(PyObject*);
             void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
             {
               if (!_self) {
                 _self = new PythonQt(flags, pythonQtModuleName);
                 PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
                 qRegisterMetaType<QList<QObject*> >("QList<void*>");
                 PythonQtRegisterToolClassesTemplateConverter(int);
                 PythonQtRegisterToolClassesTemplateConverter(float);
                 PythonQtRegisterToolClassesTemplateConverter(double);
                 PythonQtRegisterToolClassesTemplateConverter(qint32);
                 PythonQtRegisterToolClassesTemplateConverter(quint32);
                 PythonQtRegisterToolClassesTemplateConverter(qint64);
                 PythonQtRegisterToolClassesTemplateConverter(quint64);
                 // TODO: which other POD types should be available for QList etc.
                 PythonQt::self()->addDecorators(new PythonQtStdDecorators());
                 PythonQt_init_QtCoreBuiltin(NULL);
                 PythonQt_init_QtGuiBuiltin(NULL);
                 PythonQtRegisterToolClassesTemplateConverter(QDate);
                 PythonQtRegisterToolClassesTemplateConverter(QTime);
                 PythonQtRegisterToolClassesTemplateConverter(QDateTime);
                 PythonQtRegisterToolClassesTemplateConverter(QUrl);
                 PythonQtRegisterToolClassesTemplateConverter(QLocale);
                 PythonQtRegisterToolClassesTemplateConverter(QRect);
                 PythonQtRegisterToolClassesTemplateConverter(QRectF);
                 PythonQtRegisterToolClassesTemplateConverter(QSize);
                 PythonQtRegisterToolClassesTemplateConverter(QSizeF);
                 PythonQtRegisterToolClassesTemplateConverter(QLine);
                 PythonQtRegisterToolClassesTemplateConverter(QLineF);
                 PythonQtRegisterToolClassesTemplateConverter(QPoint);
                 PythonQtRegisterToolClassesTemplateConverter(QPointF);
                 PythonQtRegisterToolClassesTemplateConverter(QRegExp);
                 PythonQtRegisterToolClassesTemplateConverter(QFont);
                 PythonQtRegisterToolClassesTemplateConverter(QPixmap);
                 PythonQtRegisterToolClassesTemplateConverter(QBrush);
                 PythonQtRegisterToolClassesTemplateConverter(QColor);
                 PythonQtRegisterToolClassesTemplateConverter(QPalette);
                 PythonQtRegisterToolClassesTemplateConverter(QIcon);
                 PythonQtRegisterToolClassesTemplateConverter(QImage);
                 PythonQtRegisterToolClassesTemplateConverter(QPolygon);
                 PythonQtRegisterToolClassesTemplateConverter(QRegion);
                 PythonQtRegisterToolClassesTemplateConverter(QBitmap);
                 PythonQtRegisterToolClassesTemplateConverter(QCursor);
                 PythonQtRegisterToolClassesTemplateConverter(QSizePolicy);
                 PythonQtRegisterToolClassesTemplateConverter(QKeySequence);
                 PythonQtRegisterToolClassesTemplateConverter(QPen);
                 PythonQtRegisterToolClassesTemplateConverter(QTextLength);
                 PythonQtRegisterToolClassesTemplateConverter(QTextFormat);
                 PythonQtRegisterToolClassesTemplateConverter(QMatrix);
                 PyObject* pack = PythonQt::priv()->packageByName("QtCore");
                 PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
                 PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();
                 const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound","qDebug","qWarning","qCritical","qFatal"
                                     ,"qFuzzyCompare", "qMax","qMin","qRound","qRound64","qVersion","qrand","qsrand"};
                 for (unsigned int i = 0;i<16; i++) {
                   PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);
                   if (obj) {
                     PyModule_AddObject(pack, names[i], obj);
                     Py_INCREF(obj);
                     PyModule_AddObject(pack2, names[i], obj);
                   } else {
                     std::cerr << "method not found " << names[i];
                   }
                 }
               }
             }
             void PythonQt::cleanup()
             {
               if (_self) {
                 delete _self;
                 _self = NULL;
               }
             }
             PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
             {
               _p = new PythonQtPrivate;
               _p->_initFlags = flags;
               _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
               Py_SetProgramName("PythonQt");
               if (flags & IgnoreSiteModule) {
                 // this prevents the automatic importing of Python site files
                 Py_NoSiteFlag = 1;
               }
               Py_Initialize();
               // add our own python object types for qt object slots
               if (PyType_Ready(&PythonQtSlotFunction_Type) < 0) {
                 std::cerr << "could not initialize PythonQtSlotFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtSlotFunction_Type);
               // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
               PythonQtClassWrapper_Type.tp_base = &PyType_Type;
               // add our own python object types for classes
               if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtClassWrapper_Type);
               // add our own python object types for CPP instances
               if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
                 PythonQt::handleError();
                 std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtInstanceWrapper_Type);
               // add our own python object types for redirection of stdout
               if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
               initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
               _p->setupSharedLibrarySuffixes();
             }
             PythonQt::~PythonQt() {
               delete _p;
               _p = NULL;
             }
             PythonQtPrivate::~PythonQtPrivate() {
               delete _defaultImporter;
               _defaultImporter = NULL;
               {
                 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               PythonQtConv::global_valueStorage.clear();
               PythonQtConv::global_ptrStorage.clear();
               PythonQtConv::global_variantStorage.clear();
               PythonQtMethodInfo::cleanupCachedMethodInfos();
             }
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
               return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
             }
             void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
             {
               if (_self->_p->_noLongerWrappedCB) {
                 (*_self->_p->_noLongerWrappedCB)(o);
               };
             }
             void PythonQt::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerClass(metaobject, package, wrapperCreator, shell);
             }
-            void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module)
+            void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
               bool first = true;
               while (m) {
                 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());
                 if (!info->pythonQtClassWrapper()) {
+                  info->setTypeSlots(typeSlots);
                   info->setupQObject(m);
                   createPythonQtClassWrapper(info, package, module);
                   if (m->superClass()) {
                     PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());
                     info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));
                   }
                 }
                 if (first) {
                   first = false;
                   if (wrapperCreator) {
                     info->setDecoratorProvider(wrapperCreator);
                   }
                   if (shell) {
                     info->setShellSetInstanceWrapperCB(shell);
                   }
                 }
                 m = m->superClass();
               }
             }
             void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module)
             {
               PyObject* pack = module?module:packageByName(package);
               PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack);
               PyModule_AddObject(pack, info->className(), pyobj);
               if (!module && package && strncmp(package,"Qt",2)==0) {
                 // since PyModule_AddObject steals the reference, we need a incref once more...
                 Py_INCREF(pyobj);
                 // put all qt objects into Qt as well
                 PyModule_AddObject(packageByName("Qt"), info->className(), pyobj);
               }
               info->setPythonQtClassWrapper(pyobj);
             }
             PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
             {
               if (!obj) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);
               if (!wrap) {
                 // smuggling it in...
                 PythonQtClassInfo* classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 if (!classInfo || classInfo->pythonQtClassWrapper()==NULL) {
                   registerClass(obj->metaObject());
                   classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 }
                 wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
                 //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //    mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
             {
               if (!ptr) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
               if (!wrap) {
                 PythonQtClassInfo* info = _knownClassInfos.value(name);
                 if (!info) {
                   // maybe it is a PyObject, which we can return directly
                   if (name == "PyObject") {
                     PyObject* p = (PyObject*)ptr;
                     Py_INCREF(p);
                     return p;
                   }
                   // we do not know the metaobject yet, but we might know it by it's name:
                   if (_knownQObjectClassNames.find(name)!=_knownQObjectClassNames.end()) {
                     // yes, we know it, so we can convert to QObject
                     QObject* qptr = (QObject*)ptr;
                     registerClass(qptr->metaObject());
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                   }
                 }
                 if (info && info->isQObject()) {
                   QObject* qptr = (QObject*)ptr;
                   // if the object is a derived object, we want to switch the class info to the one of the derived class:
                   if (name!=(qptr->metaObject()->className())) {
                     registerClass(qptr->metaObject());
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                   }
                   wrap = createNewPythonQtInstanceWrapper(qptr, info);
                   //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                   return (PyObject*)wrap;
                 }
                 // not a known QObject, so try our wrapper factory:
                 QObject* wrapper = NULL;
                 for (int i=0; i<_cppWrapperFactories.size(); i++) {
                   wrapper = _cppWrapperFactories.at(i)->create(name, ptr);
                   if (wrapper) {
                     break;
                   }
                 }
                 if (info) {
                   // try to downcast in the class hierarchy, which will modify info and ptr if it is successfull
                   ptr  = info->castDownIfPossible(ptr, &info);
                 }
                 if (!info || info->pythonQtClassWrapper()==NULL) {
                   // still unknown, register as CPP class
                   registerCPPClass(name.constData());
                   info = _knownClassInfos.value(name);
                 }
                 if (wrapper && (info->metaObject() != wrapper->metaObject())) {
                   // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
                   info->setMetaObject(wrapper->metaObject());
                 }
                 wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
                 //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::dummyTuple() {
               static PyObject* dummyTuple = NULL;
               if (dummyTuple==NULL) {
                 dummyTuple = PyTuple_New(1);
                 PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));
               }
               return dummyTuple;
             }
             PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
               // call the associated class type to create a new instance...
               PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), NULL);
               result->setQObject(obj);
               result->_wrappedPtr = wrappedPtr;
               result->_ownedByPythonQt = false;
               result->_useQMetaTypeDestroy = false;
               if (wrappedPtr) {
                 _wrappedObjects.insert(wrappedPtr, result);
               } else {
                 _wrappedObjects.insert(obj, result);
                 if (obj->parent()== NULL && _wrappedCB) {
                   // tell someone who is interested that the qobject is wrapped the first time, if it has no parent
                   (*_wrappedCB)(obj);
                 }
               }
               return result;
             }
             PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* parentModule) {
               PythonQtClassWrapper* result;
               PyObject* className = PyString_FromString(info->className());
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
               PyObject* typeDict = PyDict_New();
               PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
               PyDict_SetItemString(typeDict, "__module__", moduleName);
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               // set the class info so that PythonQtClassWrapper_new can read it
               _currentClassInfoForClassWrapperCreation = info;
               // create the new type object by calling the type
               result = (PythonQtClassWrapper *)PyObject_Call((PyObject *)&PythonQtClassWrapper_Type, args, NULL);
               Py_DECREF(baseClasses);
               Py_DECREF(typeDict);
               Py_DECREF(args);
               Py_DECREF(className);
               return result;
             }
             PyObject*  PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)
             {
               PyObject* args = Py_BuildValue("(i)", enumValue);
               PyObject* result = PyObject_Call(enumType, args, NULL);
               Py_DECREF(args);
               return result;
             }
             PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
               PyObject* result;
               PyObject* className = PyString_FromString(enumName);
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
               PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
               PyObject* typeDict = PyDict_New();
               PyDict_SetItemString(typeDict, "__module__", module);
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               // create the new int derived type object by calling the core type
               result = PyObject_Call((PyObject *)&PyType_Type, args, NULL);
               Py_DECREF(baseClasses);
               Py_DECREF(typeDict);
               Py_DECREF(args);
               Py_DECREF(className);
               return result;
             }
             PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
             {
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (!r) {
                 r = new PythonQtSignalReceiver(obj);
                 _p->_signalReceivers.insert(obj, r);
               }
               return r;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = getSignalReceiver(obj);
                 flag = r->addSignalHandler(signal, callable);
                 if (!flag) {
                   // signal not found
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = getSignalReceiver(obj);
               if (r) {
                 flag = r->addSignalHandler(signal, receiver);
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
                 if (r) {
                   flag = r->removeSignalHandler(signal, callable);
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (r) {
                 flag = r->removeSignalHandler(signal, receiver);
               }
               return flag;
             }
             PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
             {
               PythonQtObjectPtr p = lookupObject(module, name);
               if (p) {
                 if (PyCallable_Check(p)) {
                   return p;
                 }
               }
               PyErr_Clear();
               return NULL;
             }
             PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)
             {
               QStringList l = name.split('.');
               PythonQtObjectPtr p = module;
               PythonQtObjectPtr prev;
               QString s;
               QByteArray b;
               for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {
                 prev = p;
                 b = (*i).toLatin1();
                 if (PyDict_Check(p)) {
                   p = PyDict_GetItemString(p, b.data());
                 } else {
                   p.setNewRef(PyObject_GetAttrString(p, b.data()));
                 }
               }
               PyErr_Clear();
               return p;
             }
             PythonQtObjectPtr PythonQt::getMainModule() {
               //both borrowed
               PythonQtObjectPtr dict = PyImport_GetModuleDict();
               return PyDict_GetItemString(dict, "__main__");
             }
             QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
               QVariant result;
               if (pycode) {
                 PyObject* dict = NULL;
                 if (PyModule_Check(object)) {
                   dict = PyModule_GetDict(object);
                 } else if (PyDict_Check(object)) {
                   dict = object;
                 }
                 PyObject* r = NULL;
                 if (dict) {
                   r = PyEval_EvalCode((PyCodeObject*)pycode, dict , dict);
                 }
                 if (r) {
                   result = PythonQtConv::PyObjToQVariant(r);
                   Py_DECREF(r);
                 } else {
                   handleError();
                 }
               } else {
                 handleError();
               }
               return result;
             }
             QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start)
             {
               QVariant result;
               PythonQtObjectPtr p;
               PyObject* dict = NULL;
               if (PyModule_Check(object)) {
                 dict = PyModule_GetDict(object);
               } else if (PyDict_Check(object)) {
                 dict = object;
               }
               if (dict) {
                 p.setNewRef(PyRun_String(script.toLatin1().data(), start, dict, dict));
               }
               if (p) {
                 result = PythonQtConv::PyObjToQVariant(p);
               } else {
                 handleError();
               }
               return result;
             }
             void PythonQt::evalFile(PyObject* module, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               if (code) {
                 evalCode(module, code);
               } else {
                 handleError();
               }
             }
             PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
             {
               PythonQtObjectPtr p;
               p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
               if (!p) {
                 handleError();
               }
               return p;
             }
             PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               PythonQtObjectPtr module = _p->createModule(name, code);
               return module;
             }
             PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)
             {
               PyErr_Clear();
               QString scriptCode = script;
               if (scriptCode.isEmpty()) {
                 // we always need at least a linefeed
                 scriptCode = "\n";
               }
               PythonQtObjectPtr pycode;
               pycode.setNewRef(Py_CompileString((char*)scriptCode.toLatin1().data(), "",  Py_file_input));
               PythonQtObjectPtr module = _p->createModule(name, pycode);
               return module;
             }
             PythonQtObjectPtr PythonQt::createUniqueModule()
             {
               static QString pyQtStr("PythonQt_module");
               QString moduleName = pyQtStr+QString::number(_uniqueModuleCount++);
               return createModuleFromScript(moduleName);
             }
             void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               }
             }
             void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               }
             }
             void PythonQt::removeVariable(PyObject* object, const QString& name)
             {
               if (PyDict_Check(object)) {
                 PyDict_DelItemString(object, name.toLatin1().data());
               } else {
                 PyObject_DelAttrString(object, name.toLatin1().data());
               }
             }
             QVariant PythonQt::getVariable(PyObject* object, const QString& objectname)
             {
               QVariant result;
               PythonQtObjectPtr obj = lookupObject(object, objectname);
               if (obj) {
                 result = PythonQtConv::PyObjToQVariant(obj);
               }
               return result;
             }
             QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
             {
               QStringList results;
               PythonQtObjectPtr object;
               if (objectname.isEmpty()) {
                 object = module;
               } else {
                 object = lookupObject(module, objectname);
                 if (!object && type == CallOverloads) {
                   PyObject* dict = lookupObject(module, "__builtins__");
                   if (dict) {
                     object = PyDict_GetItemString(dict, objectname.toLatin1().constData());
                   }
                 }
               }
               if (object) {
                 if (type == CallOverloads) {
                   if (PythonQtSlotFunction_Check(object)) {
                     PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.object();
                     PythonQtSlotInfo* info = o->m_ml;
                     while (info) {
                       results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                     PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
                     PythonQtSlotInfo* info = o->classInfo()->constructors();
                     while (info) {
                       results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else {
                     //TODO: use pydoc!
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       results << PyString_AsString(doc);
                       Py_DECREF(doc);
                     }
                   }
                 } else {
                   PyObject* keys = NULL;
                   bool isDict = false;
                   if (PyDict_Check(object)) {
                     keys = PyDict_Keys(object);
                     isDict = true;
                   } else {
                     keys = PyObject_Dir(object);
                   }
                   if (keys) {
                     int count = PyList_Size(keys);
                     PyObject* key;
                     PyObject* value;
                     QString keystr;
                     for (int i = 0;i<count;i++) {
                       key = PyList_GetItem(keys,i);
                       if (isDict) {
                         value = PyDict_GetItem(object, key);
                         Py_INCREF(value);
                       } else {
                         value = PyObject_GetAttr(object, key);
                       }
                       if (!value) continue;
                       keystr = PyString_AsString(key);
                       static const QString underscoreStr("__tmp");
                       if (!keystr.startsWith(underscoreStr)) {
                         switch (type) {
                         case Anything:
                           results << keystr;
                           break;
                         case Class:
                           if (value->ob_type == &PyClass_Type) {
                             results << keystr;
                           }
                           break;
                         case Variable:
                           if (value->ob_type != &PyClass_Type
                             && value->ob_type != &PyCFunction_Type
                             && value->ob_type != &PyFunction_Type
                             && value->ob_type != &PyModule_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Function:
                           if (value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Module:
                           if (value->ob_type == &PyModule_Type) {
                             results << keystr;
                           }
                           break;
                         default:
                           std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                         }
                       }
                       Py_DECREF(value);
                     }
                     Py_DECREF(keys);
                   }
                 }
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
             {
               PythonQtObjectPtr callable = lookupCallable(object, name);
               if (callable) {
                 return call(callable, args);
               } else {
                 return QVariant();
               }
             }
             QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
             {
               QVariant r;
               PythonQtObjectPtr result;
               result.setNewRef(callAndReturnPyObject(callable, args));
               if (result) {
                 r = PythonQtConv::PyObjToQVariant(result);
               } else {
                 PythonQt::self()->handleError();
               }
               return r;
             }
             PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args)
             {
               PyObject* result = NULL;
               if (callable) {
                 PythonQtObjectPtr pargs;
                 int count = args.size();
                 if (count>0) {
                   pargs.setNewRef(PyTuple_New(count));
                 }
                 bool err = false;
                 // transform QVariants to Python
                 for (int i = 0; i < count; i++) {
                   PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
                   if (arg) {
                     // steals reference, no unref
                     PyTuple_SetItem(pargs, i,arg);
                   } else {
                     err = true;
                     break;
                   }
                 }
                 if (!err) {
                   PyErr_Clear();
                   result = PyObject_CallObject(callable, pargs);
                 }
               }
               return result;
             }
             void PythonQt::addInstanceDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::InstanceDecorator);
             }
             void PythonQt::addClassDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::StaticDecorator | PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
             }
             void PythonQt::addDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::AllDecorators);
             }
             void PythonQt::registerQObjectClassNames(const QStringList& names)
             {
               _p->registerQObjectClassNames(names);
             }
             void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
             {
               _p->_importInterface = importInterface;
               PythonQtImport::init();
             }
             void PythonQt::setImporterIgnorePaths(const QStringList& paths)
             {
               _p->_importIgnorePaths = paths;
             }
             const QStringList& PythonQt::getImporterIgnorePaths()
             {
               return _p->_importIgnorePaths;
             }
             void PythonQt::addWrapperFactory(PythonQtCppWrapperFactory* factory)
             {
               _p->_cppWrapperFactories.append(factory);
             }
             //---------------------------------------------------------------------------------------------------
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
               _defaultImporter = new PythonQtQFileImporter;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
               _currentClassInfoForClassWrapperCreation = NULL;
             }
             void PythonQtPrivate::setupSharedLibrarySuffixes()
             {
               _sharedLibrarySuffixes.clear();
               PythonQtObjectPtr imp;
               imp.setNewRef(PyImport_ImportModule("imp"));
               int cExtensionCode = imp.getVariable("C_EXTENSION").toInt();
               QVariant result = imp.call("get_suffixes");
               foreach (QVariant entry, result.toList()) {
                 QVariantList suffixEntry = entry.toList();
                 if (suffixEntry.count()==3) {
                   int code = suffixEntry.at(2).toInt();
                   if (code == cExtensionCode) {
                     _sharedLibrarySuffixes << suffixEntry.at(0).toString();
                   }
                 }
               }
             }
             PythonQtClassInfo* PythonQtPrivate::currentClassInfoForClassWrapperCreation()
             {
               PythonQtClassInfo* info = _currentClassInfoForClassWrapperCreation;
               _currentClassInfoForClassWrapperCreation = NULL;
               return info;
             }
             void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)
             {
               o->setParent(this);
               int numMethods = o->metaObject()->methodCount();
               for (int i = 0; i < numMethods; i++) {
                 QMetaMethod m = o->metaObject()->method(i);
                 if ((m.methodType() == QMetaMethod::Method ||
                   m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().at(0).isPointer) {
                       QByteArray signature = m.signature();
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                       PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                       PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                       classInfo->addConstructor(newSlot);
                     }
                   } else if (qstrncmp(m.signature(), "delete_", 7)==0) {
                     if ((decoTypes & DestructorDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->setDestructor(newSlot);
                   } else if (qstrncmp(m.signature(), "static_", 7)==0) {
                     if ((decoTypes & StaticDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
                     nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->addDecoratorSlot(newSlot);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().count()>1) {
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.isPointer) {
                         PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(p.name);
                         PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::InstanceDecorator);
                         classInfo->addDecoratorSlot(newSlot);
                       }
                     }
                   }
                 }
               }
             }
             void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
             {
               foreach(QString name, names) {
                 _knownQObjectClassNames.insert(name.toLatin1(), true);
               }
             }
             void PythonQtPrivate::removeSignalEmitter(QObject* obj)
             {
               _signalReceivers.remove(obj);
             }
             bool PythonQt::handleError()
             {
               bool flag = false;
               if (PyErr_Occurred()) {
                 // currently we just print the error and the stderr handler parses the errors
                 PyErr_Print();
                 /*
                 // EXTRA: the format of the ptype and ptraceback is not really documented, so I use PyErr_Print() above
                 PyObject *ptype;
                 PyObject *pvalue;
                 PyObject *ptraceback;
                 PyErr_Fetch( &ptype, &pvalue, &ptraceback);
                   Py_XDECREF(ptype);
                   Py_XDECREF(pvalue);
                   Py_XDECREF(ptraceback);
                 */
                 PyErr_Clear();
                 flag = true;
               }
               return flag;
             }
             void PythonQt::addSysPath(const QString& path)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PythonQtObjectPtr obj = lookupObject(sys, "path");
               PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
             }
             void PythonQt::overwriteSysPath(const QStringList& paths)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PyModule_AddObject(sys, "path", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::setModuleImportPath(PyObject* module, const QStringList& paths)
             {
               PyModule_AddObject(module, "__path__", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::stdOutRedirectCB(const QString& str)
             {
               emit PythonQt::self()->pythonStdOut(str);
             }
             void PythonQt::stdErrRedirectCB(const QString& str)
             {
               emit PythonQt::self()->pythonStdErr(str);
             }
             void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
             {
               _p->_wrappedCB = cb;
             }
             void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
             {
               _p->_noLongerWrappedCB = cb;
             }
             static PyMethodDef PythonQtMethods[] = {
               {NULL, NULL, 0, NULL}
             };
             void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName)
             {
               QByteArray name = "PythonQt";
               if (!pythonQtModuleName.isEmpty()) {
                 name = pythonQtModuleName;
               }
               _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
               _p->_pythonQtModuleName = name;
               if (redirectStdOut) {
                 PythonQtObjectPtr sys;
                 PythonQtObjectPtr out;
                 PythonQtObjectPtr err;
                 sys.setNewRef(PyImport_ImportModule("sys"));
                 // create a redirection object for stdout and stderr
                 out = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)out.object())->_cb = stdOutRedirectCB;
                 err = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)err.object())->_cb = stdErrRedirectCB;
                 // replace the built in file objects with our own objects
                 PyModule_AddObject(sys, "stdout", out);
                 PyModule_AddObject(sys, "stderr", err);
               }
             }
             void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator, shell);
             }
             PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const char* typeName)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (!info) {
                 info = new PythonQtClassInfo();
                 info->setupCPPObject(typeName);
                 _knownClassInfos.insert(typeName, info);
               }
               return info;
             }
             void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               _p->addPolymorphicHandler(typeName, cb);
             }
             void PythonQtPrivate::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               info->addPolymorphicHandler(cb);
             }
             bool PythonQt::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               return _p->addParentClass(typeName, parentTypeName, upcastingOffset);
             }
             bool PythonQtPrivate::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (info) {
                 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(parentTypeName);
                 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo, upcastingOffset));
                 return true;
               } else {
                 return false;
               }
             }
-            void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell, PyObject* module)
+            void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               if (!info->pythonQtClassWrapper()) {
+                info->setTypeSlots(typeSlots);
                 info->setupCPPObject(typeName);
                 createPythonQtClassWrapper(info, package, module);
               }
               if (parentTypeName && strcmp(parentTypeName,"")!=0) {
                 addParentClass(typeName, parentTypeName, 0);
               }
               if (wrapperCreator) {
                 info->setDecoratorProvider(wrapperCreator);
               }
               if (shell) {
                 info->setShellSetInstanceWrapperCB(shell);
               }
             }
             PyObject* PythonQtPrivate::packageByName(const char* name)
             {
               if (name==NULL || name[0]==0) {
                 name = "private";
               }
               PyObject* v = _packages.value(name);
               if (!v) {
                 v = PyImport_AddModule((_pythonQtModuleName + "." + name).constData());
                 _packages.insert(name, v);
                 // AddObject steals the reference, so increment it!
                 Py_INCREF(v);
                 PyModule_AddObject(_pythonQtModule, name, v);
               }
               return v;
             }
             void PythonQtPrivate::handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result)
             {
               QString error = "Return value '" + PythonQtConv::PyObjGetString(result) + "' can not be converted to expected C++ type '" + methodInfo->parameters().at(0).name + "' as return value of virtual method " + signature;
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               PythonQt::self()->handleError();
             }
             PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
             {
               if (_p->_initFlags & ExternalHelp) {
                 emit pythonHelpRequest(QByteArray(info->className()));
                 return Py_BuildValue("");
               } else {
                 return PyString_FromString(info->help().toLatin1().data());
               }
             }
             void PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);
             }
             void PythonQtPrivate::addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper)
             {
               _wrappedObjects.insert(obj, wrapper);
             }
             PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
             {
               PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
               if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
                 // this is a wrapper whose QObject was already removed due to destruction
                 // so the obj pointer has to be a new QObject with the same address...
                 // we remove the old one and set the copy to NULL
                 wrap->_objPointerCopy = NULL;
                 removeWrapperPointer(obj);
                 wrap = NULL;
               }
               return wrap;
             }
             PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
             {
               PythonQtObjectPtr result;
               if (pycode) {
                 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
               } else {
                 PythonQt::self()->handleError();
               }
               return result;
             }

src/PythonQt.h +38 -2

             #ifndef _PYTHONQT_H
             #define _PYTHONQT_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
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtSystem.h"
             #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassWrapper.h"
             #include "PythonQtSlot.h"
             #include "PythonQtObjectPtr.h"
             #include <QObject>
             #include <QVariant>
             #include <QList>
             #include <QHash>
             #include <QByteArray>
             #include <QStringList>
             #include <QtDebug>
             #include <iostream>
             class PythonQtClassInfo;
             class PythonQtPrivate;
             class PythonQtMethodInfo;
             class PythonQtSignalReceiver;
             class PythonQtImportFileInterface;
             class PythonQtCppWrapperFactory;
             class PythonQtQFileImporter;
             typedef void  PythonQtQObjectWrappedCB(QObject* object);
             typedef void  PythonQtQObjectNoLongerWrappedCB(QObject* object);
             typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, char **class_name);
             typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
             template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) { ((T*)object)->_wrapper = wrapper; };
             //! returns the offset that needs to be added to upcast an object of type T1 to T2
             template<class T1, class T2> int PythonQtUpcastingOffset() {
               return (((char*)(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) - ((char*)reinterpret_cast<T1*>(0x100)));
             }
             //! callback to create a QObject lazily
             typedef QObject* PythonQtQObjectCreatorFunctionCB();
             //! helper template to create a derived QObject class
             template<class T> QObject* PythonQtCreateObject() { return new T(); };
             //! the main interface to the Python Qt binding, realized as a singleton
             class PYTHONQT_EXPORT PythonQt : public QObject {
               Q_OBJECT
             public:
               enum InitFlags {
                 RedirectStdOut = 1,   //!<< sets if the std out/err is redirected to pythonStdOut() and pythonStdErr() signals
                 IgnoreSiteModule = 2, //!<< sets if Python should ignore the site module
                 ExternalHelp = 4      //!<< sets if help() calls on PythonQt modules are forwarded to the pythonHelpRequest() signal
               };
+              //! flags that tell PythonQt which operators to expect on the registered type
+              enum TypeSlots {
+                Type_Add = 1,
+                Type_Subtract = 1 << 1,
+                Type_Multiply = 1 << 2,
+                Type_Divide = 1 << 3,
+                Type_Mod = 1 << 4,
+                Type_And = 1 << 5,
+                Type_Or = 1 << 6,
+                Type_Xor = 1 << 7,
+                Type_LShift = 1 << 8,
+                Type_RShift = 1 << 9,
+                Type_InplaceAdd = 1 << 10,
+                Type_InplaceSubtract = 1 << 11,
+                Type_InplaceMultiply = 1 << 12,
+                Type_InplaceDivide = 1 << 13,
+                Type_InplaceMod = 1 << 14,
+                Type_InplaceAnd = 1 << 15,
+                Type_InplaceOr = 1 << 16,
+                Type_InplaceXor = 1 << 17,
+                Type_InplaceLShift = 1 << 18,
+                Type_InplaceRShift = 1 << 19,
+                // Not yet needed/nicely mappable/generated...
+                //Type_Positive = 1 << 29,
+                //Type_Negative = 1 << 29,
+                //Type_Abs = 1 << 29,
+                //Type_Hash = 1 << 29,
+                Type_Invert = 1 << 29,
+                Type_RichCompare = 1 << 30,
+                Type_NonZero     = 1 << 31,
+              };
               //! initialize the python qt binding (flags are a or combination of InitFlags), if \c pythonQtModuleName is given
               //! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
               //! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
               static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());
               //! cleanup
               static void cleanup();
               //! get the singleton instance
               static PythonQt* self() { return _self; }
               //-----------------------------------------------------------------------------
               // Public API:
               //! defines the object types for introspection
               enum ObjectType {
                 Class,
                 Function,
                 Variable,
                 Module,
                 Anything,
                 CallOverloads
               };
               //! overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path)
               void overwriteSysPath(const QStringList& paths);
               //! prepend a path to sys.path to allow importing from it
               void addSysPath(const QString& path);
               //! sets the __path__ list of a module to the given list (important for local imports)
               void setModuleImportPath(PyObject* module, const QStringList& paths);
               //! get the __main__ module of python
               PythonQtObjectPtr getMainModule();
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
               void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
               void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void registerQObjectClassNames(const QStringList& names);
               //! add a parent class relation to the \c given typeName, the upcastingOffset is needed for multiple inheritance
               //! and can be calculated using PythonQtUpcastingOffset<type,parentType>(), which also verifies that
               //! type is really derived from parentType.
               //! Returns false if the typeName was not yet registered.
               bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset=0);
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
               //! parses the given file and returns the python code object, this can then be used to call evalCode()
               PythonQtObjectPtr parseFile(const QString& filename);
               //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
               //! If pycode is NULL, a python error is printed.
               QVariant evalCode(PyObject* object, PyObject* pycode);
               //! evaluates the given script code and returns the result value
               QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
               //! evaluates the given script code from file
               void evalFile(PyObject* object, const QString& filename);
               //! creates the new module \c name and evaluates the given file in the context of that module
               //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
               //! creates the new module \c name and evaluates the given script in the context of that module.
               //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
               //! create a uniquely named module, you can use evalFile or evalScript to populate the module with
               //! script code
               PythonQtObjectPtr createUniqueModule();
               //@{ Signal handlers
               //! add a signal handler to the given \c signal of \c obj  and connect it to a callable \c objectname in module
               bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
               //! remove a signal handler from the given \c signal of \c obj
               bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
               //! add a signal handler to the given \c signal of \c obj  and connect it to a callable \c receiver
               bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
               //! remove a signal handler from the given \c signal of \c obj
               bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
               //@}
               //@{ Variable access
               //! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)
               void addObject(PyObject* object, const QString& name, QObject* qObject);
               //! add the given variable to the object
               void addVariable(PyObject* object, const QString& name, const QVariant& v);
               //! remove the given variable
               void removeVariable(PyObject* module, const QString& name);
               //! get the variable with the \c name of the \c object, returns an invalid QVariant on error
               QVariant getVariable(PyObject* object, const QString& name);
               //! read vars etc. in scope of an \c object, optional looking inside of an object \c objectname
               QStringList introspection(PyObject* object, const QString& objectname, ObjectType type);
               //! returns the found callable object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
               //@}
               //@{ Calling of python callables
               //! call the given python \c callable in the scope of object, returns the result converted to a QVariant
               QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());
               //! call the given python object, returns the result converted to a QVariant
               QVariant call(PyObject* callable, const QVariantList& args = QVariantList());
               //! call the given python object, returns the result as new PyObject
               PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList());
               //@}
               //@{ Decorations, constructors, wrappers...
               //! add an object whose slots will be used as decorator slots for
               //! other QObjects or CPP classes. The slots need to follow the
               //! convention that the first argument is a pointer to the wrapped object.
               //! (ownership is passed to PythonQt)
               /*!
               Example:
               A slot with the signature
               \code
               bool doSomething(QWidget* w, int a)
               \endcode
               will extend QWidget instances (and derived classes) with a "bool doSomething(int a)" slot
               that will be called with the concrete instance as first argument.
               So in Python you can now e.g. call
               \code
               someWidget.doSomething(12)
               \endcode
               without QWidget really having this method. This allows to easily make normal methods
               of Qt classes callable by forwarding them with such decorator slots
               or to make CPP classes (which are not derived from QObject) callable from Python.
               */
               void addInstanceDecorators(QObject* o);
               //! add an object whose slots will be used as decorator slots for
               //! class objects (ownership is passed to PythonQt)
               /*!
               The slots need to follow the following convention:
               - SomeClass* new_SomeClass(...)
               - QVariant new_SomeClass(...)
               - void delete_SomeClass(SomeClass*)
               - ... static_SomeClass_someName(...)
               This will add:
               - a constructor
               - a constructor which generates a QVariant
               - a destructor (only useful for CPP objects)
               - a static decorator slot which will be available on the MetaObject (visible in PythonQt module)
               */
               void addClassDecorators(QObject* o);
               //! this will add the object both as class and instance decorator (ownership is passed to PythonQt)
               void addDecorators(QObject* o);
               //! add the given factory to PythonQt (ownership stays with caller)
               void addWrapperFactory(PythonQtCppWrapperFactory* factory);
               //@}
               //@{ Custom importer (to replace internal import implementation of python)
               //! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)
               //! (this method should be called directly after initialization of init() and before calling overwriteSysPath().
               //! On the first call to this method, it will install a generic PythonQt importer in Pythons "path_hooks".
               //! This is not reversible, so even setting setImporter(NULL) afterwards will
               //! keep the custom PythonQt importer with a QFile default import interface.
               //! Subsequent python import calls will make use of the passed importInterface
               //! which forwards all import calls to the given \c importInterface.
               //! Passing NULL will install a default QFile importer.
               //! (\c importInterface ownership stays with caller)
               void setImporter(PythonQtImportFileInterface* importInterface);
               //! this installs the default QFile importer (which effectively does a setImporter(NULL))
               //! (without calling setImporter or installDefaultImporter at least once, the default python import
               //! mechanism is in place)
               //! the default importer allows to import files from anywhere QFile can read from,
               //! including the Qt resource system using ":". Keep in mind that you need to extend
               //! "sys.path" with ":" to be able to import from the Qt resources.
               void installDefaultImporter() { setImporter(NULL); }
               //! set paths that the importer should ignore
               void setImporterIgnorePaths(const QStringList& paths);
               //! get paths that the importer should ignore
               const QStringList& getImporterIgnorePaths();
               //@}
               //! get access to internal data (should not be used on the public API, but is used by some C functions)
               static PythonQtPrivate* priv() { return _self->_p; }
               //! get access to the file importer (if set)
               static PythonQtImportFileInterface* importInterface();
               //! handle a python error, call this when a python function fails. If no error occurred, it returns false.
               //! The error is currently just output to the python stderr, future version might implement better trace printing
               bool handleError();
               //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
               void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
               //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
               void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
               //! call the callback if it is set
               static void qObjectNoLongerWrappedCB(QObject* o);
             signals:
               //! emitted when python outputs something to stdout (and redirection is turned on)
               void pythonStdOut(const QString& str);
               //! emitted when python outputs something to stderr (and redirection is turned on)
               void pythonStdErr(const QString& str);
               //! emitted when help() is called on a PythonQt object and \c ExternalHelp is enabled
               void pythonHelpRequest(const QByteArray& cppClassName);
             public:
               //! called by internal help methods
               PyObject* helpCalled(PythonQtClassInfo* info);
               //! returns the found object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
             private:
               void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
               //! callback for stdout redirection, emits pythonStdOut signal
               static void stdOutRedirectCB(const QString& str);
               //! callback for stderr redirection, emits pythonStdErr signal
               static void stdErrRedirectCB(const QString& str);
               //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
               PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
               PythonQt(int flags, const QByteArray& pythonQtModuleName);
               ~PythonQt();
               static PythonQt* _self;
               static int _uniqueModuleCount;
               PythonQtPrivate* _p;
             };
             //! internal PythonQt details
             class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
               Q_OBJECT
             public:
               PythonQtPrivate();
               ~PythonQtPrivate();
               enum DecoratorTypes {
                 StaticDecorator = 1,
                 ConstructorDecorator = 2,
                 DestructorDecorator = 4,
                 InstanceDecorator = 8,
                 AllDecorators = 0xffff
               };
               //! get the suffixes that are used for shared libraries
               const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }
               //! returns if the id is the id for PythonQtObjectPtr
               bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
               //! add the wrapper pointer (for reuse if the same obj appears while wrapper still exists)
               void addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper);
               //! remove the wrapper ptr again
               void removeWrapperPointer(void* obj);
               //! add parent class relation
               bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
               //! lookup existing classinfo and return new if not yet present
               PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
               //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
               void removeSignalEmitter(QObject* obj);
               //! wrap the given QObject into a Python object (or return existing wrapper!)
               PyObject* wrapQObject(QObject* obj);
               //! wrap the given ptr into a Python object (or return existing wrapper!) if there is a known QObject of that name or a known wrapper in the factory
               PyObject* wrapPtr(void* ptr, const QByteArray& name);
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                  you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
-              void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL);
+              void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
-              void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL);
+              void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void registerQObjectClassNames(const QStringList& names);
               //! add a decorator object
               void addDecorators(QObject* o, int decoTypes);
               //! helper method that creates a PythonQtClassWrapper object  (returns a new reference)
               PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);
               //! create a new instance of the given enum type with given value (returns a new reference)
               static PyObject*  createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
               //! helper that creates a new int derived class that represents the enum of the given name  (returns a new reference)
               static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
               //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
               PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownClassInfos.value(meta->className()); }
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownClassInfos.value(className); }
               //! creates the new module from the given pycode
               PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
               //! get the current class info (for the next PythonQtClassWrapper that is created) and reset it to NULL again
               PythonQtClassInfo* currentClassInfoForClassWrapperCreation();
               //! the dummy tuple (which is empty and may be used to detected that a wrapper is called from internal wrapper creation
               static PyObject* dummyTuple();
               //! called by virtual overloads when a python return value can not be converted to the required Qt type
               void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);
               //! get access to the PythonQt module
               PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }
             private:
               //! Setup the shared library suffixes by getting them from the "imp" module.
               void setupSharedLibrarySuffixes();
               //! create a new pythonqt class wrapper and place it in the pythonqt module
               void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
               //! get/create new package module (the returned object is a borrowed reference)
               PyObject* packageByName(const char* name);
               //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
               PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
               //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
               QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;
               //! stores the meta info of known Qt classes
               QHash<QByteArray, PythonQtClassInfo *>   _knownClassInfos;
               //! names of qobject derived classes that can be casted to qobject savely
               QHash<QByteArray, bool> _knownQObjectClassNames;
               //! stores signal receivers for QObjects
               QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;
               //! the PythonQt python module
               PythonQtObjectPtr _pythonQtModule;
               //! the name of the PythonQt python module
               QByteArray _pythonQtModuleName;
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
               //! the default importer
               PythonQtQFileImporter* _defaultImporter;
               PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
               PythonQtQObjectWrappedCB* _wrappedCB;
               QStringList _importIgnorePaths;
               QStringList _sharedLibrarySuffixes;
               //! the cpp object wrapper factories
               QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
               QHash<QByteArray, PyObject*> _packages;
               PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;
               friend class PythonQt;
             };
             #endif

src/PythonQtClassInfo.cpp +1 0

             /*
             *
             *  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;
+              _typeSlots = 0;
               _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("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 +6 0

             #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);
+              //! set the type capabilities
+              void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; }
+              //! get the type capabilities
+              int typeSlots() const { return _typeSlots; }
               //! 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 "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;
+              int                                  _typeSlots;
               bool                                 _isQObject;
               bool                                 _enumsCreated;
             };
             //---------------------------------------------------------------
             #endif

src/PythonQtClassWrapper.cpp +162 0

             /*
              *
              *  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    PythonQtClassWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtClassWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             #include "PythonQtInstanceWrapper.h"
+            static PyObject* PythonQtInstanceWrapper_invert(PythonQtInstanceWrapper* wrapper)
+            {
+              PyObject* result = NULL;
+              static QByteArray memberName = "__invert__";
+              PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
+              if (opSlot._type == PythonQtMemberInfo::Slot) {
+                result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
+              }
+              return result;
+            }
+            static int PythonQtInstanceWrapper_nonzero(PythonQtInstanceWrapper* wrapper)
+            {
+              int result = (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
+              if (result) {
+                static QByteArray memberName = "__nonzero__";
+                PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
+                if (opSlot._type == PythonQtMemberInfo::Slot) {
+                  PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
+                  if (resultObj == Py_False) {
+                    result = 0;
+                  }
+                  Py_XDECREF(resultObj);
+                }
+              }
+              return result;
+            }
+            static PyObject* PythonQtInstanceWrapper_binaryfunc(PythonQtInstanceWrapper* wrapper, PyObject* other, const QByteArray& opName, const QByteArray& fallbackOpName = QByteArray())
+            {
+              PyObject* result = NULL;
+              PythonQtMemberInfo opSlot = wrapper->classInfo()->member(opName);
+              if (opSlot._type == PythonQtMemberInfo::Slot) {
+                // TODO get rid of tuple
+                PyObject* args = PyTuple_New(1);
+                Py_INCREF(other);
+                PyTuple_SET_ITEM(args, 0, other);
+                result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
+                Py_DECREF(args);
+                if (!result && !fallbackOpName.isEmpty()) {
+                  // try fallback if we did not get a result
+                  result = PythonQtInstanceWrapper_binaryfunc(wrapper, other, fallbackOpName);
+                }
+              }
+              return result;
+            }
+            #define BINARY_OP(NAME) \
+            static PyObject* PythonQtInstanceWrapper_ ## NAME(PythonQtInstanceWrapper* wrapper, PyObject* other) \
+            { \
+              static const QByteArray opName("__" #NAME "__"); \
+              return PythonQtInstanceWrapper_binaryfunc(wrapper, other, opName); \
+            }
+            #define BINARY_OP_INPLACE(NAME) \
+              static PyObject* PythonQtInstanceWrapper_i ## NAME(PythonQtInstanceWrapper* wrapper, PyObject* other) \
+            { \
+              static const QByteArray opName("__i" #NAME "__"); \
+              static const QByteArray fallbackName("__" #NAME "__"); \
+              return PythonQtInstanceWrapper_binaryfunc(wrapper, other, opName, fallbackName); \
+            }
+            BINARY_OP(add)
+            BINARY_OP(sub)
+            BINARY_OP(mul)
+            BINARY_OP(div)
+            BINARY_OP(and)
+            BINARY_OP(or)
+            BINARY_OP(xor)
+            BINARY_OP(mod)
+            BINARY_OP(lshift)
+            BINARY_OP(rshift)
+            BINARY_OP_INPLACE(add)
+            BINARY_OP_INPLACE(sub)
+            BINARY_OP_INPLACE(mul)
+            BINARY_OP_INPLACE(div)
+            BINARY_OP_INPLACE(and)
+            BINARY_OP_INPLACE(or)
+            BINARY_OP_INPLACE(xor)
+            BINARY_OP_INPLACE(mod)
+            BINARY_OP_INPLACE(lshift)
+            BINARY_OP_INPLACE(rshift)
+            static void initializeSlots(PythonQtClassWrapper* wrap)
+            {
+              int typeSlots = wrap->classInfo()->typeSlots();
+              if (typeSlots) {
+                if (typeSlots & PythonQt::Type_Add) {
+                  wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_add;
+                }
+                if (typeSlots & PythonQt::Type_Subtract) {
+                  wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_sub;
+                }
+                if (typeSlots & PythonQt::Type_Multiply) {
+                  wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_mul;
+                }
+                if (typeSlots & PythonQt::Type_Divide) {
+                  wrap->_base.as_number.nb_divide = (binaryfunc)PythonQtInstanceWrapper_div;
+                  wrap->_base.as_number.nb_true_divide = (binaryfunc)PythonQtInstanceWrapper_div;
+                }
+                if (typeSlots & PythonQt::Type_And) {
+                  wrap->_base.as_number.nb_and = (binaryfunc)PythonQtInstanceWrapper_and;
+                }
+                if (typeSlots & PythonQt::Type_Or) {
+                  wrap->_base.as_number.nb_or = (binaryfunc)PythonQtInstanceWrapper_or;
+                }
+                if (typeSlots & PythonQt::Type_Xor) {
+                  wrap->_base.as_number.nb_xor = (binaryfunc)PythonQtInstanceWrapper_xor;
+                }
+                if (typeSlots & PythonQt::Type_Mod) {
+                  wrap->_base.as_number.nb_remainder = (binaryfunc)PythonQtInstanceWrapper_mod;
+                }
+                if (typeSlots & PythonQt::Type_LShift) {
+                  wrap->_base.as_number.nb_lshift = (binaryfunc)PythonQtInstanceWrapper_lshift;
+                }
+                if (typeSlots & PythonQt::Type_RShift) {
+                  wrap->_base.as_number.nb_rshift = (binaryfunc)PythonQtInstanceWrapper_rshift;
+                }
+                if (typeSlots & PythonQt::Type_InplaceAdd) {
+                  wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_iadd;
+                }
+                if (typeSlots & PythonQt::Type_InplaceSubtract) {
+                  wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_isub;
+                }
+                if (typeSlots & PythonQt::Type_InplaceMultiply) {
+                  wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_imul;
+                }
+                if (typeSlots & PythonQt::Type_InplaceDivide) {
+                  wrap->_base.as_number.nb_inplace_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
+                  wrap->_base.as_number.nb_inplace_true_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
+                }
+                if (typeSlots & PythonQt::Type_InplaceAnd) {
+                  wrap->_base.as_number.nb_inplace_and = (binaryfunc)PythonQtInstanceWrapper_iand;
+                }
+                if (typeSlots & PythonQt::Type_InplaceOr) {
+                  wrap->_base.as_number.nb_inplace_or = (binaryfunc)PythonQtInstanceWrapper_ior;
+                }
+                if (typeSlots & PythonQt::Type_InplaceXor) {
+                  wrap->_base.as_number.nb_inplace_xor = (binaryfunc)PythonQtInstanceWrapper_ixor;
+                }
+                if (typeSlots & PythonQt::Type_InplaceMod) {
+                  wrap->_base.as_number.nb_inplace_remainder = (binaryfunc)PythonQtInstanceWrapper_imod;
+                }
+                if (typeSlots & PythonQt::Type_InplaceLShift) {
+                  wrap->_base.as_number.nb_inplace_lshift = (binaryfunc)PythonQtInstanceWrapper_ilshift;
+                }
+                if (typeSlots & PythonQt::Type_InplaceRShift) {
+                  wrap->_base.as_number.nb_inplace_rshift = (binaryfunc)PythonQtInstanceWrapper_irshift;
+                }
+                if (typeSlots & PythonQt::Type_Invert) {
+                  wrap->_base.as_number.nb_invert = (unaryfunc)PythonQtInstanceWrapper_invert;
+                }
+                if (typeSlots & PythonQt::Type_NonZero) {
+                  wrap->_base.as_number.nb_nonzero = (inquiry)PythonQtInstanceWrapper_nonzero;
+                }
+              }
+            }
             static PyObject* PythonQtClassWrapper_alloc(PyTypeObject *self, Py_ssize_t nitems)
             {
               // call the default type alloc
               PyObject* obj = PyType_Type.tp_alloc(self, nitems);
               // take current class type, if we are called via newPythonQtClassWrapper()
               PythonQtClassWrapper* wrap = (PythonQtClassWrapper*)obj;
               wrap->_classInfo = PythonQt::priv()->currentClassInfoForClassWrapperCreation();
+              initializeSlots(wrap);
               return obj;
             }
             static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args, PyObject* kwds)
             {
               // call the default type init
               if (PyType_Type.tp_init((PyObject *)self, args, kwds) < 0) {
                 return -1;
               }
               // if we have no CPP class information, try our base class
               if (!self->classInfo()) {
                 PyTypeObject*  superType = ((PyTypeObject *)self)->tp_base;
                 if (!superType || (superType->ob_type != &PythonQtClassWrapper_Type)) {
                   PyErr_Format(PyExc_TypeError, "type %s is not derived from PythonQtClassWrapper", ((PyTypeObject*)self)->tp_name);
                   return -1;
                 }
                 // take the class info from the superType
                 self->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
               }
               return 0;
             }
             static PyObject *PythonQtClassWrapper_classname(PythonQtClassWrapper* type)
             {
               return PyString_FromString((QString("Class_") + type->classInfo()->className()).toLatin1().data());
             }
             static PyObject *PythonQtClassWrapper_help(PythonQtClassWrapper* type)
             {
               return PythonQt::self()->helpCalled(type->classInfo());
             }
             PyObject *PythonQtClassWrapper__init__(PythonQtClassWrapper *type, PyObject *args)
             {
               Py_ssize_t argc = PyTuple_Size(args);
               if (argc>0) {
                 // we need to call __init__ of the instance
                 PyObject* self = PyTuple_GET_ITEM(args, 0);
                 if (PyObject_TypeCheck(self, (PyTypeObject*)type->classInfo()->pythonQtClassWrapper())) {
                   PyObject* newargs = PyTuple_New(argc-1);
                   for (int i = 0;i<argc-1; i++) {
                     PyTuple_SET_ITEM(newargs, i,PyTuple_GET_ITEM(args, i+1));
                   }
                   PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self;
                   int result = PythonQtInstanceWrapper_init(wrapper, newargs, NULL);
                   Py_DECREF(newargs);
                   if (result==0) {
                     Py_INCREF(Py_None);
                     return Py_None;
                   } else {
                     // init failed!
                   }
                 } else {
                   // self not of correct type!
                 }
               } else {
                 // wrong number of args
               }
               return NULL;
             }
             static PyMethodDef PythonQtClassWrapper_methods[] = {
                 {"__init__", (PyCFunction)PythonQtClassWrapper__init__, METH_VARARGS,
                 "Return the classname of the object"
                 },
                 {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
             static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
             {
               const char *attributeName;
               PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (obj == (PyObject*)&PythonQtInstanceWrapper_Type) {
                 return NULL;
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 PyObject* dict = ((PyTypeObject *)wrapper)->tp_dict;
                 if (!wrapper->classInfo()) {
                   Py_INCREF(dict);
                   return dict;
                 }
                 dict = PyDict_Copy(dict);
                 QStringList l = wrapper->classInfo()->memberList(false);
                 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 {
                     // it must have been a property or child, which we do not know as a class object...
                   }
                 }
                 if (wrapper->classInfo()->constructors()) {
                   PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[0], obj);
                   PyDict_SetItemString(dict, "__init__", func);
                   Py_DECREF(func);
                 }
                 for (int i = 1;i<3;i++) {
                   PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);
                   PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);
                   Py_DECREF(func);
                 }
                 return dict;
               }
               if (wrapper->classInfo()) {
                 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
                 if (member._type == PythonQtMemberInfo::EnumValue) {
                   PyObject* enumValue = member._enumValue;
                   Py_INCREF(enumValue);
                   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);
                 }
               }
               // look for the interal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               // look in super
               PyObject* superAttr = PyType_Type.tp_getattro(obj, name);
               if (superAttr) {
                 return superAttr;
               }
               QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtClassWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               return PyType_Type.tp_setattro(obj,name,value);
             }
             /*
             static PyObject * PythonQtClassWrapper_repr(PyObject * obj)
             {
               PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
               if (wrapper->classInfo()->isCPPWrapper()) {
                 const QMetaObject* meta = wrapper->classInfo()->metaObject();
                 if (!meta) {
                   QObject* decorator = wrapper->classInfo()->decorator();
                   if (decorator) {
                     meta = decorator->metaObject();
                   }
                 }
                 if (meta) {
                   return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->classInfo()->className(), meta->className());
                 } else {
                   return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->classInfo()->className());
                 }
               } else {
                 return PyString_FromFormat("%s Class", wrapper->classInfo()->className());
               }
             }
             */
             PyTypeObject PythonQtClassWrapper_Type = {
                 PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtClassWrapper",             /*tp_name*/
                 sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
 ,                         /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
 ,                         /*tp_compare*/
 , //PythonQtClassWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
 ,                         /*tp_hash */
 ,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtClassWrapper_getattro,                         /*tp_getattro*/
                 PythonQtClassWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 ,           /* 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)PythonQtClassWrapper_init,      /* tp_init */
                 PythonQtClassWrapper_alloc,                         /* tp_alloc */
 ,                         /* tp_new */
 ,                         /* tp_free */
             };
             //-------------------------------------------------------

src/PythonQtInstanceWrapper.cpp +112 -68

             /*
             *
             *  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_richcompare(PythonQtInstanceWrapper* wrapper, PyObject* other, int code)
+            {
+              bool validPtrs = false;
+              bool areSamePtrs = false;
+              if (PyObject_TypeCheck((PyObject*)wrapper, &PythonQtInstanceWrapper_Type)) {
+                if (PyObject_TypeCheck(other, &PythonQtInstanceWrapper_Type)) {
+                  validPtrs = true;
+                  PythonQtInstanceWrapper* w1 = wrapper;
+                  PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)other;
+                  // check pointers directly
+                  if (w1->_wrappedPtr != NULL) {
+                    if (w1->_wrappedPtr == w2->_wrappedPtr) {
+                      areSamePtrs = true;
+                    }
+                  } else if (w1->_obj == w2->_obj) {
+                    areSamePtrs = true;
+                  }
+                } else if (other == Py_None) {
+                  validPtrs = true;
+                  if (wrapper->_obj || wrapper->_wrappedPtr) {
+                    areSamePtrs = false;
+                  } else {
+                    areSamePtrs = true;
+                  }
+                }
+              }
+              if ((wrapper->classInfo()->typeSlots() & PythonQt::Type_RichCompare) == 0) {
+                // shortcut if richcompare is not supported:
+                if (validPtrs && code == Py_EQ) {
+                  return PythonQtConv::GetPyBool(areSamePtrs);
+                } else if (validPtrs && code == Py_NE) {
+                  return PythonQtConv::GetPyBool(!areSamePtrs);
+                }
+                Py_INCREF(Py_NotImplemented);
+                return Py_NotImplemented;
+              }
+              QByteArray memberName;
+              switch (code) {
+              case Py_LT:
+                {
+                  static QByteArray name = "__lt__";
+                  memberName = name;
+                }
+                break;
+              case Py_LE:
+                {
+                  static QByteArray name = "__le__";
+                  memberName = name;
+                }
+                break;
+              case Py_EQ:
+                {
+                  static QByteArray name = "__eq__";
+                  memberName = name;
+                }
+                break;
+              case Py_NE:
+                {
+                  static QByteArray name = "__ne__";
+                  memberName = name;
+                }
+                break;
+              case Py_GT:
+                {
+                  static QByteArray name = "__gt__";
+                  memberName = name;
+                }
+                break;
+              case Py_GE:
+                {
+                  static QByteArray name = "__ge__";
+                  memberName = name;
+                }
+                break;
+              }
+              PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
+              if (opSlot._type == PythonQtMemberInfo::Slot) {
+                // TODO get rid of tuple
+                PyObject* args = PyTuple_New(1);
+                Py_INCREF(other);
+                PyTuple_SET_ITEM(args, 0, other);
+                PyObject* result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
+                Py_DECREF(args);
+                return result;
+              } else {
+                // not implemented, let python try something else!
+                Py_INCREF(Py_NotImplemented);
+                return Py_NotImplemented;
+              }
+            }
             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();
+                  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:
                 {
                   static const QByteArray getterString("py_get_");
                   // 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 slot
                 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) {
                 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;
               QString str = getStringFromObject(wrapper);
               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);
                 }
               }
               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)
+            static int PythonQtInstanceWrapper_builtin_nonzero(PyObject *obj)
-              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 */
+                PythonQtInstanceWrapper_builtin_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*/
+,                         /*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*/
+                Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
-,                   /* tp_richcompare */
+                (richcmpfunc)PythonQtInstanceWrapper_richcompare,                   /* 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