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