From c68e0aff542c58c3425f7a62b3b762450eb4c6d8 2009-04-14 06:56:20
From: florianlink <florianlink@ea8d5007-eb21-0410-b261-ccb3ea6e24a9>
Date: 2009-04-14 06:56:20
Subject: [PATCH] code cleanup and rename of PythonQtWrapper to PythonQtInstanceWrapper and PythonQtMetaObjectWrapper to PythonQtClassWrapper, since these names match much better what these classes wrap, regarding that we are wrapping CPP objects as well

git-svn-id: svn://svn.code.sf.net/p/pythonqt/code/trunk@52 ea8d5007-eb21-0410-b261-ccb3ea6e24a9

---

diff --git a/src/PythonQt.cpp b/src/PythonQt.cpp
index 86c6506..92061ca 100644
--- a/src/PythonQt.cpp
+++ b/src/PythonQt.cpp
@@ -171,16 +171,16 @@ PythonQt::PythonQt(int flags)
   Py_INCREF(&PythonQtSlotFunction_Type);
   
   // add our own python object types for qt objects
-  if (PyType_Ready(&PythonQtWrapper_Type) < 0) {
-    std::cerr << "could not initialize PythonQtWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+  if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
+    std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
   }
-  Py_INCREF(&PythonQtWrapper_Type);
+  Py_INCREF(&PythonQtInstanceWrapper_Type);
   
   // add our own python object types for qt objects
-  if (PyType_Ready(&PythonQtMetaObjectWrapper_Type) < 0) {
-    std::cerr << "could not initialize PythonQtMetaObjectWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+  if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
+    std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
   }
-  Py_INCREF(&PythonQtMetaObjectWrapper_Type);
+  Py_INCREF(&PythonQtClassWrapper_Type);
   
   // add our own python object types for redirection of stdout
   if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
@@ -277,7 +277,7 @@ void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* p
       info = new PythonQtClassInfo(m);
       _knownQtClasses.insert(m->className(), info);
       PythonQtObjectPtr pack = packageByName(package);
-      PyObject* pyobj = (PyObject*)createNewPythonQtMetaObjectWrapper(info);
+      PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info);
       PyModule_AddObject(pack, m->className(), pyobj);
       if (package && strncmp(package,"Qt",2)==0) {
         // put all qt objects into Qt as well
@@ -328,7 +328,7 @@ PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
     Py_INCREF(Py_None);
     return Py_None;
   }
-  PythonQtWrapper* wrap = findWrapperAndRemoveUnused(obj);
+  PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);
   if (!wrap) {
     // smuggling it in...
     PythonQtClassInfo* classInfo = _knownQtClasses.value(obj->metaObject()->className());
@@ -336,7 +336,7 @@ PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
       registerClass(obj->metaObject());
       classInfo = _knownQtClasses.value(obj->metaObject()->className());
     }
-    wrap = createNewPythonQtWrapper(obj, classInfo);
+    wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
     //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
   } else {
     Py_INCREF(wrap);
@@ -351,7 +351,7 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
     Py_INCREF(Py_None);
     return Py_None;
   }
-  PythonQtWrapper* wrap = findWrapperAndRemoveUnused(ptr);
+  PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
   if (!wrap) {
     PythonQtClassInfo* info = _knownQtClasses.value(name);
     if (!info) {
@@ -370,7 +370,7 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
         registerClass(qptr->metaObject());
         info = _knownQtClasses.value(qptr->metaObject()->className());
       }
-      wrap = createNewPythonQtWrapper(qptr, info);
+      wrap = createNewPythonQtInstanceWrapper(qptr, info);
       //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
     } else {
       // maybe it is a PyObject, which we can return directly
@@ -391,13 +391,13 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
       if (!info) {
         info = new PythonQtClassInfo(wrapper?wrapper->metaObject():NULL, name);
         _knownQtWrapperClasses.insert(name, info);
-        PyModule_AddObject(_pythonQtModule, name, (PyObject*)createNewPythonQtMetaObjectWrapper(info));
+        PyModule_AddObject(_pythonQtModule, name, (PyObject*)createNewPythonQtClassWrapper(info));
       } else {
         if (wrapper && (info->metaObject() != wrapper->metaObject())) {
           info->setMetaObject(wrapper->metaObject());
         }
       }
-      wrap = createNewPythonQtWrapper(wrapper, info, ptr);
+      wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
       //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
     }
   } else {
@@ -408,9 +408,9 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
 }
 
 
-PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
-  PythonQtWrapper* result;
-  result = (PythonQtWrapper *)PythonQtWrapper_Type.tp_new(&PythonQtWrapper_Type,
+PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
+  PythonQtInstanceWrapper* result;
+  result = (PythonQtInstanceWrapper *)PythonQtInstanceWrapper_Type.tp_new(&PythonQtInstanceWrapper_Type,
     NULL, NULL);
 
   result->setQObject(obj);
@@ -431,9 +431,9 @@ PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQ
   return result;
 }
 
-PythonQtMetaObjectWrapper* PythonQtPrivate::createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info) {
-  PythonQtMetaObjectWrapper* result;
-  result = (PythonQtMetaObjectWrapper *)PythonQtMetaObjectWrapper_Type.tp_new(&PythonQtMetaObjectWrapper_Type,
+PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info) {
+  PythonQtClassWrapper* result;
+  result = (PythonQtClassWrapper *)PythonQtClassWrapper_Type.tp_new(&PythonQtClassWrapper_Type,
     NULL, NULL);
   result->_info = info;
   return result;
@@ -664,8 +664,8 @@ QStringList PythonQt::introspection(PyObject* module, const QString& objectname,
           results << info->fullSignature(info->isInstanceDecorator());
           info = info->nextInfo();
         }
-      } else if (object->ob_type == &PythonQtMetaObjectWrapper_Type) {
-        PythonQtMetaObjectWrapper* o = (PythonQtMetaObjectWrapper*)object.object();
+      } else if (object->ob_type == &PythonQtClassWrapper_Type) {
+        PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
         PythonQtSlotInfo* info = o->_info->constructors();
     
         while (info) {
@@ -1009,7 +1009,7 @@ void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentT
     info = new PythonQtClassInfo(NULL, typeName);
     _knownQtWrapperClasses.insert(typeName, info);
     PythonQtObjectPtr pack = packageByName(package);
-    PyObject* pyobj = (PyObject*)createNewPythonQtMetaObjectWrapper(info);
+    PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info);
     PyModule_AddObject(pack, typeName, pyobj);
     if (package && strncmp(package,"Qt",2)==0) {
       // put all qt objects into Qt as well
@@ -1055,9 +1055,9 @@ void PythonQtPrivate::removeWrapperPointer(void* obj)
   _wrappedObjects.remove(obj);
 }
 
-PythonQtWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
+PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
 {
-  PythonQtWrapper* wrap = _wrappedObjects.value(obj);
+  PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
   if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
     // this is a wrapper whose QObject was already removed due to destruction
     // so the obj pointer has to be a new QObject with the same address...
diff --git a/src/PythonQt.h b/src/PythonQt.h
index d6ce9dc..04e3a8b 100644
--- a/src/PythonQt.h
+++ b/src/PythonQt.h
@@ -43,8 +43,8 @@
 //----------------------------------------------------------------------------------
 
 #include "PythonQtSystem.h"
-#include "PythonQtWrapper.h"
-#include "PythonQtMetaObjectWrapper.h"
+#include "PythonQtInstanceWrapper.h"
+#include "PythonQtClassWrapper.h"
 #include "PythonQtSlot.h"
 #include "PythonQtObjectPtr.h"
 #include <QObject>
@@ -424,11 +424,11 @@ public:
   //! an enum of another known metaobject (and as last resort, of the Qt namespace)
   bool isEnumType(const QMetaObject* meta, const QByteArray& name);
 
-  //! helper method that creates a PythonQtMetaObjectWrapper object
-  PythonQtMetaObjectWrapper* createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info);
+  //! helper method that creates a PythonQtClassWrapper object
+  PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info);
 
-  //! helper method that creates a PythonQtWrapper object and registers it in the object map
-  PythonQtWrapper* createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
+  //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
+  PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
 
   //! get the class info for a meta object (if available)
   PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownQtClasses.value(meta->className()); }
@@ -450,10 +450,10 @@ private:
   PythonQtObjectPtr packageByName(const char* name);
 
   //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
-  PythonQtWrapper* findWrapperAndRemoveUnused(void* obj);
+  PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
 
   //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
-  QHash<void* , PythonQtWrapper *>       _wrappedObjects;
+  QHash<void* , PythonQtInstanceWrapper *>       _wrappedObjects;
 
   //! stores the meta info of known Qt classes
   QHash<QByteArray, PythonQtClassInfo *> _knownQtClasses;
diff --git a/src/PythonQtClassInfo.cpp b/src/PythonQtClassInfo.cpp
index ab127b9..7e4eb0f 100644
--- a/src/PythonQtClassInfo.cpp
+++ b/src/PythonQtClassInfo.cpp
@@ -350,11 +350,9 @@ void PythonQtClassInfo::listDecoratorSlotsFromDecoratorProvider(QStringList& lis
           sigStart += 7 + 1 + strlen(className());
           isClassDeco = true;
         } else if (qstrncmp(sigStart, "new_", 4)==0) {
-          sigStart += 4 + 1 + strlen(className());
-          isClassDeco = true;
+          continue;
         } else if (qstrncmp(sigStart, "delete_", 7)==0) {
-          sigStart += 7 + 1 + strlen(className());
-          isClassDeco = true;
+          continue;
         }
         // find the first '('
         int offset = findCharOffset(sigStart, '(');
@@ -375,7 +373,7 @@ QStringList PythonQtClassInfo::memberList(bool metaOnly)
 
   QStringList l;
   QString h;
-  if (_wrappedClassName.isEmpty() && _meta) {
+  if (_wrappedClassName.isEmpty() && _meta && !metaOnly) {
     int i;
     int numProperties = _meta->propertyCount();
     for (i = 0; i < numProperties; i++) {
diff --git a/src/PythonQtMetaObjectWrapper.cpp b/src/PythonQtClassWrapper.cpp
similarity index 73%
rename from src/PythonQtMetaObjectWrapper.cpp
rename to src/PythonQtClassWrapper.cpp
index 33605c8..b477a3d 100644
--- a/src/PythonQtMetaObjectWrapper.cpp
+++ b/src/PythonQtClassWrapper.cpp
@@ -32,14 +32,14 @@
 
 //----------------------------------------------------------------------------------
 /*!
-// \file    PythonQtMetaObjectWrapper.cpp
+// \file    PythonQtClassWrapper.cpp
 // \author  Florian Link
 // \author  Last changed by $Author: florian $
 // \date    2006-05
 */
 //----------------------------------------------------------------------------------
 
-#include "PythonQtMetaObjectWrapper.h"
+#include "PythonQtClassWrapper.h"
 #include <QObject>
 
 #include "PythonQt.h"
@@ -47,29 +47,29 @@
 #include "PythonQtClassInfo.h"
 #include "PythonQtConversion.h"
 
-static void PythonQtMetaObjectWrapper_dealloc(PythonQtMetaObjectWrapper* self)
+static void PythonQtClassWrapper_dealloc(PythonQtClassWrapper* self)
 {
   self->ob_type->tp_free((PyObject*)self);
 }
 
-static PyObject* PythonQtMetaObjectWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
+static PyObject* PythonQtClassWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
 {
-  PythonQtMetaObjectWrapper *self;
+  PythonQtClassWrapper *self;
 
-  self = (PythonQtMetaObjectWrapper *)type->tp_alloc(type, 0);
+  self = (PythonQtClassWrapper *)type->tp_alloc(type, 0);
   if (self != NULL) {
     self->_info = NULL;
   }
   return (PyObject *)self;
 }
 
-static int PythonQtMetaObjectWrapper_init(PythonQtMetaObjectWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
+static int PythonQtClassWrapper_init(PythonQtClassWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
 {
   return 0;
 }
 
-PyObject *PythonQtMetaObjectWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
-  PythonQtMetaObjectWrapper* wrapper = (PythonQtMetaObjectWrapper*)func;
+PyObject *PythonQtClassWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
+  PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)func;
   PyObject* result = NULL;
   QString error;
   PyObject* err = NULL;
@@ -89,8 +89,8 @@ PyObject *PythonQtMetaObjectWrapper_call(PyObject *func, PyObject *args, PyObjec
   }
   if (result) {
     // change ownershipflag to be owned by PythonQt
-    if (result->ob_type == &PythonQtWrapper_Type) {
-      ((PythonQtWrapper*)result)->_ownedByPythonQt = true;
+    if (result->ob_type == &PythonQtInstanceWrapper_Type) {
+      ((PythonQtInstanceWrapper*)result)->_ownedByPythonQt = true;
     }
   } else {
     if (!wrapper->_info->constructors()) {
@@ -105,38 +105,38 @@ PyObject *PythonQtMetaObjectWrapper_call(PyObject *func, PyObject *args, PyObjec
   return result;
 }
 
-static PyObject *PythonQtMetaObjectWrapper_classname(PythonQtMetaObjectWrapper* type)
+static PyObject *PythonQtClassWrapper_classname(PythonQtClassWrapper* type)
 {
   return PyString_FromString((QString("Meta_") + type->_info->className()).toLatin1().data());
 }
 
-static PyObject *PythonQtMetaObjectWrapper_help(PythonQtMetaObjectWrapper* type)
+static PyObject *PythonQtClassWrapper_help(PythonQtClassWrapper* type)
 {
   return PythonQt::self()->helpCalled(type->_info);
 }
 
 
-static PyMethodDef PythonQtMetaObjectWrapper_methods[] = {
-    {"className", (PyCFunction)PythonQtMetaObjectWrapper_classname, METH_NOARGS,
+static PyMethodDef PythonQtClassWrapper_methods[] = {
+    {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
      "Return the classname of the object"
     },
-    {"help", (PyCFunction)PythonQtMetaObjectWrapper_help, METH_NOARGS,
+    {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
     "Shows the help of available methods for this class"
     },
     {NULL, NULL, 0 , NULL}  /* Sentinel */
 };
 
 
-static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name)
+static PyObject *PythonQtClassWrapper_getattro(PyObject *obj,PyObject *name)
 {
   const char *attributeName;
-  PythonQtMetaObjectWrapper *wt = (PythonQtMetaObjectWrapper *)obj;
+  PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
 
   if ((attributeName = PyString_AsString(name)) == NULL) {
     return NULL;
   }
 
-  PythonQtMemberInfo member = wt->_info->member(attributeName);
+  PythonQtMemberInfo member = wrapper->_info->member(attributeName);
   if (member._type == PythonQtMemberInfo::EnumValue) {
     return PyInt_FromLong(member._enumValue);
   }
@@ -145,14 +145,14 @@ static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name
   }
 
   // look for the interal methods (className(), help())
-  PyObject* internalMethod = Py_FindMethod( PythonQtMetaObjectWrapper_methods, obj, (char*)attributeName);
+  PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);
   if (internalMethod) {
     return internalMethod;
   }
   PyErr_Clear();
 
   if (qstrcmp(attributeName, "__dict__")==0) {
-    QStringList l = wt->_info->memberList(true);
+    QStringList l = wrapper->_info->memberList(true);
     PyObject* dict = PyDict_New();
     foreach (QString name, l) {
       //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
@@ -162,39 +162,39 @@ static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name
     return dict;
   }
 
-  QString error = QString(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
+  QString error = QString(wrapper->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
   PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
   return NULL;
 }
 
-static PyObject * PythonQtMetaObjectWrapper_repr(PyObject * obj)
+static PyObject * PythonQtClassWrapper_repr(PyObject * obj)
 {
-  PythonQtMetaObjectWrapper* wt = (PythonQtMetaObjectWrapper*)obj;
-  if (wt->_info->isCPPWrapper()) {
-    const QMetaObject* meta = wt->_info->metaObject(); 
+  PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
+  if (wrapper->_info->isCPPWrapper()) {
+    const QMetaObject* meta = wrapper->_info->metaObject(); 
     if (!meta) {
-      QObject* decorator = wt->_info->decorator();
+      QObject* decorator = wrapper->_info->decorator();
       if (decorator) {
         meta = decorator->metaObject();
       }
     }
     if (meta) {
-      return PyString_FromFormat("%s Class (C++ wrapped by %s)", wt->_info->className(), meta->className());
+      return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->_info->className(), meta->className());
     } else {
-      return PyString_FromFormat("%s Class (C++ unwrapped)", wt->_info->className());
+      return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->_info->className());
     }
   } else {
-    return PyString_FromFormat("%s Class", wt->_info->className());
+    return PyString_FromFormat("%s Class", wrapper->_info->className());
   }
 }
 
-static int PythonQtMetaObjectWrapper_compare(PyObject * obj1, PyObject * obj2)
+static int PythonQtClassWrapper_compare(PyObject * obj1, PyObject * obj2)
 {
-  if (obj1->ob_type == &PythonQtMetaObjectWrapper_Type &&
-    obj2->ob_type == &PythonQtMetaObjectWrapper_Type) {
+  if (obj1->ob_type == &PythonQtClassWrapper_Type &&
+    obj2->ob_type == &PythonQtClassWrapper_Type) {
 
-    PythonQtMetaObjectWrapper* w1 = (PythonQtMetaObjectWrapper*)obj1;
-    PythonQtMetaObjectWrapper* w2 = (PythonQtMetaObjectWrapper*)obj2;
+    PythonQtClassWrapper* w1 = (PythonQtClassWrapper*)obj1;
+    PythonQtClassWrapper* w2 = (PythonQtClassWrapper*)obj2;
     if (w1->_info == w2->_info) {
       return 0;
     } else {
@@ -205,34 +205,34 @@ static int PythonQtMetaObjectWrapper_compare(PyObject * obj1, PyObject * obj2)
   }
 }
 
-static long PythonQtMetaObjectWrapper_hash(PythonQtMetaObjectWrapper *obj)
+static long PythonQtClassWrapper_hash(PythonQtClassWrapper *obj)
 {
   return reinterpret_cast<long>(obj->_info);
 }
 
-PyTypeObject PythonQtMetaObjectWrapper_Type = {
+PyTypeObject PythonQtClassWrapper_Type = {
     PyObject_HEAD_INIT(NULL)
     0,                         /*ob_size*/
-    "PythonQt.PythonQtMetaObjectWrapper",             /*tp_name*/
-    sizeof(PythonQtMetaObjectWrapper),             /*tp_basicsize*/
+    "PythonQt.PythonQtClassWrapper",             /*tp_name*/
+    sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
     0,                         /*tp_itemsize*/
-    (destructor)PythonQtMetaObjectWrapper_dealloc, /*tp_dealloc*/
+    (destructor)PythonQtClassWrapper_dealloc, /*tp_dealloc*/
     0,                         /*tp_print*/
     0,                         /*tp_getattr*/
     0,                         /*tp_setattr*/
-    PythonQtMetaObjectWrapper_compare,         /*tp_compare*/
-    PythonQtMetaObjectWrapper_repr,            /*tp_repr*/
+    PythonQtClassWrapper_compare,         /*tp_compare*/
+    PythonQtClassWrapper_repr,            /*tp_repr*/
     0,                         /*tp_as_number*/
     0,                         /*tp_as_sequence*/
     0,                         /*tp_as_mapping*/
-    (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
-    PythonQtMetaObjectWrapper_call,                         /*tp_call*/
+    (hashfunc)PythonQtClassWrapper_hash,                         /*tp_hash */
+    PythonQtClassWrapper_call,                         /*tp_call*/
     0,                         /*tp_str*/
-    PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/
+    PythonQtClassWrapper_getattro,                         /*tp_getattro*/
     0,                         /*tp_setattro*/
     0,                         /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
-    "PythonQtMetaObjectWrapper object",           /* tp_doc */
+    "PythonQtClassWrapper object",           /* tp_doc */
     0,                   /* tp_traverse */
     0,                   /* tp_clear */
     0,                   /* tp_richcompare */
@@ -247,9 +247,9 @@ PyTypeObject PythonQtMetaObjectWrapper_Type = {
     0,                         /* tp_descr_get */
     0,                         /* tp_descr_set */
     0,                         /* tp_dictoffset */
-    (initproc)PythonQtMetaObjectWrapper_init,      /* tp_init */
+    (initproc)PythonQtClassWrapper_init,      /* tp_init */
     0,                         /* tp_alloc */
-    PythonQtMetaObjectWrapper_new,                 /* tp_new */
+    PythonQtClassWrapper_new,                 /* tp_new */
 };
 
 //-------------------------------------------------------
diff --git a/src/PythonQtMetaObjectWrapper.h b/src/PythonQtClassWrapper.h
similarity index 95%
rename from src/PythonQtMetaObjectWrapper.h
rename to src/PythonQtClassWrapper.h
index fe95cc7..6b5d410 100644
--- a/src/PythonQtMetaObjectWrapper.h
+++ b/src/PythonQtClassWrapper.h
@@ -35,7 +35,7 @@
 
 //----------------------------------------------------------------------------------
 /*!
-// \file    PythonQtMetaObjectWrapper.h
+// \file    PythonQtClassWrapper.h
 // \author  Florian Link
 // \author  Last changed by $Author: florian $
 // \date    2006-05
@@ -54,7 +54,7 @@ class PythonQtClassInfo;
 class QObject;
 struct QMetaObject;
 
-extern PyTypeObject PythonQtMetaObjectWrapper_Type;
+extern PyTypeObject PythonQtClassWrapper_Type;
 
 //---------------------------------------------------------------
 //! a Python wrapper object for Qt meta objects
@@ -64,7 +64,7 @@ typedef struct {
   //! the class information (which contains the meta object as well)
   PythonQtClassInfo* _info;
 
-} PythonQtMetaObjectWrapper;
+} PythonQtClassWrapper;
 
 //---------------------------------------------------------------
 // an abstact class for handling construction of objects
diff --git a/src/PythonQtConversion.cpp b/src/PythonQtConversion.cpp
index 35e0de4..61472c4 100644
--- a/src/PythonQtConversion.cpp
+++ b/src/PythonQtConversion.cpp
@@ -159,7 +159,7 @@ PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, const void* dat
         // if the type is known, we can construct it via QMetaType::construct
         void* newCPPObject = QMetaType::construct(type, data);
         // XXX this could be optimized by using metatypeid directly
-        PythonQtWrapper* wrap = (PythonQtWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
+        PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
         wrap->_ownedByPythonQt = true;
         wrap->_useQMetaTypeDestroy = true;
         return (PyObject*)wrap;
@@ -224,12 +224,12 @@ return Py_None;
  {
    bool ok;
    void* ptr = NULL;
-   if (obj->ob_type == &PythonQtWrapper_Type && info.typeId != PythonQtMethodInfo::Variant) {
+   if (obj->ob_type == &PythonQtInstanceWrapper_Type && info.typeId != PythonQtMethodInfo::Variant) {
      // if we have a Qt wrapper object and if we do not need a QVariant, we do the following:
      // (the Variant case is handled below in a switch)
  
      // a C++ wrapper (can be passed as pointer or reference)
-     PythonQtWrapper* wrap = (PythonQtWrapper*)obj;
+     PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)obj;
      if (wrap->_info->inherits(info.name)) {
        void* object;
        if (wrap->_info->isCPPWrapper()) {
@@ -690,8 +690,8 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       type = QVariant::Double;
     } else if (val == Py_False || val == Py_True) {
       type = QVariant::Bool;
-    } else if (val->ob_type == &PythonQtWrapper_Type) {
-      PythonQtWrapper* wrap = (PythonQtWrapper*)val;
+    } else if (val->ob_type == &PythonQtInstanceWrapper_Type) {
+      PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
       // c++ wrapper, check if the class names of the c++ objects match
       if (wrap->_info->isCPPWrapper()) {
         if (wrap->_info->metaTypeId()>0) {
@@ -849,8 +849,8 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
     break;
     
   default:
-    if (val->ob_type == &PythonQtWrapper_Type) {
-      PythonQtWrapper* wrap = (PythonQtWrapper*)val;
+    if (val->ob_type == &PythonQtInstanceWrapper_Type) {
+      PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
       if (wrap->_info->isCPPWrapper() && wrap->_info->metaTypeId() == type) {
         // construct a new variant from the C++ object if it has the same meta type
         v = QVariant(type, wrap->_wrappedPtr);
@@ -956,8 +956,8 @@ bool PythonQtConv::ConvertPythonListToQListOfPointerType(PyObject* obj, QList<vo
     PyObject* value;
     for (int i = 0;i<count;i++) {
       value = PySequence_GetItem(obj,i);
-      if (value->ob_type == &PythonQtWrapper_Type) {
-        PythonQtWrapper* wrap = (PythonQtWrapper*)value;
+      if (value->ob_type == &PythonQtInstanceWrapper_Type) {
+        PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)value;
         // both QObjects and CPP wrappers support inherits, so we use that to check of we match
         if (wrap->_info->inherits(type)) {
           if (wrap->_info->isCPPWrapper()) {
diff --git a/src/PythonQtWrapper.cpp b/src/PythonQtInstanceWrapper.cpp
similarity index 75%
rename from src/PythonQtWrapper.cpp
rename to src/PythonQtInstanceWrapper.cpp
index ce17101..334fe26 100644
--- a/src/PythonQtWrapper.cpp
+++ b/src/PythonQtInstanceWrapper.cpp
@@ -32,21 +32,21 @@
 
 //----------------------------------------------------------------------------------
 /*!
-// \file    PythonQtWrapper.cpp
+// \file    PythonQtInstanceWrapper.cpp
 // \author  Florian Link
 // \author  Last changed by $Author: florian $
 // \date    2006-05
 */
 //----------------------------------------------------------------------------------
 
-#include "PythonQtWrapper.h"
+#include "PythonQtInstanceWrapper.h"
 #include <QObject>
 #include "PythonQt.h"
 #include "PythonQtSlot.h"
 #include "PythonQtClassInfo.h"
 #include "PythonQtConversion.h"
 
-static void PythonQtWrapper_deleteObject(PythonQtWrapper* self, bool force = false) {
+static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
   
   // is this a C++ wrapper?
   if (self->_wrappedPtr) {
@@ -100,18 +100,18 @@ static void PythonQtWrapper_deleteObject(PythonQtWrapper* self, bool force = fal
   self->_obj = NULL;
 }
 
-static void PythonQtWrapper_dealloc(PythonQtWrapper* self)
+static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
 {
-  PythonQtWrapper_deleteObject(self);
+  PythonQtInstanceWrapper_deleteObject(self);
   self->_obj.~QPointer<QObject>();
   self->ob_type->tp_free((PyObject*)self);
 }
 
-static PyObject* PythonQtWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
+static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
 {
-  PythonQtWrapper *self;
+  PythonQtInstanceWrapper *self;
 
-  self = (PythonQtWrapper *)type->tp_alloc(type, 0);
+  self = (PythonQtInstanceWrapper *)type->tp_alloc(type, 0);
   if (self != NULL) {
     self->_info = NULL;
     new (&self->_obj) QPointer<QObject>();
@@ -122,54 +122,54 @@ static PyObject* PythonQtWrapper_new(PyTypeObject *type, PyObject * /*args*/, Py
   return (PyObject *)self;
 }
 
-static int PythonQtWrapper_init(PythonQtWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
+static int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
 {
   return 0;
 }
 
-static PyObject *PythonQtWrapper_classname(PythonQtWrapper* type)
+static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* type)
 {
   return PyString_FromString(type->_info->className());
 }
 
-static PyObject *PythonQtWrapper_help(PythonQtWrapper* type)
+static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* type)
 {
   return PythonQt::self()->helpCalled(type->_info);
 }
 
-static PyObject *PythonQtWrapper_delete(PythonQtWrapper * self)
+static PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
 {
-  PythonQtWrapper_deleteObject(self, true);
+  PythonQtInstanceWrapper_deleteObject(self, true);
   Py_INCREF(Py_None);
   return Py_None;
 }
 
 
-static PyMethodDef PythonQtWrapper_methods[] = {
-    {"className", (PyCFunction)PythonQtWrapper_classname, METH_NOARGS,
+static PyMethodDef PythonQtInstanceWrapper_methods[] = {
+    {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
      "Return the classname of the object"
     },
-    {"help", (PyCFunction)PythonQtWrapper_help, METH_NOARGS,
+    {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
     "Shows the help of available methods for this class"
     },
-    {"delete", (PyCFunction)PythonQtWrapper_delete, METH_NOARGS,
+    {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
     "Deletes the C++ object (at your own risk, my friend!)"
     },
 {NULL, NULL, 0, NULL}  /* Sentinel */
 };
 
 
-static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
+static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
 {
   const char *attributeName;
-  PythonQtWrapper *wt = (PythonQtWrapper *)obj;
+  PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
 
   if ((attributeName = PyString_AsString(name)) == NULL) {
     return NULL;
   }
 
-  if (!wt->_obj && !wt->_wrappedPtr) {
-    QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wt->_info->className() + " object";
+  if (!wrapper->_obj && !wrapper->_wrappedPtr) {
+    QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->_info->className() + " object";
     PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
     return NULL;
   }
@@ -178,11 +178,11 @@ static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
 
   // TODO: dynamic properties are missing
 
-  PythonQtMemberInfo member = wt->_info->member(attributeName);
+  PythonQtMemberInfo member = wrapper->_info->member(attributeName);
   switch (member._type) {
   case PythonQtMemberInfo::Property:
-    if (wt->_obj) {
-      return PythonQtConv::QVariantToPyObject(member._property.read(wt->_obj));
+    if (wrapper->_obj) {
+      return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
     }
     break;
   case PythonQtMemberInfo::Slot:
@@ -197,15 +197,15 @@ static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
   }
 
   // look for the interal methods (className(), help())
-  PyObject* internalMethod = Py_FindMethod( PythonQtWrapper_methods, obj, (char*)attributeName);
+  PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
   if (internalMethod) {
     return internalMethod;
   }
   PyErr_Clear();
 
-  if (wt->_obj) {
+  if (wrapper->_obj) {
     // look for a child
-    QObjectList children = wt->_obj->children();
+    QObjectList children = wrapper->_obj->children();
     for (int i = 0; i < children.count(); i++) {
       QObject *child = children.at(i);
       if (child->objectName() == attributeName) {
@@ -215,7 +215,7 @@ static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
   }
 
   if (qstrcmp(attributeName, "__dict__")==0) {
-    QStringList l = wt->_info->memberList(false);
+    QStringList l = wrapper->_info->memberList(false);
     PyObject* dict = PyDict_New();
     foreach (QString name, l) {
       //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
@@ -227,27 +227,27 @@ static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
   }
 
 
-  QString error = QString(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
+  QString error = QString(wrapper->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
   PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
   return NULL;
 }
 
-static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
+static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
 {
   QString error;
   char *attributeName;
-  PythonQtWrapper *wt = (PythonQtWrapper *)obj;
+  PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
 
   if ((attributeName = PyString_AsString(name)) == NULL)
     return -1;
 
-  if (!wt->_obj) {
-    error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wt->_info->className() + " object";
+  if (!wrapper->_obj) {
+    error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wrapper->_info->className() + " object";
     PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
     return -1;
   }
 
-  PythonQtMemberInfo member = wt->_info->member(attributeName);
+  PythonQtMemberInfo member = wrapper->_info->member(attributeName);
   if (member._type == PythonQtMemberInfo::Property) {
     QMetaProperty prop = member._property;
     if (prop.isWritable()) {
@@ -261,7 +261,7 @@ static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value
       }
       bool success = false;
       if (v.isValid()) {
-        success = prop.write(wt->_obj, v);
+        success = prop.write(wrapper->_obj, v);
       }
       if (success) {
         return 0;
@@ -271,13 +271,13 @@ static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value
           + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
       }
     } else {
-      error = QString("Property '") + attributeName + "' of " + wt->_info->className() + " object is not writable";
+      error = QString("Property '") + attributeName + "' of " + wrapper->_info->className() + " object is not writable";
     }
   } else {
     if (member._type == PythonQtMemberInfo::Slot) {
-      error = QString("Slot '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
+      error = QString("Slot '") + attributeName + "' can not be overwritten on " + wrapper->_info->className() + " object";
     } else if (member._type == PythonQtMemberInfo::EnumValue) {
-      error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
+      error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wrapper->_info->className() + " object";
     }
   }
 
@@ -285,51 +285,51 @@ static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value
   return -1;
 }
 
-static PyObject * PythonQtWrapper_str(PyObject * obj)
+static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
 {
-  PythonQtWrapper* wt = (PythonQtWrapper*)obj;
-  QObject *qobj = wt->_obj;
-  if (wt->_wrappedPtr) {
-    QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_wrappedPtr);
+  PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
+  QObject *qobj = wrapper->_obj;
+  if (wrapper->_wrappedPtr) {
+    QString str = PythonQtConv::CPPObjectToString(wrapper->_info->metaTypeId(), wrapper->_wrappedPtr);
     if (!str.isEmpty()) {
       return PyString_FromFormat("%s", str.toLatin1().constData());
     } else
-    if (wt->_obj) {
-      return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
+    if (wrapper->_obj) {
+      return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->_info->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
     } else {
-      return PyString_FromFormat("%s (C++ Object %p)", wt->_info->className(), wt->_wrappedPtr);
+      return PyString_FromFormat("%s (C++ Object %p)", wrapper->_info->className(), wrapper->_wrappedPtr);
     }
   } else {
-    return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
+    return PyString_FromFormat("%s (QObject %p)", wrapper->_info->className(), qobj);
   }
 }
 
-static PyObject * PythonQtWrapper_repr(PyObject * obj)
+static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
 {
-  PythonQtWrapper* wt = (PythonQtWrapper*)obj;
-  QObject *qobj = wt->_obj;
-  if (wt->_wrappedPtr) {
-    QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_wrappedPtr);
+  PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
+  QObject *qobj = wrapper->_obj;
+  if (wrapper->_wrappedPtr) {
+    QString str = PythonQtConv::CPPObjectToString(wrapper->_info->metaTypeId(), wrapper->_wrappedPtr);
     if (!str.isEmpty()) {
-      return PyString_FromFormat("%s(%s, %p)", QMetaType::typeName(wt->_info->metaTypeId()), str.toLatin1().constData(), wt->_wrappedPtr);
+      return PyString_FromFormat("%s(%s, %p)", QMetaType::typeName(wrapper->_info->metaTypeId()), str.toLatin1().constData(), wrapper->_wrappedPtr);
     } else
-    if (wt->_obj) {
-      return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
+    if (wrapper->_obj) {
+      return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->_info->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
     } else {
-      return PyString_FromFormat("%s (C++ Object %p)", wt->_info->className(), wt->_wrappedPtr);
+      return PyString_FromFormat("%s (C++ Object %p)", wrapper->_info->className(), wrapper->_wrappedPtr);
     }
   } else {
-    return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
+    return PyString_FromFormat("%s (QObject %p)", wrapper->_info->className(), qobj);
   }
 }
 
-static int PythonQtWrapper_compare(PyObject * obj1, PyObject * obj2)
+static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2)
 {
-  if (obj1->ob_type == &PythonQtWrapper_Type &&
-    obj2->ob_type == &PythonQtWrapper_Type) {
+  if (obj1->ob_type == &PythonQtInstanceWrapper_Type &&
+    obj2->ob_type == &PythonQtInstanceWrapper_Type) {
 
-    PythonQtWrapper* w1 = (PythonQtWrapper*)obj1;
-    PythonQtWrapper* w2 = (PythonQtWrapper*)obj2;
+    PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
+    PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
     // check pointers directly first:
     if (w1->_wrappedPtr != NULL) {
       if (w1->_wrappedPtr == w2->_wrappedPtr) {
@@ -378,14 +378,14 @@ static int PythonQtWrapper_compare(PyObject * obj1, PyObject * obj2)
   return -1;
 }
 
-static int PythonQtWrapper_nonzero(PyObject *obj)
+static int PythonQtInstanceWrapper_nonzero(PyObject *obj)
 {
-  PythonQtWrapper* wt = (PythonQtWrapper*)obj;
-  return (wt->_wrappedPtr == NULL && wt->_obj == NULL)?0:1;
+  PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
+  return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
 }
 
 
-static long PythonQtWrapper_hash(PythonQtWrapper *obj)
+static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
 {
   if (obj->_wrappedPtr != NULL) {
     return reinterpret_cast<long>(obj->_wrappedPtr);
@@ -398,7 +398,7 @@ static long PythonQtWrapper_hash(PythonQtWrapper *obj)
 
 
 // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
-static PyNumberMethods PythonQtWrapper_as_number = {
+static PyNumberMethods PythonQtInstanceWrapper_as_number = {
   0,      /* nb_add */
     0,      /* nb_subtract */
     0,      /* nb_multiply */
@@ -409,7 +409,7 @@ static PyNumberMethods PythonQtWrapper_as_number = {
     0,      /* nb_negative */
     0,      /* nb_positive */
     0,      /* nb_absolute */
-    PythonQtWrapper_nonzero,      /* nb_nonzero */
+    PythonQtInstanceWrapper_nonzero,      /* nb_nonzero */
     0,      /* nb_invert */
     0,      /* nb_lshift */
     0,      /* nb_rshift */
@@ -439,29 +439,29 @@ static PyNumberMethods PythonQtWrapper_as_number = {
     0,      /* nb_inplace_true_divide */
 };
 
-PyTypeObject PythonQtWrapper_Type = {
+PyTypeObject PythonQtInstanceWrapper_Type = {
   PyObject_HEAD_INIT(NULL)
     0,                         /*ob_size*/
-    "PythonQt.PythonQtWrapper",             /*tp_name*/
-    sizeof(PythonQtWrapper),             /*tp_basicsize*/
+    "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
+    sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
     0,                         /*tp_itemsize*/
-    (destructor)PythonQtWrapper_dealloc, /*tp_dealloc*/
+    (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
     0,                         /*tp_print*/
     0,                         /*tp_getattr*/
     0,                         /*tp_setattr*/
-    PythonQtWrapper_compare,         /*tp_compare*/
-    PythonQtWrapper_repr,            /*tp_repr*/
-    &PythonQtWrapper_as_number,                         /*tp_as_number*/
+    PythonQtInstanceWrapper_compare,         /*tp_compare*/
+    PythonQtInstanceWrapper_repr,            /*tp_repr*/
+    &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
     0,                         /*tp_as_sequence*/
     0,                         /*tp_as_mapping*/
-    (hashfunc)PythonQtWrapper_hash,                         /*tp_hash */
+    (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
     0,                         /*tp_call*/
-    PythonQtWrapper_str,      /*tp_str*/
-    PythonQtWrapper_getattro,                         /*tp_getattro*/
-    PythonQtWrapper_setattro,                         /*tp_setattro*/
+    PythonQtInstanceWrapper_str,      /*tp_str*/
+    PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
+    PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
     0,                         /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
-    "PythonQtWrapper object",           /* tp_doc */
+    "PythonQtInstanceWrapper object",           /* tp_doc */
     0,                   /* tp_traverse */
     0,                   /* tp_clear */
     0,                   /* tp_richcompare */
@@ -476,9 +476,9 @@ PyTypeObject PythonQtWrapper_Type = {
     0,                         /* tp_descr_get */
     0,                         /* tp_descr_set */
     0,                         /* tp_dictoffset */
-    (initproc)PythonQtWrapper_init,      /* tp_init */
+    (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
     0,                         /* tp_alloc */
-    PythonQtWrapper_new,                 /* tp_new */
+    PythonQtInstanceWrapper_new,                 /* tp_new */
 };
 
 //-------------------------------------------------------
diff --git a/src/PythonQtWrapper.h b/src/PythonQtInstanceWrapper.h
similarity index 96%
rename from src/PythonQtWrapper.h
rename to src/PythonQtInstanceWrapper.h
index 725c40e..e7a37bc 100644
--- a/src/PythonQtWrapper.h
+++ b/src/PythonQtInstanceWrapper.h
@@ -35,7 +35,7 @@
 
 //----------------------------------------------------------------------------------
 /*!
-// \file    PythonQtWrapper.h
+// \file    PythonQtInstanceWrapper.h
 // \author  Florian Link
 // \author  Last changed by $Author: florian $
 // \date    2006-05
@@ -55,7 +55,7 @@
 class PythonQtClassInfo;
 class QObject;
 
-extern PYTHONQT_EXPORT PyTypeObject PythonQtWrapper_Type;
+extern PYTHONQT_EXPORT PyTypeObject PythonQtInstanceWrapper_Type;
 
 //---------------------------------------------------------------
 //! a Python wrapper object for Qt objects and C++ objects (that are themselves wrapped by wrapper QObjects)
@@ -86,7 +86,7 @@ typedef struct {
   //! stores that the owned object should be destroyed using QMetaType::destroy()
   bool _useQMetaTypeDestroy;
   
-} PythonQtWrapper;
+} PythonQtInstanceWrapper;
 
 
 #endif
\ No newline at end of file
diff --git a/src/PythonQtSlot.cpp b/src/PythonQtSlot.cpp
index b14fa73..2f30039 100644
--- a/src/PythonQtSlot.cpp
+++ b/src/PythonQtSlot.cpp
@@ -41,7 +41,7 @@
 
 #include "PythonQt.h"
 #include "PythonQtSlot.h"
-#include "PythonQtWrapper.h"
+#include "PythonQtInstanceWrapper.h"
 #include "PythonQtClassInfo.h"
 #include "PythonQtMisc.h"
 #include "PythonQtConversion.h"
@@ -159,10 +159,10 @@ PyObject *PythonQtSlotFunction_Call(PyObject *func, PyObject *args, PyObject *kw
 {
   PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
   PythonQtSlotInfo*    info = f->m_ml;
-  if (f->m_self->ob_type == &PythonQtWrapper_Type) {
-    PythonQtWrapper* self = (PythonQtWrapper*) f->m_self;
+  if (f->m_self->ob_type == &PythonQtInstanceWrapper_Type) {
+    PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
     return PythonQtSlotFunction_CallImpl(self->_obj, info, args, kw, self->_wrappedPtr);
-  } else if (f->m_self->ob_type == &PythonQtMetaObjectWrapper_Type) {
+  } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
     return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
   } else {
     return NULL;
diff --git a/src/src.pri b/src/src.pri
index 446a83f..e4a7149 100644
--- a/src/src.pri
+++ b/src/src.pri
@@ -13,8 +13,8 @@ HEADERS +=                    \
   $$PWD/PythonQtImportFileInterface.h \
   $$PWD/PythonQtConversion.h        \
   $$PWD/PythonQtSignalReceiver.h    \
-  $$PWD/PythonQtWrapper.h           \
-  $$PWD/PythonQtMetaObjectWrapper.h \
+  $$PWD/PythonQtInstanceWrapper.h   \
+  $$PWD/PythonQtClassWrapper.h \
   $$PWD/PythonQtCppWrapperFactory.h \
   $$PWD/PythonQtVariants.h          \
   $$PWD/PythonQtQFileImporter.h     \
@@ -71,9 +71,9 @@ SOURCES +=                    \
   $$PWD/PythonQtConversion.cpp      \
   $$PWD/PythonQtSignalReceiver.cpp  \
   $$PWD/PythonQtVariants.cpp        \
-  $$PWD/PythonQtWrapper.cpp         \
-  $$PWD/PythonQtQFileImporter.cpp    \
-  $$PWD/PythonQtMetaObjectWrapper.cpp \
+  $$PWD/PythonQtInstanceWrapper.cpp \
+  $$PWD/PythonQtQFileImporter.cpp   \
+  $$PWD/PythonQtClassWrapper.cpp    \
   $$PWD/gui/PythonQtScriptingConsole.cpp \
   \
   $$PWD/../generated_cpp/com_trolltech_qt_core/PythonQtWrapper_Qt.cpp \
diff --git a/src/src.pro b/src/src.pro
index 404a957..c8e935f 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -11,6 +11,7 @@ TEMPLATE = lib
 DESTDIR    = ../lib
 
 CONFIG += qt dll
+CONFIG -= flat
 
 include ( ../build/common.prf )  
 include ( ../build/python.prf )