GIT_REPOSITORIES/LPP/PythonQt Commit - r175:7bc6abba6c12

generate extra wrappers for virtual slots to allow correct deriving via Python and to avoid recursion...

florianlink -

r175:7bc6abba6c12

parent child

Context file:

r175:7bc6abba6c12

Collapse all files

generator/abstractmetalang.h +1 -1

             /****************************************************************************
             **
             ** 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()); }
+                bool isVirtual() const { 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/shellheadergenerator.cpp +1 -1

             /****************************************************************************
             **
             ** 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()) {
+                if (!function->isSlot() || function->isVirtual()) {
                   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 << 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::PyWrapperDeclaration) {
                   s << cs.code() << endl;
                 }
               }
             }

generator/shellimplgenerator.cpp +4 -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 "shellimplgenerator.h"
             #include "reporthandler.h"
             #include "fileout.h"
             #include <iostream>
             extern void declareFunctionMetaTypes(QTextStream &stream,
                                                  const AbstractMetaFunctionList &functions,
                                                  QSet<QString> &registeredTypeNames);
             QString ShellImplGenerator::fileNameForClass(const AbstractMetaClass *meta_class) const
             {
               return QString("PythonQtWrapper_%1.cpp").arg(meta_class->name());
             }
             static bool include_less_than(const Include &a, const Include &b)
             {
               return a.name < b.name;
             }
             static void writeHelperCode(QTextStream &s, const AbstractMetaClass *)
             {
             }
             void ShellImplGenerator::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->addSource(pro_file_name, fileNameForClass(meta_class));
               s << "#include \"PythonQtWrapper_" << meta_class->name() << ".h\"" << endl << endl;
               s << "#include <PythonQtSignalReceiver.h>" << endl;
               s << "#include <PythonQtMethodInfo.h>" << endl;
               s << "#include <PythonQtConversion.h>" << endl;
               //if (!meta_class->generateShellClass())
               //    return;
               IncludeList list = meta_class->typeEntry()->extraIncludes();
               qSort(list.begin(), list.end());
               foreach (const Include &inc, list) {
                 ShellGenerator::writeInclude(s, inc);
               }
               s << endl;
               writeHelperCode(s, meta_class);
               // find constructors
               AbstractMetaFunctionList ctors;
               ctors = meta_class->queryFunctions(AbstractMetaClass::Constructors
                 | AbstractMetaClass::WasVisible
                 | AbstractMetaClass::NotRemovedFromTargetLang);
               // find member functions
               AbstractMetaFunctionList functions = getFunctionsToWrap(meta_class);
               // write metatype declarations
               {
                 //    QSet<QString> registeredTypeNames = m_qmetatype_declared_typenames;
                 //    declareFunctionMetaTypes(s, functions, registeredTypeNames);
                 //    s << endl;
               }
               if (meta_class->generateShellClass()) {
                 AbstractMetaFunctionList virtualsForShell = getVirtualFunctionsForShell(meta_class);
                 foreach (const AbstractMetaFunction *fun, virtualsForShell) {
                   bool hasReturnValue = (fun->type());
                   writeFunctionSignature(s, fun, meta_class, QString(),
                     Option(OriginalName | ShowStatic | UnderscoreSpaces),
                     "PythonQtShell_");
                   s << endl << "{" << endl;
                   Option typeOptions = Option(OriginalName | UnderscoreSpaces | SkipName);
                   AbstractMetaArgumentList args = fun->arguments();
                   s << "if (_wrapper) {" << endl;
                   s << "  PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, \"" << fun->name() << "\");" << endl;
                   s << "  PyErr_Clear();" << endl;
                   s << "  if (obj && !PythonQtSlotFunction_Check(obj)) {" << endl;
                   s << "    static const char* argumentList[] ={\"";
                   if (hasReturnValue) {
                     // write the arguments, return type first
                     writeTypeInfo(s, fun->type(), typeOptions);
                   }
                   s << "\"";
                   for (int i = 0; i < args.size(); ++i) {
                     s << " , \"";
                     writeTypeInfo(s, args.at(i)->type(), typeOptions);
                     s << "\"";
                   }
                   s << "};" << endl;
                   s << "    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(" << QString::number(args.size()+1) << ", argumentList);" << endl;
                   if (hasReturnValue) {
                     s << "      ";
                     writeTypeInfo(s, fun->type(), typeOptions);
                     s << " returnValue;" << endl;
                     // TODO: POD init to default is missing...
                   }
                   s << "    void* args[" << QString::number(args.size()+1) << "] = {NULL";
                   for (int i = 0; i < args.size(); ++i) {
                     s << ", (void*)&" << args.at(i)->argumentName();
                   }
                   s << "};" << endl;
                   s << "    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);" << endl;
                   if (hasReturnValue) {
                     s << "    if (result) {" << endl;
                     s << "      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);" << endl;
                     s << "      if (args[0]!=&returnValue) {" << endl;
                     s << "        if (args[0]==NULL) {" << endl;
                     s << "          PythonQt::priv()->handleVirtualOverloadReturnError(\"" << fun->name() << "\", methodInfo, result);" << endl;
                     s << "        } else {" << endl;
                     s << "          returnValue = *((";
                     writeTypeInfo(s, fun->type(), typeOptions);
                     s << "*)args[0]);" << endl;
                     s << "        }" << endl;
                     s << "      }" << endl;
                     s << "    }" << endl;
                   }
                   s << "    if (result) { Py_DECREF(result); } " << endl;
                   s << "    Py_DECREF(obj);" << endl;
                   if (hasReturnValue) {
                     s << "    return returnValue;" << endl;
                   } else {
                     s << "    return;" << endl;
                   }
                   s << "  }" << endl;
                   s << "}" << endl;
                   s << "  ";
                   if (fun->isAbstract()) {
                     if (fun->type()) {
                       // return empty default object
                       s << "return ";
                       if (fun->type()->indirections()>0) {
                         s << "0;";
                       } else {
                         writeTypeInfo(s, fun->type(), typeOptions);
                         s << "();";
                       }
                     }
                   } else {
                     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 << ");";
                   }
                   s << endl << "}" << endl;
                 }
               }
               if (meta_class->generateShellClass() || !meta_class->isAbstract()) {
                 // write constructors
                 foreach (const AbstractMetaFunction *ctor, ctors) {
                   if (!ctor->isPublic() || ctor->isAbstract()) { continue; }
                   s << meta_class->qualifiedCppName() << "* ";
                   s << "PythonQtWrapper_" << meta_class->name() << "::";
                   writeFunctionSignature(s, ctor, 0, "new_", Option(OriginalName | ShowStatic));
                   s << endl;
                   s << "{ " << endl;
                   s << "return new " << (meta_class->generateShellClass()?shellClassName(meta_class):meta_class->qualifiedCppName()) << "(";
                   AbstractMetaArgumentList args = ctor->arguments();
                   for (int i = 0; i < args.size(); ++i) {
                     if (i > 0)
                       s << ", ";
                     s << args.at(i)->argumentName();
                   }
                   s << ");" << " }" << endl << endl;
                 }
               }
               QString wrappedObject = " (*theWrappedObject)";
               // write member functions
               for (int i = 0; i < functions.size(); ++i) {
                 AbstractMetaFunction *fun = functions.at(i);
-                if (fun->isSlot()) continue;
+                bool needsWrapping = (!fun->isSlot() || fun->isVirtual());
+                if (!needsWrapping) {
+                  continue;
+                }
                 writeFunctionSignature(s, fun, meta_class, QString(),
                   Option(ConvertReferenceToPtr | FirstArgIsWrappedObject | OriginalName | ShowStatic | UnderscoreSpaces),
                   "PythonQtWrapper_");
                 s << endl << "{" << endl;
                 s << "  ";
                 if (ShellGenerator::isSpecialStreamingOperator(fun)) {
                   s << fun->arguments().at(0)->argumentName();
                   if (fun->originalName().startsWith("operator>>")) {
                     s << " >> ";
                   } else {
                     s << " << ";
                   }
                   s << wrappedObject;
                 } else {
                   QString scriptFunctionName = fun->originalName();
                   AbstractMetaArgumentList args = fun->arguments();
                   // call the C++ implementation
                   if (fun->type()) {
                     s << "return ";
                     // call the C++ implementation
                     if (fun->type()->isReference()) {
                       s << "&";
                     }
                   }
                   s << "(";
                   if (scriptFunctionName.startsWith("operator>>")) {
                     s << wrappedObject << " >>" << args.at(0)->argumentName();
                   } else if (scriptFunctionName.startsWith("operator<<")) {
                     s << wrappedObject << " <<" << args.at(0)->argumentName();
                   } else if (scriptFunctionName.startsWith("operator[]")) {
                     s << wrappedObject << "[" << args.at(0)->argumentName() << "]";
                   } else if (scriptFunctionName.startsWith("operator") && args.size()==1) {
                     QString op = scriptFunctionName.mid(8);
                     s << wrappedObject << op << " " << args.at(0)->argumentName();
                   } else {
                     if (fun->isStatic()) {
                       s << meta_class->qualifiedCppName() << "::";
                     } else {
                       if (!fun->isPublic() || fun->isVirtual()) {
                         s << " (("  << promoterClassName(meta_class) << "*)theWrappedObject)->promoted_";
                       } else {
                         s << " theWrappedObject->";
                       }
                     }
                     s  << fun->originalName() << "(";
                     for (int i = 0; i < args.size(); ++i) {
                       if (i > 0)
                         s << ", ";
                       s << args.at(i)->argumentName();
                     }
                     s << ")";
                   }
                   s << ")";
                 }
                 s << ";" << endl;
                 s << "}" << endl << endl;
               }
               if (meta_class->hasDefaultToStringFunction()) {
                 s << "QString PythonQtWrapper_" << meta_class->name() << "::py_toString(" << meta_class->qualifiedCppName() << "* obj) { return obj->toString(); }" << endl;
               } else if (meta_class->hasToStringCapability()) {
                 FunctionModelItem fun = meta_class->hasToStringCapability();
                 int indirections = fun->arguments().at(1)->type().indirections();
                 QString deref = QLatin1String(indirections == 0 ? "*" : "");
                 s << "QString PythonQtWrapper_" << meta_class->name() << "::py_toString(" << meta_class->qualifiedCppName() << "* obj) {" << endl;
                 s << "  QString result;" << endl;
                 s << "  QDebug d(&result);" << endl;
                 s << "  d << " << deref  << "obj;" << endl;
                 s << "  return result;" << endl;
                 s << "}" << endl << endl;
               }
               writeInjectedCode(s, meta_class);
             }
             void ShellImplGenerator::writeInjectedCode(QTextStream &s, const AbstractMetaClass *meta_class)
             {
               CodeSnipList code_snips = meta_class->typeEntry()->codeSnips();
               foreach (const CodeSnip &cs, code_snips) {
                 if (cs.language == TypeSystem::PyWrapperCode) {
                   s << cs.code() << endl;
                 }
               }
             }

generator/typesystem_core.xml +1 -2

             <?xml version="1.0"?>
             <typesystem package="com.trolltech.qt.core"><template name="core.prepare_removed_bool*_argument">
                       bool __ok;
                       bool *%out% = &amp;__ok;
                 </template><template name="core.convert_to_null_or_wrap">
                       QScriptValue %out%;
                       if (!__ok)
                           %out% = context-&gt;engine()-&gt;nullValue();
                       else
                           %out% = qScriptValueFromValue(context-&gt;engine(), %in%);
                 </template><template name="core.convert_to_null_or_primitive">
                       QScriptValue %out%;
                       if (!__ok)
                           %out% = context-&gt;engine()-&gt;nullValue();
                       else
                           %out% = QScriptValue(context-&gt;engine(), %in%);
                 </template><template name="core.convert_string_arg_to_char*">
                       QByteArray tmp_%out% = %in%.toString().toLatin1();
                       const char * %out% = tmp_%out%.constData();
                 </template><template name="core.convert_int_arg_and_check_range">
                       int %out% = %in%.toInt32();
                       if ((%out% &lt; 0) || (%this%-&gt;size() &lt; %out%)) {
                           return context-&gt;throwError(QScriptContext::RangeError,
                                                      QString::fromLatin1("%CLASS_NAME%::%FUNCTION_NAME%(): index out of range"));
                       }
                 </template><template name="core.convert_pointer_arg_and_check_null">
                       %TYPE% %out% = qscriptvalue_cast&lt;%TYPE%&gt;(%in%);
                       if (!%out%) {
                           return context-&gt;throwError(QScriptContext::TypeError,
                                                      QString::fromLatin1("%CLASS_NAME%::%FUNCTION_NAME%(): failed to convert argument to %TYPE%"));
                       }
                 </template><template name="core.convert_stringref_to_string">
                         QString %out% = %in%.toString();
                 </template><rejection class="QTextCodec::ConverterState"/><rejection class="QTextCodecFactoryInterface"/><rejection class="QAbstractEventDispatcher"/><rejection class="QAbstractFileEngine"/><rejection class="QAbstractFileEngineHandler"/><rejection class="QAbstractFileEngineIterator"/><rejection class="QFSFileEngine"/><rejection class="QSystemLocale"/><rejection class="QFutureWatcherBase"/><rejection class="QFutureSynchronizer"/><enum-type name="QXmlStreamReader::Error"/><enum-type name="QXmlStreamReader::TokenType"/>
               <primitive-type name="qgl_GLsizeiptr"/>
               <primitive-type name="qgl_GLintptr"/>
               <primitive-type name="GLint"/>
               <primitive-type name="GLuint"/>
               <primitive-type name="GLenum"/>
               <primitive-type name="GLclampf"/>
               <primitive-type name="GLsizei"/>
               <primitive-type name="GLfloat"/>
               <primitive-type name="GLbitfield"/>
               <primitive-type name="GLbyte"/>
               <primitive-type name="GLshort"/>
               <primitive-type name="GLubyte"/>
               <primitive-type name="GLushort"/>
               <primitive-type name="GLdouble"/>
               <primitive-type name="GLclampd"/>
               <primitive-type name="GLvoid"/>
               <primitive-type name="GLboolean"/>
               <primitive-type name="bool"/><primitive-type name="double"/><primitive-type name="qreal"/><primitive-type name="float"/><primitive-type name="qint64"/><primitive-type name="__int64"/><primitive-type name="unsigned __int64"/><primitive-type name="unsigned long long"/><primitive-type name="long long"/><primitive-type name="qlonglong"/><primitive-type name="qulonglong"/><primitive-type name="short"/><primitive-type name="short"/><primitive-type name="signed short"/><primitive-type name="ushort"/><primitive-type name="unsigned short"/><primitive-type name="char"/><primitive-type name="signed char"/><primitive-type name="uchar"/><primitive-type name="unsigned char"/><primitive-type name="int"/><primitive-type name="signed int"/><primitive-type name="uint"/><primitive-type name="ulong"/><primitive-type name="unsigned int"/><primitive-type name="signed long"/><primitive-type name="long"/><primitive-type name="unsigned long"/><primitive-type name="WId"/><primitive-type name="Qt::HANDLE"/><primitive-type name="QVariant::Type"/><primitive-type name="QByteRef"/><primitive-type name="QBitRef"/><primitive-type name="QBool"/><primitive-type name="jobject"/><primitive-type name="quintptr"/><suppress-warning text="WARNING(MetaJavaBuilder) :: signal 'finished' in class 'QProcess' is overloaded."/><suppress-warning text="WARNING(MetaJavaBuilder) :: missing required class for enums: QRegExp"/><suppress-warning text="WARNING(MetaJavaBuilder) :: enum 'QtValidLicenseForScriptToolsModule' does not have a type entry or is not an enum"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Rejected enum has no alternative...: QDataStream::Qt_4_5"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unhandled enum value: Qt::MatchFlags(Qt::MatchStartsWith in Qt::MatchFlag"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unhandled enum value: Qt::MatchWrap) in Qt::MatchFlag"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unmatched enum Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap) when parsing default value of 'match' in class 'QAbstractItemModel'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unsupported default value 'QLatin1String(defaultConnection)' of argument in function '*', class '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Class '*' has equals operators but no qHash() function"/><suppress-warning text="WARNING(MetaJavaBuilder) :: type '*' is specified in typesystem, but not defined. This could potentially lead to compilation errors."/><suppress-warning text="WARNING(MetaJavaBuilder) :: namespace '*' for enum '*' is not declared"/><suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function '*', unmatched parameter type '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function '*', unmatched return type '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: signature '*' for function modification in '*' not found. Possible candidates: "/><suppress-warning text="WARNING(MetaJavaBuilder) :: namespace '*' does not have a type entry"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unsupported default value '*' of argument in function '*', class '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Shadowing: * and *; Java code will not compile"/><suppress-warning text="WARNING(MetaJavaBuilder) :: enum '*' is specified in typesystem, but not declared"/>
               <value-type name="QModelIndex"/>
               <rejection class="*" function-name="d_func"/>
               <rejection class="*" function-name="data_ptr"/>
               <rejection class="*" function-name="detach"/>
               <rejection class="*" function-name="isDetached"/>
               <rejection class="*" field-name="d_ptr"/>
               <rejection class="*" field-name="d"/>
               <rejection class="" enum-name="QtValidLicenseForTestModule"/>
               <rejection class="" enum-name="QtValidLicenseForDBusModule"/>
               <rejection class="" enum-name="QtValidLicenseForSqlModule"/>
               <rejection class="" enum-name="QtValidLicenseForOpenGLModule"/>
               <rejection class="" enum-name="enum_1"/>
               <rejection class="" enum-name="QtValidLicenseForXmlModule"/>
               <rejection class="" enum-name="QtValidLicenseForXmlPatternsModule"/>
               <rejection class="" enum-name="QtValidLicenseForActiveQtModule"/>
               <rejection class="" enum-name="QtValidLicenseForCoreModule"/>
               <rejection class="" enum-name="QtValidLicenseForQt3SupportLightModule"/>
               <rejection class="" enum-name="QtValidLicenseForQt3SupportModule"/>
               <rejection class="" enum-name="QtValidLicenseForNetworkModule"/>
               <rejection class="" enum-name="QtValidLicenseForSvgModule"/>
               <rejection class="" enum-name="QtValidLicenseForGuiModule"/>
               <rejection class="" enum-name="QtValidLicenseForScriptModule"/>
               <rejection class="" enum-name="QtValidLicenseForHelpModule"/>
               <rejection class="" enum-name="QtValidLicenseForScriptToolsModule"/>
               <rejection class="" enum-name="QtValidLicenseForMultimediaModule"/>
               <rejection class="" enum-name="QtValidLicenseForOpenVGModule"/>
               <rejection class="" enum-name="QtValidLicenseForDeclarativeModule"/>
               <rejection class="QtConcurrent" enum-name="enum_1"/>
               <rejection class="QtConcurrent" function-name="operator|"/>
               <rejection class="Qt" enum-name="Modifier"/>
               <rejection class="QSharedPointer"/>
               <rejection class="QWeakPointer"/>
               <rejection class="QFuture::const_iterator"/>
               <rejection class="QFutureInterface"/>
               <rejection class="QFutureInterfaceBase"/>
               <rejection class="QtConcurrent::BlockSizeManager"/>
               <rejection class="QtConcurrent::ConstMemberFunctionWrapper"/>
               <rejection class="QtConcurrent::Exception"/>
               <rejection class="QtConcurrent::FilterKernel"/>
               <rejection class="QtConcurrent::FilteredEachKernel"/>
               <rejection class="QtConcurrent::FilteredReducedKernel"/>
               <rejection class="QtConcurrent::FunctionWrapper0"/>
               <rejection class="QtConcurrent::FunctionWrapper1"/>
               <rejection class="QtConcurrent::FunctionWrapper2"/>
               <rejection class="QtConcurrent::IntermediateResults"/>
               <rejection class="QtConcurrent::IterateKernel"/>
               <rejection class="QtConcurrent::MapKernel"/>
               <rejection class="QtConcurrent::MappedEachKernel"/>
               <rejection class="QtConcurrent::MappedReducedKernel"/>
               <rejection class="QtConcurrent::Median"/>
               <rejection class="QtConcurrent::MemberFunctionWrapper"/>
               <rejection class="QtConcurrent::MemberFunctionWrapper1"/>
               <rejection class="QtConcurrent::qValueType"/>
               <rejection class="QtConcurrent::ReduceKernel"/>
               <rejection class="QtConcurrent::ResultItem"/>
               <rejection class="QtConcurrent::ResultIterator"/>
               <rejection class="QtConcurrent::ResultIteratorBase"/>
               <rejection class="QtConcurrent::ResultReporter"/>
               <rejection class="QtConcurrent::ResultStore"/>
               <rejection class="QtConcurrent::ResultStoreBase"/>
               <rejection class="QtConcurrent::RunFunctionTask"/>
               <rejection class="QtConcurrent::RunFunctionTaskBase"/>
               <rejection class="QtConcurrent::SelectSpecialization"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall0"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall1"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall2"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall3"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall4"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall5"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall5"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall0"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall1"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall2"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall3"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall4"/>
               <rejection class="QtConcurrent::SelectStoredFunctorCall5"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall0"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall1"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall2"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall3"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall4"/>
               <rejection class="QtConcurrent::SelectStoredFunctorPointerCall5"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall0"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall1"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall2"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall3"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall4"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionCall5"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall5"/>
               <rejection class="QtConcurrent::SequenceHolder1"/>
               <rejection class="QtConcurrent::SequenceHolder2"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall0"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall1"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall2"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall3"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall4"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionCall5"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall5"/>
               <rejection class="QtConcurrent::StoredFunctorCall0"/>
               <rejection class="QtConcurrent::StoredFunctorCall1"/>
               <rejection class="QtConcurrent::StoredFunctorCall2"/>
               <rejection class="QtConcurrent::StoredFunctorCall3"/>
               <rejection class="QtConcurrent::StoredFunctorCall4"/>
               <rejection class="QtConcurrent::StoredFunctorCall5"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall0"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall1"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall2"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall3"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall4"/>
               <rejection class="QtConcurrent::StoredFunctorPointerCall5"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall0"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall1"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall2"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall3"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall4"/>
               <rejection class="QtConcurrent::StoredMemberFunctionCall5"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::StoredMemberFunctionPointerCall5"/>
               <rejection class="QtConcurrent::ThreadEngine"/>
               <rejection class="QtConcurrent::ThreadEngineBase"/>
               <rejection class="QtConcurrent::ThreadEngineSemaphore"/>
               <rejection class="QtConcurrent::ThreadEngineStarter"/>
               <rejection class="QtConcurrent::ThreadEngineStarterBase"/>
               <rejection class="QtConcurrent::UnhandledException"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall0"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall1"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall2"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall3"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall4"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall5"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall5"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall0"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall1"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall2"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall3"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall4"/>
               <rejection class="QtConcurrent::VoidStoredFunctorCall5"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall0"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall1"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall2"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall3"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall4"/>
               <rejection class="QtConcurrent::VoidStoredFunctorPointerCall5"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall0"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall1"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall2"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall3"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall4"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionCall5"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall0"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall1"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall2"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall3"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall4"/>
               <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall5"/>
               <rejection class="QMdi"/>
               <rejection class="stdext"/>
               <rejection class="QAlgorithmsPrivate"/>
               <rejection class="QAtomic"/>
               <rejection class="QAtomicPointer"/>
               <rejection class="QAtomicInt"/>
               <rejection class="QBasicAtomicInt"/>
               <rejection class="QBasicAtomic"/>
               <rejection class="QBasicAtomicPointer"/>
               <rejection class="QScopedPointer"/>
               <rejection class="QScopedArrayPointer"/>
               <rejection class="QScopedPointer"/>
               <rejection class="QScopedPointerArrayDeleter"/>
               <rejection class="QScopedPointerDeleter"/>
               <rejection class="QScopedPointerPodDeleter"/>
               <rejection class="QScopedPointerSharedDeleter"/>
               <rejection class="QScopedSharedPointer"/>
               <rejection class="QCustomScopedPointer"/>
               <rejection class="QStringBuilder"/>
               <rejection class="QBitRef"/>
               <rejection class="QCache"/>
               <rejection class="QContiguousCache"/>
               <rejection class="QContiguousCacheData"/>
               <rejection class="QContiguousCacheTypedData"/>
               <rejection class="QCharRef"/>
               <rejection class="QDebug"/>
               <rejection class="QNoDebug"/>
               <rejection class="QExplicitlySharedDataPointer"/>
               <rejection class="QFlag"/>
               <rejection class="QFlags"/>
               <rejection class="QForeachContainer"/>
               <rejection class="QForeachContainerBase"/>
               <rejection class="QGlobalStatic"/>
               <rejection class="QHash"/>
               <rejection class="QHashData"/>
               <rejection class="QHashDummyNode"/>
               <rejection class="QHashDummyNode"/>
               <rejection class="QHashDummyNode"/>
               <rejection class="QHashDummyNode"/>
               <rejection class="QHashDummyNode"/>
               <rejection class="QHashDummyValue"/>
               <rejection class="QHashIterator"/>
               <rejection class="QHashNode"/>
               <rejection class="QHashNode"/>
               <rejection class="QHashNode"/>
               <rejection class="QHashNode"/>
               <rejection class="QHashNode"/>
               <rejection class="QInternal"/>
               <rejection class="QIncompatibleFlag"/>
               <rejection class="QLinkedList"/>
               <rejection class="QLinkedListData"/>
               <rejection class="QLinkedListIterator"/>
               <rejection class="QLinkedListNode"/>
               <rejection class="QListData"/>
               <rejection class="QListIterator"/>
               <rejection class="QMap"/>
               <rejection class="QMapNode"/>
               <rejection class="QMapPayloadNode"/>
               <rejection class="QMapData"/>
               <rejection class="QMapIterator"/>
               <rejection class="QMetaTypeId"/>
               <rejection class="QMultiHash"/>
               <rejection class="QMultiMap"/>
               <rejection class="QMutableHashIterator"/>
               <rejection class="QMutableLinkedListIterator"/>
               <rejection class="QMutableListIterator"/>
               <rejection class="QMutableMapIterator"/>
               <rejection class="QMutableVectorIterator"/>
               <rejection class="QMutexLocker"/>
               <rejection class="QNoImplicitBoolCast"/>
               <rejection class="QObjectCleanupHandler"/>
               <rejection class="QObjectData"/>
               <rejection class="QObjectUserData"/>
               <rejection class="QPluginLoader"/>
               <rejection class="QPointer"/>
               <rejection class="QReadLocker"/>
               <rejection class="QSet"/>
               <rejection class="QSetIterator"/>
               <rejection class="QSharedData"/>
               <rejection class="QSharedDataPointer"/>
               <rejection class="QStack"/>
               <rejection class="QTextStreamManipulator"/>
               <rejection class="QThreadStorage"/>
               <rejection class="QThreadStorageData"/>
               <rejection class="QTypeInfo"/>
               <rejection class="QTypeInfo"/>
               <rejection class="QVFbKeyData"/>
               <rejection class="QVariantComparisonHelper"/>
               <rejection class="QVectorData"/>
               <rejection class="QVectorIterator"/>
               <rejection class="QVectorTypedData"/>
               <rejection class="QWriteLocker"/>
               <rejection class="QtPrivate"/>
               <rejection class="qGreater"/>
               <rejection class="qLess"/>
               <rejection class="std"/>
               <rejection class="QAbstractFileEngine::ExtensionOption"/>
               <rejection class="QAbstractFileEngine::ExtensionReturn"/>
               <rejection class="QByteArray::Data"/>
               <rejection class="QIntForType"/>
               <rejection class="QList::Node"/>
               <rejection class="QList::const_iterator"/>
               <rejection class="QList::iterator"/>
               <rejection class="QMetaTypeId2"/>
               <rejection class="QMutableSetIterator"/>
               <rejection class="QSubString"/>
               <rejection class="QUintForType"/>
               <rejection class="QtConcurrent::internal"/>
               <rejection class="QByteArrayMatcher::Data"/>
               <rejection class="QStringMatcher::Data"/>
               <rejection class="StringBuilder"/>
               <rejection class="QConcatenable"/>
               <rejection class="QLatin1Literal"/>
               <rejection class="QIntegerForSizeof"/>
               <rejection class="QLocale::Data"/>
               <rejection class="QGlobalStaticDeleter"/>
               <rejection class="QVarLengthArray"/>
               <!-- DBus -->
               <rejection class="QDBusAbstractAdaptor"/>
               <rejection class="QDBusAbstractInterface"/>
               <rejection class="QDBusArgument"/>
               <rejection class="QDBusConnection"/>
               <rejection class="QDBusConnectionInterface"/>
               <rejection class="QDBusContext"/>
               <rejection class="QDBusError"/>
               <rejection class="QDBusInterface"/>
               <rejection class="QDBusMessage"/>
               <rejection class="QDBusMetaType"/>
               <rejection class="QDBusObjectPath"/>
               <rejection class="QDBusReply"/>
               <rejection class="QDBusServer"/>
               <rejection class="QDBusSignature"/>
               <rejection class="QDBusVariant"/>
               <rejection class="_Revbidit"/>
               <rejection class="_complex"/>
               <rejection class="_exception"/>
               <rejection class="_iobuf"/>
               <rejection class="_stat"/>
               <rejection class="_wfinddata_t"/>
               <rejection class="exception"/>
               <rejection class="istreambuf_iterator"/>
               <rejection class="ostreambuf_iterator"/>
               <rejection class="reverse_bidirectional_iterator"/>
               <rejection class="reverse_iterator"/>
               <rejection class="stat"/>
               <rejection class="tm"/>
               <rejection class="Qt" enum-name="Initialization"/>
               <rejection class="QAbstractEventDispatcher" function-name="filterEvent"/>
               <rejection class="QAbstractEventDispatcher" function-name="setEventFilter"/>
               <rejection class="QAbstractFileEngine" function-name="extension"/>
               <rejection class="QCoreApplication" function-name="compressEvent"/>
               <rejection class="QCoreApplication" function-name="eventFilter"/>
               <rejection class="QCoreApplication" function-name="filterEvent"/>
               <rejection class="QCoreApplication" function-name="setEventFilter"/>
               <rejection class="QFile" function-name="setDecodingFunction"/>
               <rejection class="QFile" function-name="setEncodingFunction"/>
               <rejection class="QList" function-name="begin"/>
               <rejection class="QList" function-name="constBegin"/>
               <rejection class="QList" function-name="constEnd"/>
               <rejection class="QList" function-name="end"/>
               <rejection class="QList" function-name="erase"/>
               <rejection class="QList" function-name="erase"/>
               <rejection class="QList" function-name="free"/>
               <rejection class="QList" function-name="fromList"/>
               <rejection class="QList" function-name="fromSet"/>
               <rejection class="QList" function-name="fromSet"/>
               <rejection class="QList" function-name="insert"/>
               <rejection class="QList" function-name="malloc"/>
               <rejection class="QList" function-name="node_construct"/>
               <rejection class="QList" function-name="node_copy"/>
               <rejection class="QList" function-name="node_destruct"/>
               <rejection class="QList" function-name="toSet"/>
               <rejection class="QObject" function-name="receivers"/>
               <rejection class="QObject" function-name="findChild"/>
               <rejection class="QObject" function-name="findChildren"/>
               <rejection class="QObject" function-name="setUserData"/>
               <rejection class="QObject" function-name="userData"/>
               <rejection class="QObject" function-name="destroyed"/>
               <rejection class="QObject" function-name="connect"/>
               <rejection class="QObject" function-name="connectNotify"/>
               <rejection class="QObject" function-name="disconnect"/>
               <rejection class="QObject" function-name="disconnectNotify"/>
               <rejection class="QObject" function-name="registerUserData"/>
               <rejection class="QProcess" function-name="pid"/>
               <rejection class="QRegion" function-name="cleanUp"/>
               <rejection class="QSettings" function-name="registerFormat"/>
               <rejection class="QVector" function-name="back"/>
               <rejection class="QVector" function-name="begin"/>
               <rejection class="QVector" function-name="constBegin"/>
               <rejection class="QVector" function-name="constEnd"/>
               <rejection class="QVector" function-name="end"/>
               <rejection class="QVector" function-name="erase"/>
               <rejection class="QVector" function-name="free"/>
               <rejection class="QVector" function-name="front"/>
               <rejection class="QVector" function-name="insert"/>
               <rejection class="QVector" function-name="malloc"/>
               <rejection class="QVector" function-name="alloc"/>
               <rejection class="QVector" function-name="operator+="/>
               <rejection class="QAbstractFileEngineIterator" function-name="entryInfo"/>
               <rejection class="QtConcurrent::ThreadEngineBarrier"/>
               <rejection class="QAbstractFileEngineIterator" enum-name="EntryInfoType"/>
               <rejection class="QDataStream" enum-name="ByteOrder"/>
               <namespace-type name="Qt">
                 <extra-includes>
                     <include file-name="QTextDocument" location="global"/>
                 </extra-includes>
               </namespace-type>
               <enum-type name="QDate::MonthNameType"/>
               <enum-type name="QAbstractAnimation::DeletionPolicy"/>
               <enum-type name="QAbstractAnimation::Direction"/>
               <enum-type name="QAbstractAnimation::State"/>
               <enum-type name="QDataStream::FloatingPointPrecision"/>
               <enum-type name="QEasingCurve::Type"/>
               <enum-type name="QHistoryState::HistoryType"/>
               <enum-type name="QState::ChildMode"/>
               <enum-type name="QStateMachine::Error"/>
               <enum-type name="QStateMachine::EventPriority"/>
               <enum-type name="QStateMachine::RestorePolicy"/>
               <enum-type name="Qt::AnchorPoint"/>
               <enum-type name="Qt::CoordinateSystem"/>
               <enum-type name="Qt::GestureState"/>
               <enum-type name="Qt::InputMethodHint" flags="Qt::InputMethodHints"/>
               <enum-type name="Qt::NavigationMode"/>
               <enum-type name="Qt::RenderHint"/>
               <enum-type name="Qt::TileRule"/>
               <enum-type name="Qt::TouchPointState" flags="Qt::TouchPointStates"/>
               <enum-type name="QSysInfo::Endian"/>
               <enum-type name="QSysInfo::Sizes"/>
               <enum-type name="QMetaMethod::Access"/>
               <enum-type name="QMetaMethod::Attributes"/>
               <enum-type name="QMetaMethod::MethodType"/>
               <enum-type name="QSharedMemory::AccessMode"/>
               <enum-type name="QSharedMemory::SharedMemoryError"/>
               <enum-type name="QElapsedTimer::ClockType"/>
-              <enum-type name="QMetaType::Type"/>
               <enum-type name="QtMsgType">
                 <reject-enum-value name="QtSystemMsg"/>
               </enum-type>
               <enum-type name="QReadWriteLock::RecursionMode"/>
               <enum-type name="QSystemSemaphore::AccessMode"/>
               <enum-type name="QSystemSemaphore::SystemSemaphoreError"/>
               <enum-type name="QTextBoundaryFinder::BoundaryReason" flags="QTextBoundaryFinder::BoundaryReasons"/>
               <enum-type name="QTextBoundaryFinder::BoundaryType"/>
               <enum-type name="QAbstractFileEngine::Extension" extensible="yes"/>
               <enum-type name="QAbstractFileEngine::FileFlag" flags="QAbstractFileEngine::FileFlags"/>
               <enum-type name="QAbstractFileEngine::FileName"/>
               <enum-type name="QAbstractFileEngine::FileOwner"/>
               <enum-type name="QAbstractFileEngine::FileTime"/>
               <enum-type name="QDataStream::Status"/>
               <enum-type name="QDir::Filter" flags="QDir::Filters"/>
               <enum-type name="QEvent::Type" extensible="yes">
                 <reject-enum-value name="ApplicationActivated"/>
                 <reject-enum-value name="ApplicationDeactivated"/>
               </enum-type>
               <enum-type name="QEventLoop::ProcessEventsFlag" flags="QEventLoop::ProcessEventsFlags"/>
               <enum-type name="QFile::FileError"/>
               <enum-type name="QFile::MemoryMapFlags"/>
               <enum-type name="QFile::Permission" flags="QFile::Permissions"/>
               <enum-type name="QFile::FileHandleFlag" flags="QFile::FileHandleFlags"/>
               <enum-type name="QIODevice::OpenModeFlag" flags="QIODevice::OpenMode"/>
               <enum-type name="QLibraryInfo::LibraryLocation"/>
               <enum-type name="QLibrary::LoadHint" flags="QLibrary::LoadHints"/>
               <enum-type name="QLocale::FormatType"/>
               <enum-type name="QLocale::NumberOption" flags="QLocale::NumberOptions"/>
               <enum-type name="QLocale::MeasurementSystem"/>
               <enum-type name="QLocale::QuotationStyle"/>
               <enum-type name="QLocale::Script"/>
               <enum-type name="QLocale::CurrencySymbolFormat"/>
               <enum-type name="QMutex::RecursionMode"/>
               <enum-type name="QProcess::ExitStatus"/>
               <enum-type name="QProcess::ProcessChannel"/>
               <enum-type name="QProcess::ProcessChannelMode"/>
               <enum-type name="QProcess::ProcessError"/>
               <enum-type name="QProcess::ProcessState"/>
               <enum-type name="QRegExp::CaretMode"/>
               <enum-type name="QRegExp::PatternSyntax"/>
               <enum-type name="QSettings::Format"/>
               <enum-type name="QSettings::Scope"/>
               <enum-type name="QSettings::Status"/>
               <enum-type name="QSocketNotifier::Type"/>
               <enum-type name="QSystemLocale::QueryType"/>
               <enum-type name="QTextCodec::ConversionFlag" flags="QTextCodec::ConversionFlags"/>
               <enum-type name="QTextStream::FieldAlignment"/>
               <enum-type name="QTextStream::NumberFlag" flags="QTextStream::NumberFlags"/>
               <enum-type name="QTextStream::RealNumberNotation"/>
               <enum-type name="QTextStream::Status"/>
               <enum-type name="QTimeLine::CurveShape"/>
               <enum-type name="QTimeLine::Direction"/>
               <enum-type name="QTimeLine::State"/>
               <enum-type name="QUrl::FormattingOption" flags="QUrl::FormattingOptions"/>
               <enum-type name="QUrl::ParsingMode"/>
               <enum-type name="QUuid::Variant"/>
               <enum-type name="QUuid::Version"/>
               <enum-type name="Qt::SizeHint"/>
               <enum-type name="Qt::SizeMode"/>
               <enum-type name="Qt::WindowFrameSection"/>
               <enum-type name="Qt::Axis"/>
               <enum-type name="Qt::AnchorAttribute"/>
               <enum-type name="Qt::ApplicationAttribute"/>
               <enum-type name="Qt::ArrowType"/>
               <enum-type name="Qt::AspectRatioMode"/>
               <enum-type name="Qt::BGMode"/>
               <enum-type name="Qt::BrushStyle"/>
               <enum-type name="Qt::CaseSensitivity"/>
               <enum-type name="Qt::CheckState"/>
               <enum-type name="Qt::ClipOperation"/>
               <enum-type name="Qt::ConnectionType"/>
               <enum-type name="Qt::ContextMenuPolicy"/>
               <enum-type name="Qt::Corner"/>
               <enum-type name="Qt::DayOfWeek"/>
               <enum-type name="Qt::DockWidgetAreaSizes"/>
               <enum-type name="Qt::DropAction" flags="Qt::DropActions"/>
               <enum-type name="Qt::FillRule"/>
               <enum-type name="Qt::FocusPolicy"/>
               <enum-type name="Qt::FocusReason"/>
               <enum-type name="Qt::GlobalColor"/>
               <enum-type name="Qt::GestureType"/>
               <enum-type name="Qt::GestureFlag" flags="Qt::GestureFlags"/>
               <enum-type name="Qt::CursorMoveStyle"/>
               <enum-type name="Qt::HitTestAccuracy"/>
               <enum-type name="Qt::InputMethodQuery"/>
               <enum-type name="Qt::ItemFlag" flags="Qt::ItemFlags"/>
               <enum-type name="Qt::ItemSelectionMode"/>
               <enum-type name="Qt::KeyboardModifier" flags="Qt::KeyboardModifiers"/>
               <enum-type name="Qt::LayoutDirection"/>
               <enum-type name="Qt::MatchFlag" flags="Qt::MatchFlags"/>
               <enum-type name="Qt::MouseButton" flags="Qt::MouseButtons"/>
               <enum-type name="Qt::Orientation" flags="Qt::Orientations"/>
               <enum-type name="Qt::PenCapStyle"/>
               <enum-type name="Qt::PenJoinStyle"/>
               <enum-type name="Qt::PenStyle"/>
               <enum-type name="Qt::ScrollBarPolicy"/>
               <enum-type name="Qt::ShortcutContext"/>
               <enum-type name="Qt::SortOrder"/>
               <enum-type name="Qt::TextElideMode"/>
               <enum-type name="Qt::TextFlag"/>
               <enum-type name="Qt::TextFormat"/>
               <enum-type name="Qt::TextInteractionFlag" flags="Qt::TextInteractionFlags"/>
               <enum-type name="Qt::TimeSpec"/>
               <enum-type name="Qt::ToolBarAreaSizes"/>
               <enum-type name="Qt::ToolButtonStyle"/>
               <enum-type name="Qt::TransformationMode"/>
               <enum-type name="Qt::UIEffect"/>
               <enum-type name="Qt::WhiteSpaceMode"/>
               <enum-type name="Qt::WindowModality"/>
               <enum-type name="Qt::WindowState" flags="Qt::WindowStates"/>
               <enum-type name="Qt::WindowType" flags="Qt::WindowFlags"/>
               <enum-type name="QDirIterator::IteratorFlag" flags="QDirIterator::IteratorFlags"/>
               <enum-type name="Qt::EventPriority"/>
               <enum-type name="Qt::MaskMode"/>
               <enum-type name="QCryptographicHash::Algorithm"/>
               <enum-type name="QtConcurrent::ReduceOption" flags="QtConcurrent::ReduceOptions"/>
               <enum-type name="QtConcurrent::ThreadFunctionResult"/>
               <enum-type name="QCoreApplication::Encoding">
                 <reject-enum-value name="DefaultCodec"/>
               </enum-type>
               <enum-type name="Qt::AlignmentFlag" flags="Qt::Alignment">
                 <reject-enum-value name="AlignLeading"/>
                 <reject-enum-value name="AlignTrailing"/>
               </enum-type>
               <enum-type name="Qt::CursorShape">
                 <reject-enum-value name="LastCursor"/>
               </enum-type>
               <enum-type name="Qt::DateFormat">
                 <reject-enum-value name="LocalDate"/>
               </enum-type>
               <enum-type name="Qt::ItemDataRole" force-integer="yes">
                 <reject-enum-value name="BackgroundColorRole"/>
                 <reject-enum-value name="TextColorRole"/>
               </enum-type>
               <enum-type name="QDataStream::Version">
                 <reject-enum-value name="Qt_4_1"/>
               </enum-type>
               <enum-type name="QDir::SortFlag" flags="QDir::SortFlags">
                 <reject-enum-value name="Unsorted"/>
               </enum-type>
               <enum-type name="Qt::DockWidgetArea" flags="Qt::DockWidgetAreas">
                 <reject-enum-value name="AllDockWidgetAreas"/>
               </enum-type>
               <enum-type name="Qt::ImageConversionFlag" flags="Qt::ImageConversionFlags">
                 <reject-enum-value name="AutoDither"/>
                 <reject-enum-value name="ColorOnly"/>
                 <reject-enum-value name="DiffuseDither"/>
                 <reject-enum-value name="NoAlpha"/>
                 <reject-enum-value name="ThresholdAlphaDither"/>
               </enum-type>
               <enum-type name="Qt::Key">
                 <reject-enum-value name="Key_Any"/>
               </enum-type>
               <enum-type name="QLocale::Language">
                 <reject-enum-value name="LastLanguage"/>
                 <reject-enum-value name="NorwegianBokmal"/>
                 <reject-enum-value name="Nynorsk"/>
               </enum-type>
               <enum-type name="QLocale::Country">
                 <reject-enum-value name="LastCountry"/>
               </enum-type>
               <enum-type name="Qt::ToolBarArea" flags="Qt::ToolBarAreas">
                 <reject-enum-value name="AllToolBarAreas"/>
               </enum-type>
               <enum-type name="Qt::WidgetAttribute">
                 <reject-enum-value name="WA_ForceAcceptDrops"/>
                 <reject-enum-value name="WA_NoBackground"/>
                 <reject-enum-value name="WA_MacMetalStyle"/>
               </enum-type>
               <value-type name="QProcessEnvironment"/>
               <value-type name="QBasicTimer"/>
               <value-type name="QByteArrayMatcher">
                 <modify-function signature="operator=(QByteArrayMatcher)" remove="all"/>
               </value-type>
               <value-type name="QDate">
                 <modify-function signature="julianToGregorian(uint,int&amp;,int&amp;,int&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="setYMD(int, int, int)" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </value-type>
               <value-type name="QDateTime">
                 <modify-function signature="operator=(QDateTime)" remove="all"/>
               </value-type>
               <value-type name="QDir">
                 <modify-function signature="QDir(QString,QString,QFlags&lt;QDir::SortFlag&gt;,QFlags&lt;QDir::Filter&gt;)">
                   <modify-argument index="3">
                     <replace-default-expression with="SortFlag.Name, SortFlag.IgnoreCase"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="operator=(QDir)" remove="all"/>
                 <modify-function signature="operator=(QString)" remove="all"/>
                 <modify-function signature="addResourceSearchPath(QString)" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </value-type>
               <value-type name="QPoint">
                 <modify-function signature="rx()" remove="all"/>
                 <modify-function signature="ry()" remove="all"/>
               </value-type>
               <value-type name="QPointF">
                 <modify-function signature="rx()" remove="all"/>
                 <modify-function signature="ry()" remove="all"/>
               </value-type>
               <enum-type name="QLineF::IntersectType"/>
               <value-type name="QLineF"/>
               <value-type name="QLine"/>
               <value-type name="QRect">
                 <modify-function signature="getCoords(int*,int*,int*,int*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="getRect(int*,int*,int*,int*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="intersect(const QRect&amp;)const" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="unite(const QRect&amp;)const" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </value-type>
               <value-type name="QRectF">
                 <modify-function signature="getCoords(double*,double*,double*,double*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="getRect(double*,double*,double*,double*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="intersect(const QRectF&amp;)const" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="unite(const QRectF&amp;)const" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </value-type>
               <value-type name="QSize">
                 <modify-function signature="operator*=(double)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator/=(double)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator+=(QSize)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator-=(QSize)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="rheight()">
                   <remove/>
                 </modify-function>
                 <modify-function signature="rwidth()">
                   <remove/>
                 </modify-function>
               </value-type>
               <value-type name="QSizeF">
                 <modify-function signature="operator*=(double)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator/=(double)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator+=(QSizeF)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="operator-=(QSizeF)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="rheight()">
                   <remove/>
                 </modify-function>
                 <modify-function signature="rwidth()">
                   <remove/>
                 </modify-function>
               </value-type>
               <value-type name="QStringMatcher">
                 <modify-function signature="operator=(QStringMatcher)" remove="all"/>
                 <modify-function signature="QStringMatcher(const QChar*,int,Qt::CaseSensitivity)" remove="all"/>
                 <modify-function signature="indexIn(const QChar*,int,int)const" remove="all"/>
               </value-type>
               <value-type name="QTime"/>
               <value-type name="QPersistentModelIndex">
                 <modify-function signature="operator=(QPersistentModelIndex)" remove="all"/>
                 <modify-function signature="operator=(QModelIndex)" remove="all"/>
                 <modify-function signature="internalPointer()const" remove="all"/>
               </value-type>
               <value-type name="QUuid">
                 <modify-function signature="QUuid(const char*)">
                   <remove/>
                 </modify-function>
               </value-type>
               <value-type name="QLocale">
                 <modify-function signature="toString(unsigned long long) const" remove="all"/>
                 <modify-function signature="toString(unsigned short) const" remove="all"/>
                 <modify-function signature="toString(unsigned int) const" remove="all"/>
                 <modify-function signature="toUInt(QString,bool*,int)const" remove="all"/>
                 <modify-function signature="toULongLong(QString,bool*,int)const" remove="all"/>
                 <modify-function signature="operator=(QLocale)" remove="all"/>
                 <extra-includes>
                     <include file-name="QDate" location="global"/>
                 </extra-includes>
                 <inject-code class="native" position="beginning">
                 Q_DECLARE_METATYPE(QScriptValue)
                 </inject-code>
                 <modify-function signature="toDouble(QString,bool*)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toFloat(QString,bool*)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toInt(QString,bool*,int)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toLongLong(QString,bool*,int)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       QScriptValue %out%;
                       if (!__ok)
                           %out% = context-&gt;engine()-&gt;nullValue();
                       else
                           %out% = QScriptValue(context-&gt;engine(), double(%in%)).toObject();
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toShort(QString,bool*,int)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toUShort(QString,bool*,int)const">
                     <modify-argument index="2">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
               </value-type>
               <value-type name="QBitArray">
                 <modify-function signature="operator[](int)" remove="all"/>
                 <modify-function signature="operator[](int)const" remove="all"/>
                 <modify-function signature="operator[](uint)const" remove="all"/>
                 <modify-function signature="operator[](uint)" remove="all"/>
                 <modify-function signature="operator&amp;=(QBitArray)" access="private"/>
                 <modify-function signature="operator=(QBitArray)" access="private"/>
                 <modify-function signature="operator^=(QBitArray)" access="private"/>
                 <modify-function signature="operator|=(QBitArray)" access="private"/>
                 <modify-function signature="operator~()const" access="private"/>
                 <modify-function signature="at(int)const">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="at"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="clearBit(int)">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="clearBit"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setBit(int)">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="setBit"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setBit(int,bool)">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="setBit"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="testBit(int)const">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="testBit"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="toggleBit(int)">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QBitArray"/>
                       <replace from="%FUNCTION_NAME%" to="toggleBit"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="operator&amp;=(QBitArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="operator=(QBitArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="operator^=(QBitArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="operator|=(QBitArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
               </value-type>
               <object-type name="QReadWriteLock"/>
               <object-type name="QDirIterator"/>
               <object-type name="QAbstractFileEngineIterator"/>
               <object-type name="QAbstractItemModel">
                 <modify-function signature="rowsAboutToBeInserted(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="rowsInserted(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="rowsAboutToBeRemoved(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="rowsRemoved(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="columnsAboutToBeInserted(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="columnsInserted(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="columnsAboutToBeRemoved(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="columnsRemoved(QModelIndex,int,int)" private-signal="yes"/>
                 <modify-function signature="modelAboutToBeReset()" private-signal="yes"/>
                 <modify-function signature="modelReset()" private-signal="yes"/>
               </object-type>
               <object-type name="QAbstractListModel">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                   <include file-name="QSize" location="global"/>
                 </extra-includes>
               </object-type>
               <value-type name="QUrl">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                 </extra-includes>
                 <modify-function signature="operator=(QUrl)" remove="all"/>
                 <modify-function signature="operator=(QString)" remove="all"/>
                 <modify-function signature="fromPunycode(const QByteArray&amp;)" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="toPunycode(const QString&amp;)" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </value-type>
               <value-type name="QRegExp">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                 </extra-includes>
                 <modify-function signature="operator=(QRegExp)" remove="all"/>
                 <modify-function signature="pos(int)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="cap(int)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="capturedTexts()const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="errorString()const">
                   <remove/>
                 </modify-function>
               </value-type>
               <value-type name="QFileInfo">
                 <extra-includes>
                   <include file-name="QDateTime" location="global"/>
                   <include file-name="QDir" location="global"/>
                 </extra-includes>
                 <modify-function signature="operator!=(const QFileInfo &amp;)const" remove="all"/>
                 <modify-function signature="operator==(const QFileInfo &amp;)const" remove="all"/>
                 <modify-function signature="operator=(QFileInfo)" remove="all"/>
                 <modify-function signature="setFile(QFile)">
                   <modify-argument index="1">
                     <reference-count action="ignore"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="readLink()const" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="QFileInfo(QFile)">
                   <modify-argument index="1">
                     <replace-type modified-type="QFile*"/>
                     <conversion-rule class="native">
                     QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setFile(QFile)">
                   <modify-argument index="1">
                     <replace-type modified-type="QFile*"/>
                     <conversion-rule class="native">
                     QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
               </value-type>
               <interface-type name="QFactoryInterface"/>
               <value-type name="QByteArray">
                 <extra-includes>
                   <include file-name="QNoImplicitBoolCast" location="global"/>
                 </extra-includes>
                 <!-- removed functions -->
                 <modify-function signature="begin()" remove="all"/>
                 <modify-function signature="begin()const" remove="all"/>
                 <modify-function signature="constBegin()const" remove="all"/>
                 <modify-function signature="constData()const" remove="all"/>
                 <modify-function signature="constEnd()const" remove="all"/>
                 <modify-function signature="count()const" remove="all"/>
                 <modify-function signature="data()const" remove="all"/>
                 <modify-function signature="end()" remove="all"/>
                 <modify-function signature="end()const" remove="all"/>
                 <modify-function signature="number(uint,int)" remove="all"/>
                 <modify-function signature="number(unsigned long long,int)" remove="all"/>
                 <modify-function signature="operator const char *()const" remove="all"/>
                 <modify-function signature="operator const void *()const" remove="all"/>
                 <modify-function signature="operator+=(const char*)" remove="all"/>
                 <modify-function signature="operator!=(QString)const" remove="all"/>
                 <modify-function signature="operator=(const char*)" remove="all"/>
                 <modify-function signature="operator[](int)" remove="all"/>
                 <modify-function signature="operator[](int)const" remove="all"/>
                 <modify-function signature="operator[](uint)" remove="all"/>
                 <modify-function signature="operator[](uint)const" remove="all"/>
                 <modify-function signature="push_back(char)" remove="all"/>
                 <modify-function signature="push_back(const char*)" remove="all"/>
                 <modify-function signature="push_front(char)" remove="all"/>
                 <modify-function signature="push_front(const char*)" remove="all"/>
                 <modify-function signature="setNum(uint,int)" remove="all"/>
                 <modify-function signature="setNum(unsigned long long,int)" remove="all"/>
                 <modify-function signature="setNum(unsigned short,int)" remove="all"/>
                 <modify-function signature="toLong(bool*, int) const" remove="all"/>
                 <modify-function signature="toLongLong(bool*, int) const" remove="all"/>
                 <modify-function signature="toShort(bool*, int) const" remove="all"/>
                 <modify-function signature="toUInt(bool*, int) const" remove="all"/>
                 <modify-function signature="toULong(bool*, int) const" remove="all"/>
                 <modify-function signature="toULongLong(bool*, int) const" remove="all"/>
                 <!-- functions made private... -->
                 <modify-function signature="operator=(QByteArray)" access="private"/>
                 <modify-function signature="operator+=(QString)" remove="all"/>
                 <modify-function signature="operator+=(char)" remove="all"/>
                 <inject-code class="pywrap-h">
               PyObject* data(QByteArray* b) {
                 if (b-&gt;data()) {
                   return PyString_FromStringAndSize(b-&gt;data(), b-&gt;size());
                 } else {
                   Py_INCREF(Py_None);
                   return Py_None;
                 }
               }
                 </inject-code>
                 <inject-code class="native" position="beginning">
                 Q_DECLARE_METATYPE(QScriptValue)
                 </inject-code>
                 <modify-function signature="QByteArray(const char*,int)" remove="all"/>
                 <modify-function signature="QByteArray(const char*)" remove="all"/>
                 <modify-function signature="at(int)const">
                   <modify-argument index="1">
                     <conversion-rule class="native">
                     <insert-template name="core.convert_int_arg_and_check_range">
                       <replace from="%CLASS_NAME%" to="QByteArray"/>
                       <replace from="%FUNCTION_NAME%" to="at"/>
                     </insert-template>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="append(const char *)" remove="all"/>
                 <modify-function signature="append(QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="append(QString)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="append(const char *)" remove="all">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="append(char)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="appendByte"/>
                 </modify-function>
                 <modify-function signature="count(const char *)const" remove="all"/>
                 <modify-function signature="data()" remove="all"/>
                 <modify-function signature="endsWith(const char *)const" remove="all"/>
                 <modify-function signature="fill(char,int)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="indexOf(const char*,int)const" remove="all"/>
                 <modify-function signature="indexOf(char,int)const">
                   <rename to="indexOfByte"/>
                 </modify-function>
                 <modify-function signature="insert(int,QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="insert(int,QString)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="insert(int,const char *)" remove="all"/>
                 <modify-function signature="insert(int,char)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="insertByte"/>
                 </modify-function>
                 <modify-function signature="lastIndexOf(const char*,int)const" remove="all"/>
                 <modify-function signature="lastIndexOf(char,int)const">
                   <rename to="lastIndexOfByte"/>
                 </modify-function>
                 <modify-function signature="prepend(QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="prepend(const char *)" remove="all"/>
                 <modify-function signature="prepend(char)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="prependByte"/>
                 </modify-function>
                 <modify-function signature="remove(int,int)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(int,int,QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(int,int,const char *)" remove="all"/>
                 <modify-function signature="replace(QByteArray,QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(const char*,QByteArray)" remove="all"/>
                 <modify-function signature="replace(QByteArray,const char *)" remove="all"/>
                 <modify-function signature="replace(QString,QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(QString,const char *)" remove="all"/>
                 <modify-function signature="replace(const char *,const char *)" remove="all"/>
                 <modify-function signature="replace(char,QByteArray)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(char,QString)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="replace(char,const char *)" remove="all"/>
                 <modify-function signature="replace(char,char)">
                   <modify-argument index="0" replace-value="this"/>
                 </modify-function>
                 <modify-function signature="startsWith(const char *)const" remove="all"/>
                 <modify-function signature="fromRawData(const char*,int)" remove="all"/>
                 <modify-function signature="number(int,int)">
                   <rename to="fromInt"/>
                 </modify-function>
                 <modify-function signature="number(uint,int)">
                   <rename to="fromUInt"/>
                 </modify-function>
                 <modify-function signature="number(qlonglong,int)">
                   <rename to="fromLongLong"/>
                 </modify-function>
                 <modify-function signature="number(qulonglong,int)">
                   <rename to="fromULongLong"/>
                 </modify-function>
                 <modify-function signature="setNum(int,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setInt"/>
                 </modify-function>
                 <modify-function signature="setNum(uint,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setUInt"/>
                 </modify-function>
                 <modify-function signature="setNum(short,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setShort"/>
                 </modify-function>
                 <modify-function signature="setNum(ushort,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setUShort"/>
                 </modify-function>
                 <modify-function signature="setNum(qlonglong,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setLongLong"/>
                 </modify-function>
                 <modify-function signature="setNum(qulonglong,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setULongLong"/>
                 </modify-function>
                 <modify-function signature="setNum(double,char,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setDouble"/>
                 </modify-function>
                 <modify-function signature="setNum(float,char,int)">
                   <modify-argument index="0" replace-value="this"/>
                   <rename to="setFloat"/>
                 </modify-function>
                 <modify-function signature="toDouble(bool*)const">
                     <modify-argument index="1">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toFloat(bool*)const">
                     <modify-argument index="1">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toInt(bool*,int)const">
                     <modify-argument index="1">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
                 <modify-function signature="toUShort(bool*,int)const">
                     <modify-argument index="1">
                       <remove-default-expression/>
                       <remove-argument/>
                       <conversion-rule class="native">
                       <insert-template name="core.prepare_removed_bool*_argument"/>
                       </conversion-rule>
                     </modify-argument>
                     <modify-argument index="return">
                       <conversion-rule class="native">
                       <insert-template name="core.convert_to_null_or_primitive"/>
                       </conversion-rule>
                     </modify-argument>
                 </modify-function>
               </value-type>
               <value-type name="QTextBoundaryFinder">
                 <modify-function signature="QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType,const QChar*,int,unsigned char*,int)" remove="all"/>
                 <modify-function signature="operator=(QTextBoundaryFinder)" remove="all"/>
               </value-type>
               <value-type name="QEasingCurve">
                 <modify-function signature="customType()const" remove="all"/>
                 <modify-function signature="setCustomType(double)" remove="all"/>
               </value-type>
               <object-type name="QAbstractAnimation"/>
               <object-type name="QVariantAnimation"/>
               <object-type name="QAnimationGroup"/>
               <object-type name="QPauseAnimation"/>
               <object-type name="QParallelAnimationGroup"/>
               <object-type name="QSequentialAnimationGroup"/>
               <object-type name="QPropertyAnimation"/>
               <object-type name="QAbstractState"/>
               <object-type name="QAbstractTransition"/>
               <object-type name="QState"/>
               <object-type name="QStateMachine"/>
               <object-type name="QHistoryState"/>
               <object-type name="QSignalTransition"/>
               <object-type name="QEventTransition"/>
               <object-type name="QFinalState"/>
               <object-type name="QXmlStreamEntityResolver"/>
               <object-type name="QAbstractEventDispatcher">
                 <extra-includes>
                     <include file-name="QPair" location="global"/>
                 </extra-includes>
               </object-type>
               <object-type name="QEventLoop"/>
               <object-type name="QFile">
                 <modify-function signature="readLink()const" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="readLink(QString)" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="map(long long,long long,QFile::MemoryMapFlags)" remove="all"/>
                 <!-- Can't provide same API and performance -->
                 <modify-function signature="unmap(unsigned char*)" remove="all"/>
                 <!-- Can't provide same API and performance -->
                 <modify-function signature="open(int,QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/>
                 <modify-function signature="decodeName(const char*)" remove="all"/>
                 <modify-function signature="map(qint64,qint64,QFile::MemoryMapFlags)" remove="all"/>
                 <modify-function signature="unmap(uchar*)" remove="all"/>
               </object-type>
               <object-type name="QIODevice">
                 <modify-function signature="peek(char *,qint64)" remove="all"/>
                 <modify-function signature="read(char *,qint64)" remove="all"/>
                 <modify-function signature="readLine(char *,qint64)" remove="all"/>
                 <modify-function signature="write(const char *,qint64)" remove="all"/>
               </object-type>
               <object-type name="QStateMachine::SignalEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::StateMachineSignal"/>
               <object-type name="QStateMachine::WrappedEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::StateMachineWrapped"/>
               <object-type name="QCryptographicHash">
                 <modify-function signature="addData(const char*,int)" remove="all"/>
               </object-type>
               <object-type name="QLibraryInfo"/>
               <object-type name="QMutex"/>
               <object-type name="QSemaphore"/>
               <object-type name="QSocketNotifier"/>
               <object-type name="QSystemLocale"/>
               <object-type name="QTemporaryFile">
                 <modify-function signature="fileName()const" rename="uniqueFilename"/>
                 <modify-function signature="createLocalFile(QFile&amp;)">
                   <modify-argument index="1">
                     <replace-type modified-type="QFile*"/>
                     <conversion-rule class="native">
                     QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
               </object-type>
               <object-type name="QMimeData">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                   <include file-name="QUrl" location="global"/>
                 </extra-includes>
               </object-type>
               <object-type name="QTextCodec">
                 <modify-function signature="setCodecForTr(QTextCodec*)">
                   <access modifier="private"/>
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcCodecForTr"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setCodecForCStrings(QTextCodec*)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcCodecForCStrings"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setCodecForLocale(QTextCodec*)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcCodecForLocale"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="codecForTr()">
                   <remove/>
                 </modify-function>
                 <modify-function signature="QTextCodec()">
                   <modify-argument index="-1">
                     <define-ownership class="java" owner="c++"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="fromUnicode(const QChar*,int,QTextCodec::ConverterState*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="toUnicode(const char*,int,QTextCodec::ConverterState*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="toUnicode(const char*)const">
                   <remove/>
                 </modify-function>
               </object-type>
               <object-type name="QTextDecoder">
                 <modify-function signature="toUnicode(const char*,int)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="toUnicode(QString*,const char*,int)" remove="all"/>
               </object-type>
               <object-type name="QTextEncoder">
                 <modify-function signature="fromUnicode(const QChar*,int)">
                   <remove/>
                 </modify-function>
               </object-type>
               <object-type name="QTimeLine"/>
               <object-type name="QTranslator">
                 <modify-function signature="translate(const char*,const char*,const char*,int)const">
                   <remove/>
                 </modify-function>
               </object-type>
               <object-type name="QWaitCondition"/>
               <object-type name="QFileSystemWatcher">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                 </extra-includes>
               </object-type>
               <object-type name="QTextCodec::ConverterState">
                 <include file-name="QTextCodec" location="global"/>
               </object-type>
               <object-type name="QBuffer">
                 <modify-function signature="buffer()">
                   <remove/>
                 </modify-function>
                 <modify-function signature="connectNotify(const char *)" remove="all"/>
                 <modify-function signature="disconnectNotify(const char *)" remove="all"/>
                 <!-- ### modify to return value by pointer? -->
                 <modify-function signature="buffer()const" remove="all"/>
                 <modify-function signature="data()const" remove="all"/>
                 <modify-function signature="setData(const char*,int)" remove="all"/>
               </object-type>
               <object-type name="QTimer"/>
               <object-type name="QAbstractFileEngineHandler">
                 <modify-function signature="create(const QString &amp;) const">
                   <modify-argument index="return">
                     <define-ownership owner="c++" class="shell"/>
                   </modify-argument>
                 </modify-function>
               </object-type>
               <object-type name="QAbstractFileEngine::MapExtensionOption"/>
               <object-type name="QAbstractFileEngine::MapExtensionReturn"/>
               <object-type name="QAbstractFileEngine::UnMapExtensionOption"/>
               <object-type name="QAbstractFileEngine">
                 <extra-includes>
                   <include file-name="QDateTime" location="global"/>
                 </extra-includes>
                 <modify-function signature="map(long long,long long,QFile::MemoryMapFlags)" remove="all"/>
                 <modify-function signature="unmap(unsigned char*)" remove="all"/>
               </object-type>
               <object-type name="QProcess">
                 <modify-function signature="readChannelMode()const" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="setReadChannelMode(QProcess::ProcessChannelMode)" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </object-type>
               <object-type name="QSignalMapper">
                 <modify-function signature="mapped(const QString &amp;)">
                   <rename to="mappedString"/>
                 </modify-function>
                 <modify-function signature="mapped(int)">
                   <rename to="mappedInteger"/>
                 </modify-function>
                 <modify-function signature="mapped(QObject *)">
                   <rename to="mappedQObject"/>
                 </modify-function>
                 <modify-function signature="mapped(QWidget *)" remove="all"/>
                 <modify-function signature="mapping(QWidget*)const" remove="all"/>
                 <modify-function signature="setMapping(QObject*,QWidget*)" remove="all"/>
                 <!-- ### overloads -->
                 <modify-function signature="mapping(int)const">
                   <rename to="mappingById"/>
                 </modify-function>
                 <modify-function signature="mapping(QString)const">
                   <rename to="mappingByString"/>
                 </modify-function>
                 <modify-function signature="mapping(QObject*)const">
                   <rename to="mappingByObject"/>
                 </modify-function>
                 <modify-function signature="setMapping(QObject*,int)">
                   <rename to="setMappingById"/>
                 </modify-function>
                 <modify-function signature="setMapping(QObject*,QString)">
                   <rename to="setMappingByString"/>
                 </modify-function>
                 <modify-function signature="setMapping(QObject*,QObject*)">
                   <rename to="setMappingByObject"/>
                 </modify-function>
               </object-type>
               <object-type name="QObject">
                 <modify-function signature="childEvent(QChildEvent*)">
                   <modify-argument index="1" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="customEvent(QEvent*)">
                   <modify-argument index="1" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="event(QEvent*)">
                   <modify-argument index="1" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="eventFilter(QObject*,QEvent*)">
                   <modify-argument index="2" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="timerEvent(QTimerEvent*)">
                   <modify-argument index="1" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="installEventFilter(QObject*)">
                   <modify-argument index="1">
                     <reference-count action="add" variable-name="__rcEventFilters"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="removeEventFilter(QObject*)">
                   <modify-argument index="1">
                     <reference-count action="remove" variable-name="__rcEventFilters"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setParent(QObject*)">
                   <modify-argument index="1">
                     <reference-count action="ignore"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="deleteLater()">
                   <rename to="disposeLater"/>
                 </modify-function>
                 <modify-function signature="inherits(const char*)const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="property(const char*)const">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="setProperty(const char*,QVariant)">
                   <access modifier="private"/>
                 </modify-function>
                 <extra-includes>
                   <include file-name="QVarLengthArray" location="global"/>
                 </extra-includes>
                 <modify-function signature="property(const char*)const">
                   <modify-argument index="1">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setProperty(const char*,QVariant)">
                   <modify-argument index="1">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="inherits(const char*)const">
                   <modify-argument index="1">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
               </object-type>
               <object-type name="QCoreApplication">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                 </extra-includes>
                 <modify-function signature="argv()" remove="all"/>
                 <!-- Obsolete -->
                 <modify-function signature="argc()" remove="all"/>
                 <!-- Obsolete -->
                 <modify-function signature="notify(QObject*,QEvent*)">
                   <modify-argument index="2" invalidate-after-use="yes"/>
                 </modify-function>
                 <modify-function signature="QCoreApplication(int &amp;, char  **)">
                   <access modifier="private"/>
                 </modify-function>
                 <modify-function signature="QCoreApplication(int &amp;, char  **, int)" remove="all"/>
                 <modify-function signature="removePostedEvents(QObject*)">
                   <modify-argument index="1">
                     <reference-count action="ignore"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="removePostedEvents(QObject*,int)">
                   <modify-argument index="1">
                     <reference-count action="ignore"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="installTranslator(QTranslator *)">
                   <modify-argument index="1">
                     <reference-count action="add" variable-name="__rcTranslators"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="removeTranslator(QTranslator *)">
                   <modify-argument index="1">
                     <reference-count action="remove" variable-name="__rcTranslators"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="postEvent(QObject*,QEvent*)">
                   <modify-argument index="2">
                     <define-ownership class="java" owner="c++"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="QCoreApplication(int &amp;, char **)" remove="all"/>
                 <!-- ### arguments() causes a warning: "QScriptValue::setProperty(arguments): cannot change flags of a native property" -->
                 <modify-function signature="arguments()" remove="all"/>
                 <modify-function signature="translate(const char*,const char*,const char*,QCoreApplication::Encoding,int)">
                   <modify-argument index="1">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                   <modify-argument index="2">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                   <modify-argument index="3">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="translate(const char *,const char *,const char *,QCoreApplication::Encoding)">
                   <modify-argument index="1">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                   <modify-argument index="2">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                   <modify-argument index="3">
                     <replace-type modified-type="QString"/>
                     <conversion-rule class="native">
                       <insert-template name="core.convert_string_arg_to_char*"/>
                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
               </object-type>
               <object-type name="QSettings">
                 <extra-includes>
                   <include file-name="QStringList" location="global"/>
                 </extra-includes>
                 <modify-function signature="setIniCodec(QTextCodec*)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcIniCodec"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setSystemIniPath(const QString&amp;)" remove="all"/>
                 <!--### Obsolete in 4.3-->
                 <modify-function signature="setUserIniPath(const QString&amp;)" remove="all"/>
                 <!--### Obsolete in 4.3-->
               </object-type>
               <object-type name="QEvent" polymorphic-base="yes" polymorphic-id-expression="%1-&gt;type() == QEvent::None"/>
               <object-type name="QChildEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ChildAdded || %1-&gt;type() == QEvent::ChildPolished || %1-&gt;type() == QEvent::ChildRemoved">
                 <modify-field name="c" read="false" write="false"/>
               </object-type>
               <object-type name="QTimerEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Timer"/>
               <object-type name="QDynamicPropertyChangeEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DynamicPropertyChange"/>
               <object-type name="QDataStream">
                 <modify-function signature="setDevice(QIODevice*)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcDevice"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="unsetDevice()">
                   <inject-code position="end">
                     __rcDevice = null;
                   </inject-code>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const char*)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned char)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned int)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned long long)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned short)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(char &amp;*)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(uint&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(unsigned char&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(unsigned long long&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="readRawData(char*,int)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="readBytes(char&amp;*,uint&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="writeRawData(const char*,int)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="writeBytes(const char*,uint)">
                   <remove/>
                 </modify-function>
                   <modify-function signature="operator&gt;&gt;(signed char&amp;)" remove="all"/>
                   <modify-function signature="operator&lt;&lt;(signed char)" remove="all"/>
                   <modify-function signature="operator&lt;&lt;(bool)">
                       <rename to="writeBoolean"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(unsigned char)">
                       <modify-argument index="0" replace-value="this"/>
                       <rename to="writeByte"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(int)">
                       <rename to="writeInt"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(qint64)">
                       <rename to="writeLongLong"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(float)">
                       <rename to="writeFloat"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(double)">
                       <rename to="writeDouble"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(short)">
                       <rename to="writeShort"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(bool &amp;)">
                       <rename to="readBoolean"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         bool __result;
                         bool &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         bool %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(unsigned char &amp;)">
                       <rename to="readByte"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         unsigned char __result;
                         unsigned char &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         int %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(int &amp;)">
                       <rename to="readInt"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         int __result;
                         int &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         int %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(uint &amp;)">
                       <rename to="readUInt"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         uint __result;
                         uint &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         uint %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(qint64 &amp;)">
                       <rename to="readLongLong"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         qint64 __result;
                         qint64 &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         qint64 %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(unsigned long long &amp;)">
                       <rename to="readULongLong"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         unsigned long long __result;
                         unsigned long long &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         unsigned long long %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(float &amp;)">
                       <rename to="readFloat"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         float __result;
                         float &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         float %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(double &amp;)">
                       <rename to="readDouble"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         double __result;
                         double &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         double %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(short &amp;)">
                       <rename to="readShort"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         short __result;
                         short &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         short %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(unsigned short &amp;)">
                       <rename to="readUShort"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         unsigned short __result;
                         unsigned short &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         unsigned short %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
               </object-type>
               <object-type name="QFSFileEngine">
                 <extra-includes>
                   <include file-name="QDateTime" location="global"/>
                 </extra-includes>
               </object-type>
               <object-type name="QTextStream">
                 <modify-function signature="QTextStream(QByteArray *, QFlags&lt;QIODevice::OpenModeFlag&gt;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="QTextStream(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(QChar&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const void*)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned int)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned long long)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const QChar &amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned long)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(signed long)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const char*)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(unsigned short)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const QByteArray&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(unsigned long long&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(uint&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(ulong&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="setString(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="string()const">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(signed long&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(char*)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(QByteArray&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(QString&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&gt;&gt;(unsigned short&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="operator&lt;&lt;(const QString&amp;)">
                   <remove/>
                 </modify-function>
                 <modify-function signature="setCodec(QTextCodec *)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcCodec"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="QTextStream(QIODevice *)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcDevice"/>
                   </modify-argument>
                 </modify-function>
                 <modify-function signature="setDevice(QIODevice *)">
                   <modify-argument index="1">
                     <reference-count action="set" variable-name="__rcDevice"/>
                   </modify-argument>
                 </modify-function>
                   <modify-function signature="setCodec(const char *)">
                     <modify-argument index="1">
                       <replace-type modified-type="QString"/>
                       <conversion-rule class="native">
                         <insert-template name="core.convert_string_arg_to_char*"/>
                       </conversion-rule>
                     </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(QBool)">
                       <rename to="writeBoolean"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(char)">
                       <modify-argument index="0" replace-value="this"/>
                       <rename to="writeByte"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(signed int)">
                       <rename to="writeInt"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(qlonglong)">
                       <rename to="writeLongLong"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(float)">
                       <rename to="writeFloat"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(double)">
                       <rename to="writeDouble"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(signed short)">
                       <rename to="writeShort"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(const QByteArray&amp;)">
                       <rename to="writeByteArray"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(const QString&amp;)">
                       <rename to="writeString"/>
                       <modify-argument index="0" replace-value="this"/>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(char&amp;)">
                       <rename to="readByte"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         char __result;
                         char &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         int %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(signed short&amp;)">
                       <rename to="readShort"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         short __result;
                         short &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         short %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(signed int&amp;)">
                       <rename to="readInt"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         int __result;
                         int &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         int %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(unsigned short&amp;)">
                       <rename to="readUShort"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         unsigned short __result;
                         unsigned short &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         unsigned short %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(unsigned int&amp;)">
                       <rename to="readUInt"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         unsigned int __result;
                         unsigned int &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         unsigned int %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(qlonglong&amp;)">
                       <rename to="readLongLong"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         qlonglong __result;
                         qlonglong &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         qlonglong %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(qulonglong&amp;)">
                       <rename to="readULongLong"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         qulonglong __result;
                         qulonglong &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         qulonglong %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(float&amp;)">
                       <rename to="readFloat"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         float __result;
                         float &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         float %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&gt;&gt;(double&amp;)">
                       <rename to="readDouble"/>
                       <modify-argument index="1">
                         <remove-argument/>
                         <conversion-rule class="native">
                         double __result;
                         double &amp; %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                       <modify-argument index="0" replace-value="void">
                         <conversion-rule class="native">
                         double %out% = __result;
                         </conversion-rule>
                       </modify-argument>
                   </modify-function>
                   <modify-function signature="operator&lt;&lt;(qulonglong)" remove="all"/>
                   <modify-function signature="operator&gt;&gt;(qulonglong&amp;)" remove="all"/>
               </object-type>
               <object-type name="QSystemSemaphore"/>
               <namespace-type name="QtConcurrent" target-type="class">
                 <extra-includes>
                     <include file-name="qtconcurrentreducekernel.h" location="global"/>
                     <include file-name="qtconcurrentthreadengine.h" location="global"/>
                 </extra-includes>
               </namespace-type>
               <value-type name="QFuture" generate="no">
                 <modify-function signature="operator T() const" remove="all"/>
                 <modify-function signature="operator=(const QFuture &amp;)" remove="all"/>
               </value-type>
               <value-type name="QtJambiVoidFuture" java-name="QFutureVoid">
                 <modify-function signature="resultCount()const" remove="all"/>
                 <modify-function signature="isResultReadyAt(int)const" remove="all"/>
               </value-type>
               <value-type name="QtJambiFuture" java-name="QFuture" generic-class="yes"/>
               <object-type name="QFutureWatcherBase">
                 <modify-function signature="connectNotify(const char *)" remove="all"/>
                 <modify-function signature="disconnectNotify(const char *)" remove="all"/>
               </object-type>
               <object-type name="QtJambiVoidFutureWatcher" java-name="QFutureWatcherVoid"/>
               <object-type name="QFutureWatcher" generate="no">
                 <modify-function signature="future()const" remove="all"/>
               </object-type>
               <object-type name="QtJambiFutureWatcher" java-name="QFutureWatcher" generic-class="yes"/>
               <object-type name="QFutureSynchronizer" generate="no"/>
               <object-type name="QtJambiFutureSynchronizer" generic-class="yes" java-name="QFutureSynchronizer"/>
               <object-type name="QtJambiVoidFutureSynchronizer" java-name="QFutureSynchronizerVoid"/>
               <object-type name="QThreadPool"/>
               <object-type name="QFutureIterator" generate="no">
                 <modify-function signature="operator=(const QFuture&amp;)" remove="all"/>
               </object-type>
               <object-type name="QtJambiFutureIterator" generic-class="yes" java-name="QFutureIterator"/>
               <object-type name="QRunnable"/>
               <object-type name="QSysInfo"/>
               <object-type name="QLibrary"/>
               <object-type name="QResource"/>
               <object-type name="QSharedMemory"/>
               <object-type name="QMetaObject"/>
               <object-type name="QMetaMethod"/>
               <object-type name="QMetaEnum"/>
               <object-type name="QMetaProperty"/>
               <object-type name="QMetaClassInfo"/>
               <object-type name="QElapsedTimer"/>
               <object-type name="QMetaType"/>
               <!-- Inefficient hash codes -->
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QUuid' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QLocale' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QFuture' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QRegExp' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QFutureVoid' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QUrl' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QProcessEnvironment' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::selectIteration', unmatched parameter type 'T'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QVariantAnimation::registerInterpolator', unmatched parameter type 'QVariantAnimation::Interpolator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'Qt::Initialization'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'std::*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type '*Private\*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type '*Private&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'FILE\*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QByteArray::Data\*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QTSMFC'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QTSMFI'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QAbstractFileEngine::ExtensionOption const\*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QAbstractFileEngine::Iterator\*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QDataStream::ByteOrder'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: visibility of function '*' modified in class '*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: hiding of function '*' in class '*'"/>
               <suppress-warning text="WARNING(CppImplGenerator) :: protected function '*' in final class '*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QPointer&lt;*&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QVector&lt;*&gt;'"/>
               <suppress-warning text="* private virtual function '*' in 'QAbstractListModel'"/>
               <suppress-warning text="* private virtual function '*' in 'QAbstractTableModel'"/>
               <suppress-warning text="* private virtual function '*' in 'QListWidget'"/>
               <suppress-warning text="* private virtual function '*' in 'QTreeWidget'"/>
               <suppress-warning text="* private virtual function '*' in 'QFontDialog'"/>
               <suppress-warning text="* private virtual function '*' in 'QTableWidget'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcherBase::futureInterface', unmatched return type 'QFutureInterfaceBase&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcherBase::futureInterface', unmatched return type 'QFutureInterfaceBase const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcher::futureInterface', unmatched return type 'QFutureInterfaceBase&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcher::futureInterface', unmatched return type 'QFutureInterfaceBase const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: unknown operator 'T'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::constBegin', unmatched return type 'const_iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::end', unmatched return type 'const_iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::constEnd', unmatched return type 'const_iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::QFuture', unmatched parameter type 'QFutureInterface&lt;T&gt;*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::begin', unmatched return type 'const_iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::advance', unmatched parameter type 'It&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'Sequence'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'QList&lt;U&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'QList&lt;MapFunctor::result_type&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'OutputSequence'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filtered', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filtered', unmatched parameter type 'Sequence const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filter', unmatched parameter type 'Sequence&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;qValueType&lt;Iterator&gt;::value_type&gt;"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;Sequence::value_type&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;Iterator::value_type&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'V'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'W'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'ResultType'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'U'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFiltered', unmatched return type 'OutputSequence'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFiltered', unmatched return type 'Sequence'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMappedReduced', unmatched return type 'ThreadEngineStarter&lt;ResultType&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'U'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'V'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'ResultType'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMap', unmatched return type 'ThreadEngineStarter&lt;void&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startThreadEngine', unmatched return type 'ThreadEngineStarter&lt;ThreadEngine::ResultType&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mappedReduced', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mappedReduced', unmatched parameter type 'Sequence const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filteredReduced', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filteredReduced', unmatched parameter type 'Sequence const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::map', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::map', unmatched parameter type 'Sequence&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filterInternal', unmatched return type 'ThreadEngineStarter&lt;void&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'QtConcurrent::SelectMemberFunctor0lt;T,Class&gt;::type'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'SelectFunctor0&lt;T,T&gt;::type'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mapped', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mapped', unmatched parameter type 'Sequence const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMap', unmatched parameter type 'Iterator'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMap', unmatched parameter type 'Sequence&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMapped', unmatched return type 'QtConcurrent::ThreadEngineStarter&lt;T&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFilteredReduced', unmatched return type 'ThreadEngineStarter&lt;ResultType&gt;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class const*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class const&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'FunctionObject*'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'FunctionObject'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'T'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilter', unmatched parameter type 'Sequence&amp;'"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'QtConcurrent::SelectMemberFunctor0&lt;T,Class&gt;::type'"/>
               <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFuture&lt;void&gt;::operator= - definition *ignored*"/>
               <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFutureInterface&lt;void&gt;::future - definition *ignored*"/>
               <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFutureWatcher&lt;void&gt;::setFuture - definition *ignored*"/>
             </typesystem>

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