template<class T1, class T2> int PythonQtUpcastingOffset() {

}

};

//---------------------------------------------------------------------------

//! \name Singleton Initialization

//@{

//! initialize the python qt binding (flags are a or combination of PythonQt::InitFlags), if \c pythonQtModuleName is given

//! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.

//! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.

static PythonQt* self() { return _self; }

//@}

//! defines the object types for introspection

enum ObjectType {

Class,

//! to a module later on.

//! The user needs to make sure that the \c name is unique in the python module dictionary.

PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);

//! creates the new module \c name and evaluates the given script in the context of that module.

//! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code

//! to a module later on.

//! The user needs to make sure that the \c name is unique in the python module dictionary.

PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());

//! create a uniquely named module, you can use evalFile or evalScript to populate the module with

//! script code

PythonQtObjectPtr createUniqueModule();

void setModuleImportPath(PyObject* module, const QStringList& paths);

//@}

//---------------------------------------------------------------------------

//! \name Registering Classes

//@{

//! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)

/* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,

void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);

//! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants

//! (ownership of wrapper is passed to PythonQt)

/*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!

//---------------------------------------------------------------------------

//! \name Script Parsing and Evaluation

//@{

//! parses the given file and returns the python code object, this can then be used to call evalCode()

PythonQtObjectPtr parseFile(const QString& filename);

//---------------------------------------------------------------------------

//! \name Variable access

//! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)

void addObject(PyObject* object, const QString& name, QObject* qObject);

//---------------------------------------------------------------------------

//! \name Calling Python Objects

//! call the given python \c callable in the scope of object, returns the result converted to a QVariant

QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());

//---------------------------------------------------------------------------

//! \name Custom Importer

//@{

//! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)

//! (this method should be called directly after initialization of init() and before calling overwriteSysPath().

//! This is not reversible, so even setting setImporter(NULL) afterwards will

//! keep the custom PythonQt importer with a QFile default import interface.

//! Subsequent python import calls will make use of the passed importInterface

//! The error is currently just output to the python stderr, future version might implement better trace printing

bool handleError();

//! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt

void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);

//! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt

//! called by internal help methods

PyObject* helpCalled(PythonQtClassInfo* info);

//! returns the found object or NULL

//! @return new reference

PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);

//@}

signals:

//! add a handler for polymorphic downcasting

void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);

//! lookup existing classinfo and return new if not yet present

PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);

//! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants

//! (ownership of wrapper is passed to PythonQt)

/*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!

void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);

//! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes

//! and it will register the classes when it first sees a pointer to such a derived class

void registerQObjectClassNames(const QStringList& names);

//! called by virtual overloads when a python return value can not be converted to the required Qt type

void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);

//! get access to the PythonQt module

PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }

//! Setup the shared library suffixes by getting them from the "imp" module.

void setupSharedLibrarySuffixes();

//! the name of the PythonQt python module

QByteArray _pythonQtModuleName;

//! the importer interface (if set)

PythonQtImportFileInterface* _importInterface;

//! the default importer

PythonQtQFileImporter* _defaultImporter;

PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;

PythonQtQObjectWrappedCB* _wrappedCB;

PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;

int _initFlags;

int _PythonQtObjectPtr_metaId;

return NULL;

}

int metaTypeId() { return _metaTypeId; }

//! set an additional decorator provider that offers additional decorator slots for this class

//! get the decorator qobject instance

QObject* decorator();

//! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum

static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);

void createEnumWrappers();

void createEnumWrappers(const QMetaObject* meta);

PythonQtSlotInfo* findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);

int findCharOffset(const char* sigStart, char someChar);

QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;

PythonQtSlotInfo* _constructors;