GIT_REPOSITORIES/LPP/PythonQt Commit - r16:c68e0aff542c

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...

florianlink -

r16:c68e0aff542c

parent child

Context file:

r16:c68e0aff542c

Collapse all files

src/PythonQt.cpp +24 -24

               Py_INCREF(&PythonQtSlotFunction_Type);
               // add our own python object types for qt objects
-              if (PyType_Ready(&PythonQtWrapper_Type) < 0) {
+              if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
-                std::cerr << "could not initialize PythonQtWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+                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) {
+              if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
-                std::cerr << "could not initialize PythonQtMetaObjectWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+                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) {
                   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
                 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());
                   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);
                 Py_INCREF(Py_None);
                 return Py_None;
               }
-              PythonQtWrapper* wrap = findWrapperAndRemoveUnused(ptr);
+              PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
               if (!wrap) {
                 PythonQtClassInfo* info = _knownQtClasses.value(name);
                 if (!info) {
                     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
                   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 {
             }
-            PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
+            PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
-              PythonQtWrapper* result;
+              PythonQtInstanceWrapper* result;
-              result = (PythonQtWrapper *)PythonQtWrapper_Type.tp_new(&PythonQtWrapper_Type,
+              result = (PythonQtInstanceWrapper *)PythonQtInstanceWrapper_Type.tp_new(&PythonQtInstanceWrapper_Type,
                 NULL, NULL);
               result->setQObject(obj);
               return result;
             }
-            PythonQtMetaObjectWrapper* PythonQtPrivate::createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info) {
+            PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info) {
-              PythonQtMetaObjectWrapper* result;
+              PythonQtClassWrapper* result;
-              result = (PythonQtMetaObjectWrapper *)PythonQtMetaObjectWrapper_Type.tp_new(&PythonQtMetaObjectWrapper_Type,
+              result = (PythonQtClassWrapper *)PythonQtClassWrapper_Type.tp_new(&PythonQtClassWrapper_Type,
                 NULL, NULL);
               result->_info = info;
               return result;
                       results << info->fullSignature(info->isInstanceDecorator());
                       info = info->nextInfo();
                     }
-                  } else if (object->ob_type == &PythonQtMetaObjectWrapper_Type) {
+                  } else if (object->ob_type == &PythonQtClassWrapper_Type) {
-                    PythonQtMetaObjectWrapper* o = (PythonQtMetaObjectWrapper*)object.object();
+                    PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
                     PythonQtSlotInfo* info = o->_info->constructors();
                     while (info) {
                 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
               _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...

src/PythonQt.h +8 -8

             //----------------------------------------------------------------------------------
             #include "PythonQtSystem.h"
-            #include "PythonQtWrapper.h"
+            #include "PythonQtInstanceWrapper.h"
-            #include "PythonQtMetaObjectWrapper.h"
+            #include "PythonQtClassWrapper.h"
             #include "PythonQtSlot.h"
             #include "PythonQtObjectPtr.h"
             #include <QObject>
               //! 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
+              //! helper method that creates a PythonQtClassWrapper object
-              PythonQtMetaObjectWrapper* createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info);
+              PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info);
-              //! helper method that creates a PythonQtWrapper object and registers it in the object map
+              //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
-              PythonQtWrapper* createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
+              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()); }
               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;

src/PythonQtClassInfo.cpp +3 -5

                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
-                      sigStart += 4 + 1 + strlen(className());
+                      continue;
-                      isClassDeco = true;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
-                      sigStart += 7 + 1 + strlen(className());
+                      continue;
-                      isClassDeco = true;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
               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++) {

src/PythonQtClassWrapper.cpp ~~src/PythonQtMetaObjectWrapper.cpp~~ renamed +48 -48

             //----------------------------------------------------------------------------------
             /*!
-            // \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"
             #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) {
+            PyObject *PythonQtClassWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
-              PythonQtMetaObjectWrapper* wrapper = (PythonQtMetaObjectWrapper*)func;
+              PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)func;
               PyObject* result = NULL;
               QString error;
               PyObject* err = NULL;
               }
               if (result) {
                 // change ownershipflag to be owned by PythonQt
-                if (result->ob_type == &PythonQtWrapper_Type) {
+                if (result->ob_type == &PythonQtInstanceWrapper_Type) {
-                  ((PythonQtWrapper*)result)->_ownedByPythonQt = true;
+                  ((PythonQtInstanceWrapper*)result)->_ownedByPythonQt = true;
                 }
               } else {
                 if (!wrapper->_info->constructors()) {
               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[] = {
+            static PyMethodDef PythonQtClassWrapper_methods[] = {
-                {"className", (PyCFunction)PythonQtMetaObjectWrapper_classname, METH_NOARGS,
+                {"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);
               }
               }
               // 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());
                 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;
+              PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
-              if (wt->_info->isCPPWrapper()) {
+              if (wrapper->_info->isCPPWrapper()) {
-                const QMetaObject* meta = wt->_info->metaObject();
+                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 &&
+              if (obj1->ob_type == &PythonQtClassWrapper_Type &&
-                obj2->ob_type == &PythonQtMetaObjectWrapper_Type) {
+                obj2->ob_type == &PythonQtClassWrapper_Type) {
-                PythonQtMetaObjectWrapper* w1 = (PythonQtMetaObjectWrapper*)obj1;
+                PythonQtClassWrapper* w1 = (PythonQtClassWrapper*)obj1;
-                PythonQtMetaObjectWrapper* w2 = (PythonQtMetaObjectWrapper*)obj2;
+                PythonQtClassWrapper* w2 = (PythonQtClassWrapper*)obj2;
                 if (w1->_info == w2->_info) {
                   return 0;
                 } else {
               }
             }
-            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)
 ,                         /*ob_size*/
-                "PythonQt.PythonQtMetaObjectWrapper",             /*tp_name*/
+                "PythonQt.PythonQtClassWrapper",             /*tp_name*/
-                sizeof(PythonQtMetaObjectWrapper),             /*tp_basicsize*/
+                sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
-                (destructor)PythonQtMetaObjectWrapper_dealloc, /*tp_dealloc*/
+                (destructor)PythonQtClassWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
-                PythonQtMetaObjectWrapper_compare,         /*tp_compare*/
+                PythonQtClassWrapper_compare,         /*tp_compare*/
-                PythonQtMetaObjectWrapper_repr,            /*tp_repr*/
+                PythonQtClassWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
-                (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
+                (hashfunc)PythonQtClassWrapper_hash,                         /*tp_hash */
-                PythonQtMetaObjectWrapper_call,                         /*tp_call*/
+                PythonQtClassWrapper_call,                         /*tp_call*/
 ,                         /*tp_str*/
-                PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/
+                PythonQtClassWrapper_getattro,                         /*tp_getattro*/
 ,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
-                "PythonQtMetaObjectWrapper object",           /* tp_doc */
+                "PythonQtClassWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
-                (initproc)PythonQtMetaObjectWrapper_init,      /* tp_init */
+                (initproc)PythonQtClassWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
-                PythonQtMetaObjectWrapper_new,                 /* tp_new */
+                PythonQtClassWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtClassWrapper.h ~~src/PythonQtMetaObjectWrapper.h~~ renamed +3 -3

             //----------------------------------------------------------------------------------
             /*!
-            // \file    PythonQtMetaObjectWrapper.h
+            // \file    PythonQtClassWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             class QObject;
             struct QMetaObject;
-            extern PyTypeObject PythonQtMetaObjectWrapper_Type;
+            extern PyTypeObject PythonQtClassWrapper_Type;
             //---------------------------------------------------------------
             //! a Python wrapper object for Qt meta objects
               //! the class information (which contains the meta object as well)
               PythonQtClassInfo* _info;
-            } PythonQtMetaObjectWrapper;
+            } PythonQtClassWrapper;
             //---------------------------------------------------------------
             // an abstact class for handling construction of objects

src/PythonQtConversion.cpp +9 -9

                     // 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;
              {
                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()) {
                   type = QVariant::Double;
                 } else if (val == Py_False || val == Py_True) {
                   type = QVariant::Bool;
-                } else if (val->ob_type == &PythonQtWrapper_Type) {
+                } else if (val->ob_type == &PythonQtInstanceWrapper_Type) {
-                  PythonQtWrapper* wrap = (PythonQtWrapper*)val;
+                  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) {
                 break;
               default:
-                if (val->ob_type == &PythonQtWrapper_Type) {
+                if (val->ob_type == &PythonQtInstanceWrapper_Type) {
-                  PythonQtWrapper* wrap = (PythonQtWrapper*)val;
+                  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);
                 PyObject* value;
                 for (int i = 0;i<count;i++) {
                   value = PySequence_GetItem(obj,i);
-                  if (value->ob_type == &PythonQtWrapper_Type) {
+                  if (value->ob_type == &PythonQtInstanceWrapper_Type) {
-                    PythonQtWrapper* wrap = (PythonQtWrapper*)value;
+                    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()) {

src/PythonQtInstanceWrapper.cpp ~~src/PythonQtWrapper.cpp~~ renamed +82 -82

             //----------------------------------------------------------------------------------
             /*!
-            // \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) {
               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>();
               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[] = {
+            static PyMethodDef PythonQtInstanceWrapper_methods[] = {
-                {"className", (PyCFunction)PythonQtWrapper_classname, METH_NOARGS,
+                {"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) {
+              if (!wrapper->_obj && !wrapper->_wrappedPtr) {
-                QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wt->_info->className() + " object";
+                QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->_info->className() + " object";
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return NULL;
               }
               // 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) {
+                if (wrapper->_obj) {
-                  return PythonQtConv::QVariantToPyObject(member._property.read(wt->_obj));
+                  return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                 }
                 break;
               case PythonQtMemberInfo::Slot:
               }
               // 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) {
               }
               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());
               }
-              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) {
+              if (!wrapper->_obj) {
-                error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wt->_info->className() + " object";
+                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()) {
                   }
                   bool success = false;
                   if (v.isValid()) {
-                    success = prop.write(wt->_obj, v);
+                    success = prop.write(wrapper->_obj, v);
                   }
                   if (success) {
                     return 0;
                       + 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";
                 }
               }
               return -1;
             }
-            static PyObject * PythonQtWrapper_str(PyObject * obj)
+            static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
-              PythonQtWrapper* wt = (PythonQtWrapper*)obj;
+              PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
-              QObject *qobj = wt->_obj;
+              QObject *qobj = wrapper->_obj;
-              if (wt->_wrappedPtr) {
+              if (wrapper->_wrappedPtr) {
-                QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_wrappedPtr);
+                QString str = PythonQtConv::CPPObjectToString(wrapper->_info->metaTypeId(), wrapper->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else
-                if (wt->_obj) {
+                if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
+                  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;
+              PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
-              QObject *qobj = wt->_obj;
+              QObject *qobj = wrapper->_obj;
-              if (wt->_wrappedPtr) {
+              if (wrapper->_wrappedPtr) {
-                QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_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) {
+                if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
+                  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 &&
+              if (obj1->ob_type == &PythonQtInstanceWrapper_Type &&
-                obj2->ob_type == &PythonQtWrapper_Type) {
+                obj2->ob_type == &PythonQtInstanceWrapper_Type) {
-                PythonQtWrapper* w1 = (PythonQtWrapper*)obj1;
+                PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
-                PythonQtWrapper* w2 = (PythonQtWrapper*)obj2;
+                PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
                 // check pointers directly first:
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w2->_wrappedPtr) {
               return -1;
             }
-            static int PythonQtWrapper_nonzero(PyObject *obj)
+            static int PythonQtInstanceWrapper_nonzero(PyObject *obj)
             {
-              PythonQtWrapper* wt = (PythonQtWrapper*)obj;
+              PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
-              return (wt->_wrappedPtr == NULL && wt->_obj == NULL)?0:1;
+              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);
             // 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 = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
-                PythonQtWrapper_nonzero,      /* nb_nonzero */
+                PythonQtInstanceWrapper_nonzero,      /* nb_nonzero */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,      /* nb_inplace_true_divide */
             };
-            PyTypeObject PythonQtWrapper_Type = {
+            PyTypeObject PythonQtInstanceWrapper_Type = {
               PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
-                "PythonQt.PythonQtWrapper",             /*tp_name*/
+                "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
-                sizeof(PythonQtWrapper),             /*tp_basicsize*/
+                sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
-                (destructor)PythonQtWrapper_dealloc, /*tp_dealloc*/
+                (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
-                PythonQtWrapper_compare,         /*tp_compare*/
+                PythonQtInstanceWrapper_compare,         /*tp_compare*/
-                PythonQtWrapper_repr,            /*tp_repr*/
+                PythonQtInstanceWrapper_repr,            /*tp_repr*/
-                &PythonQtWrapper_as_number,                         /*tp_as_number*/
+                &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
-                (hashfunc)PythonQtWrapper_hash,                         /*tp_hash */
+                (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
-                PythonQtWrapper_str,      /*tp_str*/
+                PythonQtInstanceWrapper_str,      /*tp_str*/
-                PythonQtWrapper_getattro,                         /*tp_getattro*/
+                PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
-                PythonQtWrapper_setattro,                         /*tp_setattro*/
+                PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
-                "PythonQtWrapper object",           /* tp_doc */
+                "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
-                (initproc)PythonQtWrapper_init,      /* tp_init */
+                (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
-                PythonQtWrapper_new,                 /* tp_new */
+                PythonQtInstanceWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtInstanceWrapper.h ~~src/PythonQtWrapper.h~~ renamed +3 -3

             //----------------------------------------------------------------------------------
             /*!
-            // \file    PythonQtWrapper.h
+            // \file    PythonQtInstanceWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             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)
               //! stores that the owned object should be destroyed using QMetaType::destroy()
               bool _useQMetaTypeDestroy;
-            } PythonQtWrapper;
+            } PythonQtInstanceWrapper;
             #endif

src/PythonQtSlot.cpp +4 -4

             #include "PythonQt.h"
             #include "PythonQtSlot.h"
-            #include "PythonQtWrapper.h"
+            #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMisc.h"
             #include "PythonQtConversion.h"
             {
               PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
               PythonQtSlotInfo*    info = f->m_ml;
-              if (f->m_self->ob_type == &PythonQtWrapper_Type) {
+              if (f->m_self->ob_type == &PythonQtInstanceWrapper_Type) {
-                PythonQtWrapper* self = (PythonQtWrapper*) f->m_self;
+                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;

src/src.pri +5 -5

               $$PWD/PythonQtImportFileInterface.h \
               $$PWD/PythonQtConversion.h        \
               $$PWD/PythonQtSignalReceiver.h    \
-              $$PWD/PythonQtWrapper.h           \
+              $$PWD/PythonQtInstanceWrapper.h   \
-              $$PWD/PythonQtMetaObjectWrapper.h \
+              $$PWD/PythonQtClassWrapper.h \
               $$PWD/PythonQtCppWrapperFactory.h \
               $$PWD/PythonQtVariants.h          \
               $$PWD/PythonQtQFileImporter.h     \
               $$PWD/PythonQtConversion.cpp      \
               $$PWD/PythonQtSignalReceiver.cpp  \
               $$PWD/PythonQtVariants.cpp        \
-              $$PWD/PythonQtWrapper.cpp         \
+              $$PWD/PythonQtInstanceWrapper.cpp \
-              $$PWD/PythonQtQFileImporter.cpp    \
+              $$PWD/PythonQtQFileImporter.cpp   \
-              $$PWD/PythonQtMetaObjectWrapper.cpp \
+              $$PWD/PythonQtClassWrapper.cpp    \
               $$PWD/gui/PythonQtScriptingConsole.cpp \
               \
               $$PWD/../generated_cpp/com_trolltech_qt_core/PythonQtWrapper_Qt.cpp \

src/src.pro +1 0

             DESTDIR    = ../lib
             CONFIG += qt dll
+            CONFIG -= flat
             include ( ../build/common.prf )
             include ( ../build/python.prf )

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages