PythonQtClassInfo.h

Go to the documentation of this file.

#ifndef _PYTHONQTCLASSINFO_H
#define _PYTHONQTCLASSINFO_H
 
/*
 *
 *  Copyright (C) 2010 MeVis Medical Solutions AG 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 Medical Solutions AG, Universitaetsallee 29,
 *  28359 Bremen, Germany or:
 *
 *  http://www.mevis.de
 *
 */
 
#include "PythonQtPythonInclude.h"
#include "PythonQt.h"
#include <QMetaObject>
#include <QMetaMethod>
#include <QHash>
#include <QByteArray>
#include <QList>
 
class PythonQtSlotInfo;
class PythonQtClassInfo;
 
struct PythonQtDynamicClassInfo
{
  PythonQtDynamicClassInfo() { _dynamicMetaObject = NULL; _classInfo = NULL; }
  ~PythonQtDynamicClassInfo();
 
  const QMetaObject* _dynamicMetaObject;
  PythonQtClassInfo* _classInfo;
};
 
struct PythonQtMemberInfo {
  enum Type {
    Invalid, Slot, Signal, EnumValue, EnumWrapper, Property, NestedClass, NotFound 
  };
 
  PythonQtMemberInfo():_type(Invalid),_slot(NULL),_pythonType(NULL),_enumValue(0) { }
  
  PythonQtMemberInfo(PythonQtSlotInfo* info);
 
  PythonQtMemberInfo(const PythonQtObjectPtr& enumValue);
 
  PythonQtMemberInfo(const QMetaProperty& prop);
 
  Type              _type;
 
  // TODO: this could be a union...
  PythonQtSlotInfo* _slot;
  PyObject*         _pythonType;
  PythonQtObjectPtr _enumValue;
  QMetaProperty     _property;
};
 
 
class PYTHONQT_EXPORT PythonQtClassInfo {
 
public:
  PythonQtClassInfo();
  ~PythonQtClassInfo();
 
  struct ParentClassInfo {
    ParentClassInfo(PythonQtClassInfo* parent, int upcastingOffset=0):_parent(parent),_upcastingOffset(upcastingOffset)
    {};
 
    PythonQtClassInfo* _parent;
    int                _upcastingOffset;
  };
 
 
  void setupQObject(const QMetaObject* meta);
 
  void setupCPPObject(const QByteArray& classname);
 
  void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; }
  int typeSlots() const { return _typeSlots; }
 
  PythonQtMemberInfo member(const char* member);
 
  PythonQtSlotInfo* constructors();
  
  PythonQtSlotInfo* destructor();
 
  void addConstructor(PythonQtSlotInfo* info);
 
  void setDestructor(PythonQtSlotInfo* info);
 
  void addDecoratorSlot(PythonQtSlotInfo* info);
 
  void addNestedClass(PythonQtClassInfo* info);
 
  const QByteArray& className() const;
 
  QByteArray unscopedClassName() const;
 
  bool isQObject() { return _isQObject; }
 
  bool isCPPWrapper() { return !_isQObject; }
 
  const QMetaObject* metaObject() { return _meta; }
 
  void setMetaObject(const QMetaObject* meta);
 
  bool inherits(const char* classname);
  
  bool inherits(PythonQtClassInfo* info);
 
  void* castTo(void* ptr, const char* classname);
 
  QString help();
 
  QStringList propertyList();
 
  QStringList memberList();
 
  int metaTypeId() { return _metaTypeId; }
 
  void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb);
 
  QObject* decorator();
  
  void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
 
  void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
 
  PyObject* pythonQtClassWrapper() { return _pythonQtClassWrapper; }
 
  void setShellSetInstanceWrapperCB(PythonQtShellSetInstanceWrapperCB* cb) {
    _shellSetInstanceWrapperCB = cb;
  }
  
  PythonQtShellSetInstanceWrapperCB* shellSetInstanceWrapperCB() {
    return _shellSetInstanceWrapperCB;
  }
 
  void addPolymorphicHandler(PythonQtPolymorphicHandlerCB* cb) { _polymorphicHandlers.append(cb); }
 
  void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
 
  static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);
 
  void clearNotFoundCachedMembers();
 
  const QList<PythonQtClassInfo*>& nestedClasses() { return _nestedClasses; }
 
  PyObject* copyObject(void* cppObject);
 
  PythonQtSlotInfo* getCopyConstructor();
 
  void setReferenceCounting(PythonQtVoidPtrCB* refCB, PythonQtVoidPtrCB* unrefCB);
 
  PythonQtVoidPtrCB* referenceCountingRefCB();
  PythonQtVoidPtrCB* referenceCountingUnrefCB();
 
  PyObject* getPythonTypeForProperty(const QString& name);
 
  PythonQtClassInfo* getClassInfoForProperty( const QString& name );
 
  bool supportsRichCompare();
 
private:
  void updateRefCountingCBs();
 
  void createEnumWrappers(const QObject* decoratorProvider);
  void createEnumWrappers(const QMetaObject* meta);
  PyObject* findEnumWrapper(const char* name);
 
  void clearCachedMembers();
 
  void* recursiveCastDownIfPossible(void* ptr, const char** resultClassName);
 
  PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
  void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
  PythonQtSlotInfo* recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
 
  void recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects);
  void recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects);
 
  bool lookForPropertyAndCache(const char* memberName);
  bool lookForMethodAndCache(const char* memberName);
  bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
 
  PythonQtSlotInfo* findDecoratorSlots(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
  int findCharOffset(const char* sigStart, char someChar);
 
  QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
 
  PythonQtSlotInfo*                    _constructors;
  PythonQtSlotInfo*                    _destructor;
 
  PythonQtVoidPtrCB*                   _refCallback;
  PythonQtVoidPtrCB*                   _unrefCallback;
 
  QList<PythonQtSlotInfo*>             _decoratorSlots;
 
  QList<PythonQtObjectPtr>             _enumWrappers;
 
  const QMetaObject*                   _meta;
 
  QByteArray                           _wrappedClassName;
  QList<ParentClassInfo>               _parentClasses;
 
  QList<PythonQtPolymorphicHandlerCB*> _polymorphicHandlers;
 
  QList<PythonQtClassInfo*>            _nestedClasses;
 
  QObject*                             _decoratorProvider;
  PythonQtQObjectCreatorFunctionCB*    _decoratorProviderCB;
  
  PyObject*                            _pythonQtClassWrapper;
  
  PythonQtShellSetInstanceWrapperCB*   _shellSetInstanceWrapperCB;
  
  int  _metaTypeId;
  int  _typeSlots;
 
  bool _isQObject;
  bool _enumsCreated;
  bool _richCompareDetectionDone;
  bool _searchPolymorphicHandlerOnParent;
  bool _searchRefCountCB;
  
};
 
//---------------------------------------------------------------
 
 
#endif