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 )