PythonQtClassInfo.h
262 lines
| 9.4 KiB
| text/x-c
|
CLexer
/ src / PythonQtClassInfo.h
ezust
|
r0 | #ifndef _PYTHONQTCLASSINFO_H | ||
| #define _PYTHONQTCLASSINFO_H | ||||
| /* | ||||
| * | ||||
florianlink
|
r133 | * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved. | ||
|
ezust
|
r0 | * | ||
| * 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 | ||||
| * | ||||
|
florianlink
|
r133 | * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29, | ||
|
ezust
|
r0 | * 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 | ||||
| */ | ||||
|
florianlink
|
r139 | class PYTHONQT_EXPORT PythonQtClassInfo { | ||
|
ezust
|
r0 | |||
| 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); | ||||
|
florianlink
|
r119 | //! set the type capabilities | ||
| void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; } | ||||
| //! get the type capabilities | ||||
| int typeSlots() const { return _typeSlots; } | ||||
|
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
|
r119 | int _typeSlots; | ||
|
florianlink
|
r24 | |||
| bool _isQObject; | ||||
|
florianlink
|
r51 | bool _enumsCreated; | ||
|
florianlink
|
r10 | |||
|
ezust
|
r0 | }; | ||
| //--------------------------------------------------------------- | ||||
| #endif | ||||