[pygi] Apply consistent whitespace formatting with:



commit 1319da5b7f483e48a90b0b7489f77236ba26f479
Author: Tomeu Vizoso <tomeu vizoso collabora co uk>
Date:   Wed May 26 12:19:17 2010 +0200

    Apply consistent whitespace formatting with:
    
    astyle -p -d -c -S -U -M60
    
    This won't affect git blame nor git diff if the switch -w is used.

 gi/gimodule.c           |  138 ++++----
 gi/pygi-argument.c      |  960 +++++++++++++++++++++++-----------------------
 gi/pygi-boxed.c         |  108 +++---
 gi/pygi-callbacks.c     |  154 ++++----
 gi/pygi-callbacks.h     |    8 +-
 gi/pygi-closure.c       |  270 +++++++-------
 gi/pygi-closure.h       |   18 +-
 gi/pygi-foreign-cairo.c |   36 +-
 gi/pygi-foreign-cairo.h |   36 +-
 gi/pygi-foreign.c       |   54 ++--
 gi/pygi-foreign.h       |   10 +-
 gi/pygi-info.c          |  646 ++++++++++++++++----------------
 gi/pygi-invoke.c        |  380 ++++++++++----------
 gi/pygi-repository.c    |  114 +++---
 gi/pygi-struct.c        |   88 +++---
 gi/pygi-type.c          |   32 +-
 gi/pygi.h               |   20 +-
 gi/pygobject-external.h |   14 +-
 18 files changed, 1544 insertions(+), 1542 deletions(-)
---
diff --git a/gi/gimodule.c b/gi/gimodule.c
index e0ea1e8..59601fb 100644
--- a/gi/gimodule.c
+++ b/gi/gimodule.c
@@ -37,18 +37,18 @@ _wrap_pyg_enum_add (PyObject *self,
     PyObject *py_g_type;
     GType g_type;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                "O!:enum_add",
-                kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "O!:enum_add",
+                                      kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
         return NULL;
     }
 
-    g_type = pyg_type_from_object(py_g_type);
+    g_type = pyg_type_from_object (py_g_type);
     if (g_type == G_TYPE_INVALID) {
         return NULL;
     }
 
-    return pyg_enum_add(NULL, g_type_name(g_type), NULL, g_type);
+    return pyg_enum_add (NULL, g_type_name (g_type), NULL, g_type);
 }
 
 static PyObject *
@@ -60,18 +60,18 @@ _wrap_pyg_flags_add (PyObject *self,
     PyObject *py_g_type;
     GType g_type;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                "O!:flags_add",
-                kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "O!:flags_add",
+                                      kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
         return NULL;
     }
 
-    g_type = pyg_type_from_object(py_g_type);
+    g_type = pyg_type_from_object (py_g_type);
     if (g_type == G_TYPE_INVALID) {
         return NULL;
     }
 
-    return pyg_flags_add(NULL, g_type_name(g_type), NULL, g_type);
+    return pyg_flags_add (NULL, g_type_name (g_type), NULL, g_type);
 }
 
 static PyObject *
@@ -83,19 +83,19 @@ _wrap_pyg_set_object_has_new_constructor (PyObject *self,
     PyObject *py_g_type;
     GType g_type;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                "O!:set_object_has_new_constructor",
-                kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "O!:set_object_has_new_constructor",
+                                      kwlist, &PyGTypeWrapper_Type, &py_g_type)) {
         return NULL;
     }
 
-    g_type = pyg_type_from_object(py_g_type);
-    if (!g_type_is_a(g_type, G_TYPE_OBJECT)) {
-        PyErr_SetString(PyExc_TypeError, "must be a subtype of GObject");
+    g_type = pyg_type_from_object (py_g_type);
+    if (!g_type_is_a (g_type, G_TYPE_OBJECT)) {
+        PyErr_SetString (PyExc_TypeError, "must be a subtype of GObject");
         return NULL;
     }
 
-    pyg_set_object_has_new_constructor(g_type);
+    pyg_set_object_has_new_constructor (g_type);
 
     Py_RETURN_NONE;
 }
@@ -107,27 +107,27 @@ initialize_interface (GTypeInterface *iface, PyTypeObject *pytype)
 }
 
 static PyObject *
-_wrap_pyg_register_interface_info(PyObject *self, PyObject *args)
+_wrap_pyg_register_interface_info (PyObject *self, PyObject *args)
 {
     PyObject *py_g_type;
     GType g_type;
     GInterfaceInfo *info;
 
-    if (!PyArg_ParseTuple(args, "O!:register_interface_info",
-                          &PyGTypeWrapper_Type, &py_g_type)) {
+    if (!PyArg_ParseTuple (args, "O!:register_interface_info",
+                           &PyGTypeWrapper_Type, &py_g_type)) {
         return NULL;
     }
 
-    g_type = pyg_type_from_object(py_g_type);
-    if (!g_type_is_a(g_type, G_TYPE_INTERFACE)) {
-        PyErr_SetString(PyExc_TypeError, "must be an interface");
+    g_type = pyg_type_from_object (py_g_type);
+    if (!g_type_is_a (g_type, G_TYPE_INTERFACE)) {
+        PyErr_SetString (PyExc_TypeError, "must be an interface");
         return NULL;
     }
 
-    info = g_new0(GInterfaceInfo, 1);
+    info = g_new0 (GInterfaceInfo, 1);
     info->interface_init = (GInterfaceInitFunc) initialize_interface;
 
-    pyg_register_interface_info(g_type, info);
+    pyg_register_interface_info (g_type, info);
 
     Py_RETURN_NONE;
 }
@@ -149,44 +149,44 @@ _wrap_pyg_hook_up_vfunc_implementation (PyObject *self, PyObject *args)
     gboolean is_interface = FALSE;
     PyGICClosure *closure = NULL;
 
-    if (!PyArg_ParseTuple(args, "O!O!O:hook_up_vfunc_implementation",
-                          &PyGIBaseInfo_Type, &py_info,
-                          &PyGTypeWrapper_Type, &py_type,
-                          &py_function))
+    if (!PyArg_ParseTuple (args, "O!O!O:hook_up_vfunc_implementation",
+                           &PyGIBaseInfo_Type, &py_info,
+                           &PyGTypeWrapper_Type, &py_type,
+                           &py_function))
         return NULL;
 
-    implementor_gtype = pyg_type_from_object(py_type);
-    g_assert(G_TYPE_IS_CLASSED(implementor_gtype));
+    implementor_gtype = pyg_type_from_object (py_type);
+    g_assert (G_TYPE_IS_CLASSED (implementor_gtype));
 
     vfunc_info = py_info->info;
-    ancestor_info = g_base_info_get_container(vfunc_info);
-    is_interface = g_base_info_get_type(ancestor_info) == GI_INFO_TYPE_INTERFACE;
+    ancestor_info = g_base_info_get_container (vfunc_info);
+    is_interface = g_base_info_get_type (ancestor_info) == GI_INFO_TYPE_INTERFACE;
 
-    ancestor_g_type = g_registered_type_info_get_g_type(
-            (GIRegisteredTypeInfo *)ancestor_info);
+    ancestor_g_type = g_registered_type_info_get_g_type (
+                          (GIRegisteredTypeInfo *) ancestor_info);
 
-    implementor_class = g_type_class_ref(implementor_gtype);
+    implementor_class = g_type_class_ref (implementor_gtype);
     if (is_interface) {
         GTypeInstance *implementor_iface_class;
-        implementor_iface_class = g_type_interface_peek(implementor_class,
-                                                        ancestor_g_type);
+        implementor_iface_class = g_type_interface_peek (implementor_class,
+                                                         ancestor_g_type);
         if (implementor_iface_class == NULL) {
             g_type_class_unref (implementor_class);
             PyErr_Format (PyExc_RuntimeError,
-                    "Couldn't find GType of implementor of interface %s. "
-                    "Forgot to set __gtype_name__?",
-                    g_type_name (ancestor_g_type));
+                          "Couldn't find GType of implementor of interface %s. "
+                          "Forgot to set __gtype_name__?",
+                          g_type_name (ancestor_g_type));
             return NULL;
         }
 
         g_type_class_unref (implementor_class);
         implementor_class = implementor_iface_class;
 
-        struct_info = g_interface_info_get_iface_struct ((GIInterfaceInfo*)ancestor_info);
+        struct_info = g_interface_info_get_iface_struct ( (GIInterfaceInfo*) ancestor_info);
     } else
-        struct_info = g_object_info_get_class_struct ((GIObjectInfo*)ancestor_info);
+        struct_info = g_object_info_get_class_struct ( (GIObjectInfo*) ancestor_info);
 
-    length = g_struct_info_get_n_fields(struct_info);
+    length = g_struct_info_get_n_fields (struct_info);
     for (i = 0; i < length; i++) {
         GIFieldInfo *field_info;
         GITypeInfo *type_info;
@@ -196,8 +196,8 @@ _wrap_pyg_hook_up_vfunc_implementation (PyObject *self, PyObject *args)
 
         field_info = g_struct_info_get_field (struct_info, i);
 
-        if (strcmp(g_base_info_get_name((GIBaseInfo*) field_info),
-                   g_base_info_get_name((GIBaseInfo*) vfunc_info)) != 0)
+        if (strcmp (g_base_info_get_name ( (GIBaseInfo*) field_info),
+                    g_base_info_get_name ( (GIBaseInfo*) vfunc_info)) != 0)
             continue;
 
         type_info = g_field_info_get_type (field_info);
@@ -205,14 +205,14 @@ _wrap_pyg_hook_up_vfunc_implementation (PyObject *self, PyObject *args)
             continue;
 
         interface_info = g_type_info_get_interface (type_info);
-        g_assert(g_base_info_get_type(interface_info) == GI_INFO_TYPE_CALLBACK);
+        g_assert (g_base_info_get_type (interface_info) == GI_INFO_TYPE_CALLBACK);
 
         callback_info = (GICallbackInfo*) interface_info;
-        offset = g_field_info_get_offset(field_info);
-        method_ptr = G_STRUCT_MEMBER_P(implementor_class, offset);
+        offset = g_field_info_get_offset (field_info);
+        method_ptr = G_STRUCT_MEMBER_P (implementor_class, offset);
 
-        closure = _pygi_make_native_closure((GICallableInfo*)callback_info,
-            GI_SCOPE_TYPE_NOTIFIED, py_function, NULL);
+        closure = _pygi_make_native_closure ( (GICallableInfo*) callback_info,
+                                              GI_SCOPE_TYPE_NOTIFIED, py_function, NULL);
 
         *method_ptr = closure->closure;
 
@@ -232,20 +232,20 @@ _wrap_pyg_hook_up_vfunc_implementation (PyObject *self, PyObject *args)
 }
 
 static void
-_sink_gobject(GObject *obj)
+_sink_gobject (GObject *obj)
 {
-    if (G_IS_INITIALLY_UNOWNED(obj) || g_object_is_floating(obj)) {
-            g_object_ref_sink(obj);
+    if (G_IS_INITIALLY_UNOWNED (obj) || g_object_is_floating (obj)) {
+        g_object_ref_sink (obj);
     }
 }
 
 static PyMethodDef _pygi_functions[] = {
-    { "enum_add", (PyCFunction)_wrap_pyg_enum_add, METH_VARARGS | METH_KEYWORDS },
-    { "flags_add", (PyCFunction)_wrap_pyg_flags_add, METH_VARARGS | METH_KEYWORDS },
+    { "enum_add", (PyCFunction) _wrap_pyg_enum_add, METH_VARARGS | METH_KEYWORDS },
+    { "flags_add", (PyCFunction) _wrap_pyg_flags_add, METH_VARARGS | METH_KEYWORDS },
 
-    { "set_object_has_new_constructor", (PyCFunction)_wrap_pyg_set_object_has_new_constructor, METH_VARARGS | METH_KEYWORDS },
-    { "register_interface_info", (PyCFunction)_wrap_pyg_register_interface_info, METH_VARARGS },
-    { "hook_up_vfunc_implementation", (PyCFunction)_wrap_pyg_hook_up_vfunc_implementation, METH_VARARGS },
+    { "set_object_has_new_constructor", (PyCFunction) _wrap_pyg_set_object_has_new_constructor, METH_VARARGS | METH_KEYWORDS },
+    { "register_interface_info", (PyCFunction) _wrap_pyg_register_interface_info, METH_VARARGS },
+    { "hook_up_vfunc_implementation", (PyCFunction) _wrap_pyg_hook_up_vfunc_implementation, METH_VARARGS },
     { NULL, NULL, 0 }
 };
 
@@ -255,17 +255,17 @@ struct PyGI_API PyGI_API = {
 
 
 PyMODINIT_FUNC
-init_gi(void)
+init_gi (void)
 {
     PyObject *m;
     PyObject *api;
 
-    m = Py_InitModule("_gi", _pygi_functions);
+    m = Py_InitModule ("_gi", _pygi_functions);
     if (m == NULL) {
         return;
     }
 
-    if (pygobject_init(-1, -1, -1) == NULL) {
+    if (pygobject_init (-1, -1, -1) == NULL) {
         return;
     }
 
@@ -280,18 +280,18 @@ init_gi(void)
     // register our floating object sink while we wait for the pygobject
     // patch to be approved.  Once the patch is in this becomes a noop
     // For more details - https://bugzilla.gnome.org/show_bug.cgi?id=583909
-    pygobject_register_sinkfunc(G_TYPE_OBJECT, _sink_gobject);
+    pygobject_register_sinkfunc (G_TYPE_OBJECT, _sink_gobject);
 
-    _pygi_repository_register_types(m);
-    _pygi_info_register_types(m);
-    _pygi_struct_register_types(m);
-    _pygi_boxed_register_types(m);
+    _pygi_repository_register_types (m);
+    _pygi_info_register_types (m);
+    _pygi_struct_register_types (m);
+    _pygi_boxed_register_types (m);
     _pygi_argument_init();
 
-    api = PyCObject_FromVoidPtr((void *)&PyGI_API, NULL);
+    api = PyCObject_FromVoidPtr ( (void *) &PyGI_API, NULL);
     if (api == NULL) {
         return;
     }
-    PyModule_AddObject(m, "_API", api);
+    PyModule_AddObject (m, "_API", api);
 }
 
diff --git a/gi/pygi-argument.c b/gi/pygi-argument.c
index 4f91fb9..ded5b12 100644
--- a/gi/pygi-argument.c
+++ b/gi/pygi-argument.c
@@ -35,78 +35,78 @@ _pygi_g_type_tag_py_bounds (GITypeTag   type_tag,
                             PyObject  **lower,
                             PyObject  **upper)
 {
-    switch(type_tag) {
+    switch (type_tag) {
         case GI_TYPE_TAG_INT8:
-            *lower = PyInt_FromLong(-128);
-            *upper = PyInt_FromLong(127);
+            *lower = PyInt_FromLong (-128);
+            *upper = PyInt_FromLong (127);
             break;
         case GI_TYPE_TAG_UINT8:
-            *upper = PyInt_FromLong(255);
-            *lower = PyInt_FromLong(0);
+            *upper = PyInt_FromLong (255);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_INT16:
-            *lower = PyInt_FromLong(-32768);
-            *upper = PyInt_FromLong(32767);
+            *lower = PyInt_FromLong (-32768);
+            *upper = PyInt_FromLong (32767);
             break;
         case GI_TYPE_TAG_UINT16:
-            *upper = PyInt_FromLong(65535);
-            *lower = PyInt_FromLong(0);
+            *upper = PyInt_FromLong (65535);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_INT32:
-            *lower = PyInt_FromLong(G_MININT32);
-            *upper = PyInt_FromLong(G_MAXINT32);
+            *lower = PyInt_FromLong (G_MININT32);
+            *upper = PyInt_FromLong (G_MAXINT32);
             break;
         case GI_TYPE_TAG_UINT32:
             /* Note: On 32-bit archs, this number doesn't fit in a long. */
-            *upper = PyLong_FromLongLong(G_MAXUINT32);
-            *lower = PyInt_FromLong(0);
+            *upper = PyLong_FromLongLong (G_MAXUINT32);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_INT64:
             /* Note: On 32-bit archs, these numbers don't fit in a long. */
-            *lower = PyLong_FromLongLong(G_MININT64);
-            *upper = PyLong_FromLongLong(G_MAXINT64);
+            *lower = PyLong_FromLongLong (G_MININT64);
+            *upper = PyLong_FromLongLong (G_MAXINT64);
             break;
         case GI_TYPE_TAG_UINT64:
-            *upper = PyLong_FromUnsignedLongLong(G_MAXUINT64);
-            *lower = PyInt_FromLong(0);
+            *upper = PyLong_FromUnsignedLongLong (G_MAXUINT64);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_SHORT:
-            *lower = PyInt_FromLong(G_MINSHORT);
-            *upper = PyInt_FromLong(G_MAXSHORT);
+            *lower = PyInt_FromLong (G_MINSHORT);
+            *upper = PyInt_FromLong (G_MAXSHORT);
             break;
         case GI_TYPE_TAG_USHORT:
-            *upper = PyInt_FromLong(G_MAXUSHORT);
-            *lower = PyInt_FromLong(0);
+            *upper = PyInt_FromLong (G_MAXUSHORT);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_INT:
-            *lower = PyInt_FromLong(G_MININT);
-            *upper = PyInt_FromLong(G_MAXINT);
+            *lower = PyInt_FromLong (G_MININT);
+            *upper = PyInt_FromLong (G_MAXINT);
             break;
         case GI_TYPE_TAG_UINT:
             /* Note: On 32-bit archs, this number doesn't fit in a long. */
-            *upper = PyLong_FromLongLong(G_MAXUINT);
-            *lower = PyInt_FromLong(0);
+            *upper = PyLong_FromLongLong (G_MAXUINT);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_LONG:
         case GI_TYPE_TAG_SSIZE:
-            *lower = PyInt_FromLong(G_MINLONG);
-            *upper = PyInt_FromLong(G_MAXLONG);
+            *lower = PyInt_FromLong (G_MINLONG);
+            *upper = PyInt_FromLong (G_MAXLONG);
             break;
         case GI_TYPE_TAG_ULONG:
         case GI_TYPE_TAG_SIZE:
-            *upper = PyLong_FromUnsignedLongLong(G_MAXULONG);
-            *lower = PyInt_FromLong(0);
+            *upper = PyLong_FromUnsignedLongLong (G_MAXULONG);
+            *lower = PyInt_FromLong (0);
             break;
         case GI_TYPE_TAG_FLOAT:
-            *upper = PyFloat_FromDouble(G_MAXFLOAT);
-            *lower = PyFloat_FromDouble(-G_MAXFLOAT);
+            *upper = PyFloat_FromDouble (G_MAXFLOAT);
+            *lower = PyFloat_FromDouble (-G_MAXFLOAT);
             break;
         case GI_TYPE_TAG_DOUBLE:
-            *upper = PyFloat_FromDouble(G_MAXDOUBLE);
-            *lower = PyFloat_FromDouble(-G_MAXDOUBLE);
+            *upper = PyFloat_FromDouble (G_MAXDOUBLE);
+            *lower = PyFloat_FromDouble (-G_MAXDOUBLE);
             break;
         default:
-            PyErr_SetString(PyExc_TypeError, "Non-numeric type tag");
+            PyErr_SetString (PyExc_TypeError, "Non-numeric type tag");
             *lower = *upper = NULL;
             return;
     }
@@ -124,47 +124,47 @@ _pygi_g_registered_type_info_check_object (GIRegisteredTypeInfo *info,
     gchar *type_name_expected = NULL;
     GIInfoType interface_type;
 
-    interface_type = g_base_info_get_type(info);
-    if ((interface_type == GI_INFO_TYPE_STRUCT) &&
-            (g_struct_info_is_foreign((GIStructInfo*)info))) {
+    interface_type = g_base_info_get_type (info);
+    if ( (interface_type == GI_INFO_TYPE_STRUCT) &&
+            (g_struct_info_is_foreign ( (GIStructInfo*) info))) {
         /* TODO: Could we check is the correct foreign type? */
         return 1;
     }
 
-    g_type = g_registered_type_info_get_g_type(info);
+    g_type = g_registered_type_info_get_g_type (info);
     if (g_type != G_TYPE_NONE) {
-        py_type = _pygi_type_get_from_g_type(g_type);
+        py_type = _pygi_type_get_from_g_type (g_type);
     } else {
-        py_type = _pygi_type_import_by_gi_info((GIBaseInfo *)info);
+        py_type = _pygi_type_import_by_gi_info ( (GIBaseInfo *) info);
     }
 
     if (py_type == NULL) {
         return 0;
     }
 
-    g_assert(PyType_Check(py_type));
+    g_assert (PyType_Check (py_type));
 
     if (is_instance) {
-        retval = PyObject_IsInstance(object, py_type);
+        retval = PyObject_IsInstance (object, py_type);
         if (!retval) {
-            type_name_expected = _pygi_g_base_info_get_fullname(
-                    (GIBaseInfo *)info);
+            type_name_expected = _pygi_g_base_info_get_fullname (
+                                     (GIBaseInfo *) info);
         }
     } else {
-        if (!PyObject_Type(py_type)) {
+        if (!PyObject_Type (py_type)) {
             type_name_expected = "type";
             retval = 0;
-        } else if (!PyType_IsSubtype((PyTypeObject *)object,
-                (PyTypeObject *)py_type)) {
-            type_name_expected = _pygi_g_base_info_get_fullname(
-                    (GIBaseInfo *)info);
+        } else if (!PyType_IsSubtype ( (PyTypeObject *) object,
+                                       (PyTypeObject *) py_type)) {
+            type_name_expected = _pygi_g_base_info_get_fullname (
+                                     (GIBaseInfo *) info);
             retval = 0;
         } else {
             retval = 1;
         }
     }
 
-    Py_DECREF(py_type);
+    Py_DECREF (py_type);
 
     if (!retval) {
         PyTypeObject *object_type;
@@ -173,15 +173,15 @@ _pygi_g_registered_type_info_check_object (GIRegisteredTypeInfo *info,
             return -1;
         }
 
-        object_type = (PyTypeObject *)PyObject_Type(object);
+        object_type = (PyTypeObject *) PyObject_Type (object);
         if (object_type == NULL) {
             return -1;
         }
 
-        PyErr_Format(PyExc_TypeError, "Must be %s, not %s",
-            type_name_expected, object_type->tp_name);
+        PyErr_Format (PyExc_TypeError, "Must be %s, not %s",
+                      type_name_expected, object_type->tp_name);
 
-        g_free(type_name_expected);
+        g_free (type_name_expected);
     }
 
     return retval;
@@ -199,7 +199,7 @@ _pygi_g_type_info_check_object (GITypeInfo *type_info,
         return retval;
     }
 
-    type_tag = g_type_info_get_tag(type_info);
+    type_tag = g_type_info_get_tag (type_info);
 
     switch (type_tag) {
         case GI_TYPE_TAG_VOID:
@@ -229,20 +229,20 @@ _pygi_g_type_info_check_object (GITypeInfo *type_info,
         {
             PyObject *number, *lower, *upper;
 
-            if (!PyNumber_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be number, not %s",
-                        object->ob_type->tp_name);
+            if (!PyNumber_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be number, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
                 break;
             }
 
             if (type_tag == GI_TYPE_TAG_FLOAT || type_tag == GI_TYPE_TAG_DOUBLE) {
-                number = PyNumber_Float(object);
+                number = PyNumber_Float (object);
             } else {
-                number = PyNumber_Int(object);
+                number = PyNumber_Int (object);
             }
 
-            _pygi_g_type_tag_py_bounds(type_tag, &lower, &upper);
+            _pygi_g_type_tag_py_bounds (type_tag, &lower, &upper);
 
             if (lower == NULL || upper == NULL || number == NULL) {
                 retval = -1;
@@ -250,8 +250,8 @@ _pygi_g_type_info_check_object (GITypeInfo *type_info,
             }
 
             /* Check bounds */
-            if (PyObject_Compare(lower, number) > 0
-                || PyObject_Compare(upper, number) < 0) {
+            if (PyObject_Compare (lower, number) > 0
+                    || PyObject_Compare (upper, number) < 0) {
                 PyObject *lower_str;
                 PyObject *upper_str;
 
@@ -260,34 +260,34 @@ _pygi_g_type_info_check_object (GITypeInfo *type_info,
                     goto check_number_release;
                 }
 
-                lower_str = PyObject_Str(lower);
-                upper_str = PyObject_Str(upper);
+                lower_str = PyObject_Str (lower);
+                upper_str = PyObject_Str (upper);
                 if (lower_str == NULL || upper_str == NULL) {
                     retval = -1;
                     goto check_number_error_release;
                 }
 
-                PyErr_Format(PyExc_ValueError, "Must range from %s to %s",
-                        PyString_AS_STRING(lower_str),
-                        PyString_AS_STRING(upper_str));
+                PyErr_Format (PyExc_ValueError, "Must range from %s to %s",
+                              PyString_AS_STRING (lower_str),
+                              PyString_AS_STRING (upper_str));
 
                 retval = 0;
 
 check_number_error_release:
-                Py_XDECREF(lower_str);
-                Py_XDECREF(upper_str);
+                Py_XDECREF (lower_str);
+                Py_XDECREF (upper_str);
             }
 
 check_number_release:
-            Py_XDECREF(number);
-            Py_XDECREF(lower);
-            Py_XDECREF(upper);
+            Py_XDECREF (number);
+            Py_XDECREF (lower);
+            Py_XDECREF (upper);
             break;
         }
         case GI_TYPE_TAG_TIME_T:
-            if (!PyDateTime_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be datetime.datetime, not %s",
-                        object->ob_type->tp_name);
+            if (!PyDateTime_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be datetime.datetime, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
             }
             break;
@@ -295,24 +295,24 @@ check_number_release:
         {
             gint is_instance;
 
-            is_instance = PyObject_IsInstance(object, (PyObject *)&PyGTypeWrapper_Type);
+            is_instance = PyObject_IsInstance (object, (PyObject *) &PyGTypeWrapper_Type);
             if (is_instance < 0) {
                 retval = -1;
                 break;
             }
 
-            if (!is_instance && (!PyType_Check(object) || pyg_type_from_object(object) == 0)) {
-                PyErr_Format(PyExc_TypeError, "Must be gobject.GType, not %s",
-                        object->ob_type->tp_name);
+            if (!is_instance && (!PyType_Check (object) || pyg_type_from_object (object) == 0)) {
+                PyErr_Format (PyExc_TypeError, "Must be gobject.GType, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
             }
             break;
         }
         case GI_TYPE_TAG_UTF8:
         case GI_TYPE_TAG_FILENAME:
-            if (!PyString_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be string, not %s",
-                        object->ob_type->tp_name);
+            if (!PyString_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be string, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
             }
             break;
@@ -323,53 +323,53 @@ check_number_release:
             GITypeInfo *item_type_info;
             Py_ssize_t i;
 
-            if (!PySequence_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be sequence, not %s",
-                        object->ob_type->tp_name);
+            if (!PySequence_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
                 break;
             }
 
-            length = PySequence_Length(object);
+            length = PySequence_Length (object);
             if (length < 0) {
                 retval = -1;
                 break;
             }
 
-            fixed_size = g_type_info_get_array_fixed_size(type_info);
+            fixed_size = g_type_info_get_array_fixed_size (type_info);
             if (fixed_size >= 0 && length != fixed_size) {
-                PyErr_Format(PyExc_ValueError, "Must contain %zd items, not %zd",
-                        fixed_size, length);
+                PyErr_Format (PyExc_ValueError, "Must contain %zd items, not %zd",
+                              fixed_size, length);
                 retval = 0;
                 break;
             }
 
-            item_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(item_type_info != NULL);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (item_type_info != NULL);
 
             for (i = 0; i < length; i++) {
                 PyObject *item;
 
-                item = PySequence_GetItem(object, i);
+                item = PySequence_GetItem (object, i);
                 if (item == NULL) {
                     retval = -1;
                     break;
                 }
 
-                retval = _pygi_g_type_info_check_object(item_type_info, item, TRUE);
+                retval = _pygi_g_type_info_check_object (item_type_info, item, TRUE);
 
-                Py_DECREF(item);
+                Py_DECREF (item);
 
                 if (retval < 0) {
                     break;
                 }
                 if (!retval) {
-                    _PyGI_ERROR_PREFIX("Item %zd: ", i);
+                    _PyGI_ERROR_PREFIX ("Item %zd: ", i);
                     break;
                 }
             }
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
 
             break;
         }
@@ -378,59 +378,59 @@ check_number_release:
             GIBaseInfo *info;
             GIInfoType info_type;
 
-            info = g_type_info_get_interface(type_info);
-            g_assert(info != NULL);
+            info = g_type_info_get_interface (type_info);
+            g_assert (info != NULL);
 
-            info_type = g_base_info_get_type(info);
+            info_type = g_base_info_get_type (info);
 
             switch (info_type) {
                 case GI_INFO_TYPE_CALLBACK:
-                    if (!PyCallable_Check(object)) {
-                        PyErr_Format(PyExc_TypeError, "Must be callable, not %s",
-                                object->ob_type->tp_name);
+                    if (!PyCallable_Check (object)) {
+                        PyErr_Format (PyExc_TypeError, "Must be callable, not %s",
+                                      object->ob_type->tp_name);
                         retval = 0;
                     }
                     break;
                 case GI_INFO_TYPE_ENUM:
-                    retval = _pygi_g_registered_type_info_check_object(
-                            (GIRegisteredTypeInfo *)info, TRUE, object);
+                    retval = _pygi_g_registered_type_info_check_object (
+                                 (GIRegisteredTypeInfo *) info, TRUE, object);
                     break;
                 case GI_INFO_TYPE_FLAGS:
-                    if (PyNumber_Check(object)) {
+                    if (PyNumber_Check (object)) {
                         /* Accept 0 as a valid flag value */
-                        PyObject *number = PyNumber_Int(object);
+                        PyObject *number = PyNumber_Int (object);
                         if (number == NULL)
                             PyErr_Clear();
                         else {
-                            long value = PyInt_AsLong(number);
+                            long value = PyInt_AsLong (number);
                             if (value == 0)
                                 break;
                             else if (value == -1)
                                 PyErr_Clear();
                         }
                     }
-                    retval = _pygi_g_registered_type_info_check_object(
-                            (GIRegisteredTypeInfo *)info, TRUE, object);
+                    retval = _pygi_g_registered_type_info_check_object (
+                                 (GIRegisteredTypeInfo *) info, TRUE, object);
                     break;
                 case GI_INFO_TYPE_STRUCT:
                 {
                     GType type;
 
                     /* Handle special cases. */
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
-                    if (g_type_is_a(type, G_TYPE_VALUE)) {
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
+                    if (g_type_is_a (type, G_TYPE_VALUE)) {
                         GType object_type;
-                        object_type = pyg_type_from_object((PyObject *)object->ob_type);
+                        object_type = pyg_type_from_object ( (PyObject *) object->ob_type);
                         if (object_type == G_TYPE_INVALID) {
-                            PyErr_Format(PyExc_TypeError, "Must be of a known GType, not %s",
-                                    object->ob_type->tp_name);
+                            PyErr_Format (PyExc_TypeError, "Must be of a known GType, not %s",
+                                          object->ob_type->tp_name);
                             retval = 0;
                         }
                         break;
-                    } else if (g_type_is_a(type, G_TYPE_CLOSURE)) {
-                        if (!PyCallable_Check(object)) {
-                            PyErr_Format(PyExc_TypeError, "Must be callable, not %s",
-                                    object->ob_type->tp_name);
+                    } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
+                        if (!PyCallable_Check (object)) {
+                            PyErr_Format (PyExc_TypeError, "Must be callable, not %s",
+                                          object->ob_type->tp_name);
                             retval = 0;
                         }
                         break;
@@ -442,13 +442,13 @@ check_number_release:
                 case GI_INFO_TYPE_INTERFACE:
                 case GI_INFO_TYPE_OBJECT:
                 case GI_INFO_TYPE_UNION:
-                    retval = _pygi_g_registered_type_info_check_object((GIRegisteredTypeInfo *)info, TRUE, object);
+                    retval = _pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) info, TRUE, object);
                     break;
                 default:
                     g_assert_not_reached();
             }
 
-            g_base_info_unref(info);
+            g_base_info_unref (info);
             break;
         }
         case GI_TYPE_TAG_GLIST:
@@ -458,45 +458,45 @@ check_number_release:
             GITypeInfo *item_type_info;
             Py_ssize_t i;
 
-            if (!PySequence_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be sequence, not %s",
-                        object->ob_type->tp_name);
+            if (!PySequence_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
                 break;
             }
 
-            length = PySequence_Length(object);
+            length = PySequence_Length (object);
             if (length < 0) {
                 retval = -1;
                 break;
             }
 
-            item_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(item_type_info != NULL);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (item_type_info != NULL);
 
             for (i = 0; i < length; i++) {
                 PyObject *item;
 
-                item = PySequence_GetItem(object, i);
+                item = PySequence_GetItem (object, i);
                 if (item == NULL) {
                     retval = -1;
                     break;
                 }
 
-                retval = _pygi_g_type_info_check_object(item_type_info, item, TRUE);
+                retval = _pygi_g_type_info_check_object (item_type_info, item, TRUE);
 
-                Py_DECREF(item);
+                Py_DECREF (item);
 
                 if (retval < 0) {
                     break;
                 }
                 if (!retval) {
-                    _PyGI_ERROR_PREFIX("Item %zd: ", i);
+                    _PyGI_ERROR_PREFIX ("Item %zd: ", i);
                     break;
                 }
             }
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
             break;
         }
         case GI_TYPE_TAG_GHASH:
@@ -508,72 +508,72 @@ check_number_release:
             GITypeInfo *value_type_info;
             Py_ssize_t i;
 
-            if (!PyMapping_Check(object)) {
-                PyErr_Format(PyExc_TypeError, "Must be mapping, not %s",
-                        object->ob_type->tp_name);
+            if (!PyMapping_Check (object)) {
+                PyErr_Format (PyExc_TypeError, "Must be mapping, not %s",
+                              object->ob_type->tp_name);
                 retval = 0;
                 break;
             }
 
-            length = PyMapping_Length(object);
+            length = PyMapping_Length (object);
             if (length < 0) {
                 retval = -1;
                 break;
             }
 
-            keys = PyMapping_Keys(object);
+            keys = PyMapping_Keys (object);
             if (keys == NULL) {
                 retval = -1;
                 break;
             }
 
-            values = PyMapping_Values(object);
+            values = PyMapping_Values (object);
             if (values == NULL) {
                 retval = -1;
-                Py_DECREF(keys);
+                Py_DECREF (keys);
                 break;
             }
 
-            key_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(key_type_info != NULL);
+            key_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (key_type_info != NULL);
 
-            value_type_info = g_type_info_get_param_type(type_info, 1);
-            g_assert(value_type_info != NULL);
+            value_type_info = g_type_info_get_param_type (type_info, 1);
+            g_assert (value_type_info != NULL);
 
             for (i = 0; i < length; i++) {
                 PyObject *key;
                 PyObject *value;
 
-                key = PyList_GET_ITEM(keys, i);
-                value = PyList_GET_ITEM(values, i);
+                key = PyList_GET_ITEM (keys, i);
+                value = PyList_GET_ITEM (values, i);
 
-                retval = _pygi_g_type_info_check_object(key_type_info, key, TRUE);
+                retval = _pygi_g_type_info_check_object (key_type_info, key, TRUE);
                 if (retval < 0) {
                     break;
                 }
                 if (!retval) {
-                    _PyGI_ERROR_PREFIX("Key %zd :", i);
+                    _PyGI_ERROR_PREFIX ("Key %zd :", i);
                     break;
                 }
 
-                retval = _pygi_g_type_info_check_object(value_type_info, value, TRUE);
+                retval = _pygi_g_type_info_check_object (value_type_info, value, TRUE);
                 if (retval < 0) {
                     break;
                 }
                 if (!retval) {
-                    _PyGI_ERROR_PREFIX("Value %zd :", i);
+                    _PyGI_ERROR_PREFIX ("Value %zd :", i);
                     break;
                 }
             }
 
-            g_base_info_unref((GIBaseInfo *)key_type_info);
-            g_base_info_unref((GIBaseInfo *)value_type_info);
-            Py_DECREF(values);
-            Py_DECREF(keys);
+            g_base_info_unref ( (GIBaseInfo *) key_type_info);
+            g_base_info_unref ( (GIBaseInfo *) value_type_info);
+            Py_DECREF (values);
+            Py_DECREF (keys);
             break;
         }
         case GI_TYPE_TAG_ERROR:
-            PyErr_SetString(PyExc_NotImplementedError, "Error marshalling is not supported yet");
+            PyErr_SetString (PyExc_NotImplementedError, "Error marshalling is not supported yet");
             /* TODO */
             break;
     }
@@ -596,23 +596,23 @@ _pygi_argument_to_array (GArgument  *arg,
     if (arg->v_pointer == NULL) {
         return NULL;
     }
- 
-    is_zero_terminated = g_type_info_is_zero_terminated(type_info);
-    item_type_info = g_type_info_get_param_type(type_info, 0);
 
-    item_size = _pygi_g_type_info_size(item_type_info);
+    is_zero_terminated = g_type_info_is_zero_terminated (type_info);
+    item_type_info = g_type_info_get_param_type (type_info, 0);
+
+    item_size = _pygi_g_type_info_size (item_type_info);
 
-    g_base_info_unref((GIBaseInfo *)item_type_info);
+    g_base_info_unref ( (GIBaseInfo *) item_type_info);
 
     if (is_zero_terminated) {
-        length = g_strv_length(arg->v_pointer);
+        length = g_strv_length (arg->v_pointer);
     } else {
-        length = g_type_info_get_array_fixed_size(type_info);
+        length = g_type_info_get_array_fixed_size (type_info);
         if (length < 0) {
             gint length_arg_pos;
 
-            length_arg_pos = g_type_info_get_array_length(type_info);
-            g_assert(length_arg_pos >= 0);
+            length_arg_pos = g_type_info_get_array_length (type_info);
+            g_assert (length_arg_pos >= 0);
 
             if (is_method) {
                 length_arg_pos--;
@@ -627,7 +627,7 @@ _pygi_argument_to_array (GArgument  *arg,
 
     g_assert (length >= 0);
 
-    g_array = g_array_new(is_zero_terminated, FALSE, item_size);
+    g_array = g_array_new (is_zero_terminated, FALSE, item_size);
 
     g_array->data = arg->v_pointer;
     g_array->len = length;
@@ -643,16 +643,16 @@ _pygi_argument_from_object (PyObject   *object,
     GArgument arg;
     GITypeTag type_tag;
 
-    type_tag = g_type_info_get_tag(type_info);
+    type_tag = g_type_info_get_tag (type_info);
 
     switch (type_tag) {
         case GI_TYPE_TAG_VOID:
-            g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
+            g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
             arg.v_pointer = object;
             break;
         case GI_TYPE_TAG_BOOLEAN:
         {
-            arg.v_boolean = PyObject_IsTrue(object);
+            arg.v_boolean = PyObject_IsTrue (object);
             break;
         }
         case GI_TYPE_TAG_INT8:
@@ -668,14 +668,14 @@ _pygi_argument_from_object (PyObject   *object,
         {
             PyObject *int_;
 
-            int_ = PyNumber_Int(object);
+            int_ = PyNumber_Int (object);
             if (int_ == NULL) {
                 break;
             }
 
-            arg.v_long = PyInt_AsLong(int_);
+            arg.v_long = PyInt_AsLong (int_);
 
-            Py_DECREF(int_);
+            Py_DECREF (int_);
 
             break;
         }
@@ -688,20 +688,20 @@ _pygi_argument_from_object (PyObject   *object,
             PyObject *number;
             guint64 value;
 
-            number = PyNumber_Int(object);
+            number = PyNumber_Int (object);
             if (number == NULL) {
                 break;
             }
 
-            if (PyInt_Check(number)) {
-                value = PyInt_AS_LONG(number);
+            if (PyInt_Check (number)) {
+                value = PyInt_AS_LONG (number);
             } else {
-                value = PyLong_AsUnsignedLongLong(number);
+                value = PyLong_AsUnsignedLongLong (number);
             }
 
             arg.v_uint64 = value;
 
-            Py_DECREF(number);
+            Py_DECREF (number);
 
             break;
         }
@@ -710,20 +710,20 @@ _pygi_argument_from_object (PyObject   *object,
             PyObject *number;
             gint64 value;
 
-            number = PyNumber_Int(object);
+            number = PyNumber_Int (object);
             if (number == NULL) {
                 break;
             }
 
-            if (PyInt_Check(number)) {
-                value = PyInt_AS_LONG(number);
+            if (PyInt_Check (number)) {
+                value = PyInt_AS_LONG (number);
             } else {
-                value = PyLong_AsLongLong(number);
+                value = PyLong_AsLongLong (number);
             }
 
             arg.v_int64 = value;
 
-            Py_DECREF(number);
+            Py_DECREF (number);
 
             break;
         }
@@ -731,13 +731,13 @@ _pygi_argument_from_object (PyObject   *object,
         {
             PyObject *float_;
 
-            float_ = PyNumber_Float(object);
+            float_ = PyNumber_Float (object);
             if (float_ == NULL) {
                 break;
             }
 
-            arg.v_float = (float)PyFloat_AsDouble(float_);
-            Py_DECREF(float_);
+            arg.v_float = (float) PyFloat_AsDouble (float_);
+            Py_DECREF (float_);
 
             break;
         }
@@ -745,13 +745,13 @@ _pygi_argument_from_object (PyObject   *object,
         {
             PyObject *float_;
 
-            float_ = PyNumber_Float(object);
+            float_ = PyNumber_Float (object);
             if (float_ == NULL) {
                 break;
             }
 
-            arg.v_double = PyFloat_AsDouble(float_);
-            Py_DECREF(float_);
+            arg.v_double = PyFloat_AsDouble (float_);
+            Py_DECREF (float_);
 
             break;
         }
@@ -760,25 +760,25 @@ _pygi_argument_from_object (PyObject   *object,
             PyDateTime_DateTime *py_datetime;
             struct tm datetime;
 
-            py_datetime = (PyDateTime_DateTime *)object;
+            py_datetime = (PyDateTime_DateTime *) object;
 
             if (py_datetime->hastzinfo) {
-                if (PyErr_WarnEx(NULL, "tzinfo ignored; only local time is supported", 1) < 0) {
+                if (PyErr_WarnEx (NULL, "tzinfo ignored; only local time is supported", 1) < 0) {
                     break;
                 }
             }
 
-            datetime.tm_sec = PyDateTime_DATE_GET_SECOND(py_datetime);
-            datetime.tm_min = PyDateTime_DATE_GET_MINUTE(py_datetime);
-            datetime.tm_hour = PyDateTime_DATE_GET_HOUR(py_datetime);
-            datetime.tm_mday = PyDateTime_GET_DAY(py_datetime);
-            datetime.tm_mon = PyDateTime_GET_MONTH(py_datetime) - 1;
-            datetime.tm_year = PyDateTime_GET_YEAR(py_datetime) - 1900;
+            datetime.tm_sec = PyDateTime_DATE_GET_SECOND (py_datetime);
+            datetime.tm_min = PyDateTime_DATE_GET_MINUTE (py_datetime);
+            datetime.tm_hour = PyDateTime_DATE_GET_HOUR (py_datetime);
+            datetime.tm_mday = PyDateTime_GET_DAY (py_datetime);
+            datetime.tm_mon = PyDateTime_GET_MONTH (py_datetime) - 1;
+            datetime.tm_year = PyDateTime_GET_YEAR (py_datetime) - 1900;
             datetime.tm_isdst = -1;
 
-            arg.v_long = mktime(&datetime);
+            arg.v_long = mktime (&datetime);
             if (arg.v_long == -1) {
-                PyErr_SetString(PyExc_RuntimeError, "datetime conversion failed");
+                PyErr_SetString (PyExc_RuntimeError, "datetime conversion failed");
                 break;
             }
 
@@ -786,7 +786,7 @@ _pygi_argument_from_object (PyObject   *object,
         }
         case GI_TYPE_TAG_GTYPE:
         {
-            arg.v_long = pyg_type_from_object(object);
+            arg.v_long = pyg_type_from_object (object);
 
             break;
         }
@@ -794,15 +794,15 @@ _pygi_argument_from_object (PyObject   *object,
         {
             const gchar *string;
 
-            if (object == Py_None){
+            if (object == Py_None) {
                 arg.v_string = NULL;
                 break;
             }
 
-            string = PyString_AsString(object);
+            string = PyString_AsString (object);
 
             /* Don't need to check for errors, since g_strdup is NULL-proof. */
-            arg.v_string = g_strdup(string);
+            arg.v_string = g_strdup (string);
             break;
         }
         case GI_TYPE_TAG_FILENAME:
@@ -810,14 +810,14 @@ _pygi_argument_from_object (PyObject   *object,
             GError *error = NULL;
             const gchar *string;
 
-            string = PyString_AsString(object);
+            string = PyString_AsString (object);
             if (string == NULL) {
                 break;
             }
 
-            arg.v_string = g_filename_from_utf8(string, -1, NULL, NULL, &error);
+            arg.v_string = g_filename_from_utf8 (string, -1, NULL, NULL, &error);
             if (arg.v_string == NULL) {
-                PyErr_SetString(PyExc_Exception, error->message);
+                PyErr_SetString (PyExc_Exception, error->message);
                 /* TODO: Convert the error to an exception. */
             }
 
@@ -833,24 +833,24 @@ _pygi_argument_from_object (PyObject   *object,
             GITransfer item_transfer;
             Py_ssize_t i;
 
-            if (object == Py_None){
+            if (object == Py_None) {
                 arg.v_pointer = NULL;
                 break;
             }
 
-            length = PySequence_Length(object);
+            length = PySequence_Length (object);
             if (length < 0) {
                 break;
             }
 
-            is_zero_terminated = g_type_info_is_zero_terminated(type_info);
-            item_type_info = g_type_info_get_param_type(type_info, 0);
+            is_zero_terminated = g_type_info_is_zero_terminated (type_info);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
 
-            item_size = _pygi_g_type_info_size(item_type_info);
+            item_size = _pygi_g_type_info_size (item_type_info);
 
-            array = g_array_sized_new(is_zero_terminated, FALSE, item_size, length);
+            array = g_array_sized_new (is_zero_terminated, FALSE, item_size, length);
             if (array == NULL) {
-                g_base_info_unref((GIBaseInfo *)item_type_info);
+                g_base_info_unref ( (GIBaseInfo *) item_type_info);
                 PyErr_NoMemory();
                 break;
             }
@@ -861,35 +861,35 @@ _pygi_argument_from_object (PyObject   *object,
                 PyObject *py_item;
                 GArgument item;
 
-                py_item = PySequence_GetItem(object, i);
+                py_item = PySequence_GetItem (object, i);
                 if (py_item == NULL) {
                     goto array_item_error;
                 }
 
-                item = _pygi_argument_from_object(py_item, item_type_info, item_transfer);
+                item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
 
-                Py_DECREF(py_item);
+                Py_DECREF (py_item);
 
                 if (PyErr_Occurred()) {
                     goto array_item_error;
                 }
 
-                g_array_insert_val(array, i, item);
+                g_array_insert_val (array, i, item);
                 continue;
 
 array_item_error:
                 /* Free everything we have converted so far. */
-                _pygi_argument_release((GArgument *)&array, type_info,
-                        GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                _pygi_argument_release ( (GArgument *) &array, type_info,
+                                         GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                 array = NULL;
 
-                _PyGI_ERROR_PREFIX("Item %zd: ", i);
+                _PyGI_ERROR_PREFIX ("Item %zd: ", i);
                 break;
             }
 
             arg.v_pointer = array;
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
             break;
         }
         case GI_TYPE_TAG_INTERFACE:
@@ -897,8 +897,8 @@ array_item_error:
             GIBaseInfo *info;
             GIInfoType info_type;
 
-            info = g_type_info_get_interface(type_info);
-            info_type = g_base_info_get_type(info);
+            info = g_type_info_get_interface (type_info);
+            info_type = g_base_info_get_type (info);
 
             switch (info_type) {
                 case GI_INFO_TYPE_CALLBACK:
@@ -916,65 +916,65 @@ array_item_error:
                         break;
                     }
 
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 
                     /* Handle special cases first. */
-                    if (g_type_is_a(type, G_TYPE_VALUE)) {
+                    if (g_type_is_a (type, G_TYPE_VALUE)) {
                         GValue *value;
                         GType object_type;
                         gint retval;
 
-                        object_type = pyg_type_from_object((PyObject *)object->ob_type);
+                        object_type = pyg_type_from_object ( (PyObject *) object->ob_type);
                         if (object_type == G_TYPE_INVALID) {
-                            PyErr_SetString(PyExc_RuntimeError, "unable to retrieve object's GType");
+                            PyErr_SetString (PyExc_RuntimeError, "unable to retrieve object's GType");
                             break;
                         }
 
-                        g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
+                        g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
 
-                        value = g_slice_new0(GValue);
-                        g_value_init(value, object_type);
+                        value = g_slice_new0 (GValue);
+                        g_value_init (value, object_type);
 
-                        retval = pyg_value_from_pyobject(value, object);
+                        retval = pyg_value_from_pyobject (value, object);
                         if (retval < 0) {
-                            g_slice_free(GValue, value);
-                            PyErr_SetString(PyExc_RuntimeError, "PyObject conversion to GValue failed");
+                            g_slice_free (GValue, value);
+                            PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GValue failed");
                             break;
                         }
 
                         arg.v_pointer = value;
-                    } else if (g_type_is_a(type, G_TYPE_CLOSURE)) {
+                    } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
                         GClosure *closure;
 
-                        g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
+                        g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
 
-                        closure = pyg_closure_new(object, NULL, NULL);
+                        closure = pyg_closure_new (object, NULL, NULL);
                         if (closure == NULL) {
-                            PyErr_SetString(PyExc_RuntimeError, "PyObject conversion to GClosure failed");
+                            PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GClosure failed");
                             break;
                         }
 
                         arg.v_pointer = closure;
-                    } else if (g_type_is_a(type, G_TYPE_BOXED)) {
-                        arg.v_pointer = pyg_boxed_get(object, void);
+                    } else if (g_type_is_a (type, G_TYPE_BOXED)) {
+                        arg.v_pointer = pyg_boxed_get (object, void);
                         if (transfer == GI_TRANSFER_EVERYTHING) {
-                            arg.v_pointer = g_boxed_copy(type, arg.v_pointer);
+                            arg.v_pointer = g_boxed_copy (type, arg.v_pointer);
                         }
-                    } else if ((type == G_TYPE_NONE) && (g_struct_info_is_foreign (info))) {
+                    } else if ( (type == G_TYPE_NONE) && (g_struct_info_is_foreign (info))) {
                         gint retval;
 
-                        retval = pygi_struct_foreign_convert_to_g_argument(
-                                object, type_info, transfer, &arg);
+                        retval = pygi_struct_foreign_convert_to_g_argument (
+                                     object, type_info, transfer, &arg);
 
                         if (!retval) {
-                            PyErr_SetString(PyExc_RuntimeError, "PyObject conversion to foreign struct failed");
+                            PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to foreign struct failed");
                             break;
                         }
-                    } else if (g_type_is_a(type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
-                        g_warn_if_fail(!g_type_info_is_pointer(type_info) || transfer == GI_TRANSFER_NOTHING);
-                        arg.v_pointer = pyg_pointer_get(object, void);
+                    } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
+                        g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
+                        arg.v_pointer = pyg_pointer_get (object, void);
                     } else {
-                        PyErr_Format(PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name(type));
+                        PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
                     }
 
                     break;
@@ -984,14 +984,14 @@ array_item_error:
                 {
                     PyObject *int_;
 
-                    int_ = PyNumber_Int(object);
+                    int_ = PyNumber_Int (object);
                     if (int_ == NULL) {
                         break;
                     }
 
-                    arg.v_long = PyInt_AsLong(int_);
+                    arg.v_long = PyInt_AsLong (int_);
 
-                    Py_DECREF(int_);
+                    Py_DECREF (int_);
 
                     break;
                 }
@@ -1002,16 +1002,16 @@ array_item_error:
                         break;
                     }
 
-                    arg.v_pointer = pygobject_get(object);
+                    arg.v_pointer = pygobject_get (object);
                     if (transfer == GI_TRANSFER_EVERYTHING) {
-                        g_object_ref(arg.v_pointer);
+                        g_object_ref (arg.v_pointer);
                     }
 
                     break;
                 default:
                     g_assert_not_reached();
             }
-            g_base_info_unref(info);
+            g_base_info_unref (info);
             break;
         }
         case GI_TYPE_TAG_GLIST:
@@ -1028,13 +1028,13 @@ array_item_error:
                 break;
             }
 
-            length = PySequence_Length(object);
+            length = PySequence_Length (object);
             if (length < 0) {
                 break;
             }
 
-            item_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(item_type_info != NULL);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (item_type_info != NULL);
 
             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 
@@ -1042,40 +1042,40 @@ array_item_error:
                 PyObject *py_item;
                 GArgument item;
 
-                py_item = PySequence_GetItem(object, i);
+                py_item = PySequence_GetItem (object, i);
                 if (py_item == NULL) {
                     goto list_item_error;
                 }
 
-                item = _pygi_argument_from_object(py_item, item_type_info, item_transfer);
+                item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
 
-                Py_DECREF(py_item);
+                Py_DECREF (py_item);
 
                 if (PyErr_Occurred()) {
                     goto list_item_error;
                 }
 
                 if (type_tag == GI_TYPE_TAG_GLIST) {
-                    list = (GSList *)g_list_prepend((GList *)list, item.v_pointer);
+                    list = (GSList *) g_list_prepend ( (GList *) list, item.v_pointer);
                 } else {
-                    list = g_slist_prepend(list, item.v_pointer);
+                    list = g_slist_prepend (list, item.v_pointer);
                 }
 
                 continue;
 
 list_item_error:
                 /* Free everything we have converted so far. */
-                _pygi_argument_release((GArgument *)&list, type_info,
-                        GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                _pygi_argument_release ( (GArgument *) &list, type_info,
+                                         GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                 list = NULL;
 
-                _PyGI_ERROR_PREFIX("Item %zd: ", i);
+                _PyGI_ERROR_PREFIX ("Item %zd: ", i);
                 break;
             }
 
             arg.v_pointer = list;
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
 
             break;
         }
@@ -1094,36 +1094,36 @@ list_item_error:
             Py_ssize_t i;
 
 
-            if (object == Py_None){
-                arg.v_pointer = NULL;                
+            if (object == Py_None) {
+                arg.v_pointer = NULL;
                 break;
             }
 
-            length = PyMapping_Length(object);
+            length = PyMapping_Length (object);
             if (length < 0) {
                 break;
             }
 
-            keys = PyMapping_Keys(object);
+            keys = PyMapping_Keys (object);
             if (keys == NULL) {
                 break;
             }
 
-            values = PyMapping_Values(object);
+            values = PyMapping_Values (object);
             if (values == NULL) {
-                Py_DECREF(keys);
+                Py_DECREF (keys);
                 break;
             }
 
-            key_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(key_type_info != NULL);
+            key_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (key_type_info != NULL);
 
-            value_type_info = g_type_info_get_param_type(type_info, 1);
-            g_assert(value_type_info != NULL);
+            value_type_info = g_type_info_get_param_type (type_info, 1);
+            g_assert (value_type_info != NULL);
 
-            key_type_tag = g_type_info_get_tag(key_type_info);
+            key_type_tag = g_type_info_get_tag (key_type_info);
 
-            switch(key_type_tag) {
+            switch (key_type_tag) {
                 case GI_TYPE_TAG_UTF8:
                 case GI_TYPE_TAG_FILENAME:
                     hash_func = g_str_hash;
@@ -1134,7 +1134,7 @@ list_item_error:
                     equal_func = NULL;
             }
 
-            hash_table = g_hash_table_new(hash_func, equal_func);
+            hash_table = g_hash_table_new (hash_func, equal_func);
             if (hash_table == NULL) {
                 PyErr_NoMemory();
                 goto hash_table_release;
@@ -1148,44 +1148,44 @@ list_item_error:
                 GArgument key;
                 GArgument value;
 
-                py_key = PyList_GET_ITEM(keys, i);
-                py_value = PyList_GET_ITEM(values, i);
+                py_key = PyList_GET_ITEM (keys, i);
+                py_value = PyList_GET_ITEM (values, i);
 
-                key = _pygi_argument_from_object(py_key, key_type_info, item_transfer);
+                key = _pygi_argument_from_object (py_key, key_type_info, item_transfer);
                 if (PyErr_Occurred()) {
                     goto hash_table_item_error;
                 }
 
-                value = _pygi_argument_from_object(py_value, value_type_info, item_transfer);
+                value = _pygi_argument_from_object (py_value, value_type_info, item_transfer);
                 if (PyErr_Occurred()) {
-                    _pygi_argument_release(&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                    _pygi_argument_release (&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                     goto hash_table_item_error;
                 }
 
-                g_hash_table_insert(hash_table, key.v_pointer, value.v_pointer);
+                g_hash_table_insert (hash_table, key.v_pointer, value.v_pointer);
                 continue;
 
 hash_table_item_error:
                 /* Free everything we have converted so far. */
-                _pygi_argument_release((GArgument *)&hash_table, type_info,
-                        GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                _pygi_argument_release ( (GArgument *) &hash_table, type_info,
+                                         GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                 hash_table = NULL;
 
-                _PyGI_ERROR_PREFIX("Item %zd: ", i);
+                _PyGI_ERROR_PREFIX ("Item %zd: ", i);
                 break;
             }
 
             arg.v_pointer = hash_table;
 
 hash_table_release:
-            g_base_info_unref((GIBaseInfo *)key_type_info);
-            g_base_info_unref((GIBaseInfo *)value_type_info);
-            Py_DECREF(keys);
-            Py_DECREF(values);
+            g_base_info_unref ( (GIBaseInfo *) key_type_info);
+            g_base_info_unref ( (GIBaseInfo *) value_type_info);
+            Py_DECREF (keys);
+            Py_DECREF (values);
             break;
         }
         case GI_TYPE_TAG_ERROR:
-            PyErr_SetString(PyExc_NotImplementedError, "error marshalling is not supported yet");
+            PyErr_SetString (PyExc_NotImplementedError, "error marshalling is not supported yet");
             /* TODO */
             break;
     }
@@ -1201,110 +1201,110 @@ _pygi_argument_to_object (GArgument  *arg,
     GITypeTag type_tag;
     PyObject *object = NULL;
 
-    type_tag = g_type_info_get_tag(type_info);
+    type_tag = g_type_info_get_tag (type_info);
     switch (type_tag) {
         case GI_TYPE_TAG_VOID:
-            if (g_type_info_is_pointer(type_info)) {
+            if (g_type_info_is_pointer (type_info)) {
                 /* Raw Python objects are passed to void* args */
-                g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
+                g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
                 object = arg->v_pointer;
             } else
                 object = Py_None;
-            Py_XINCREF(object);
+            Py_XINCREF (object);
             break;
         case GI_TYPE_TAG_BOOLEAN:
         {
-            object = PyBool_FromLong(arg->v_boolean);
+            object = PyBool_FromLong (arg->v_boolean);
             break;
         }
         case GI_TYPE_TAG_INT8:
         {
-            object = PyInt_FromLong(arg->v_int8);
+            object = PyInt_FromLong (arg->v_int8);
             break;
         }
         case GI_TYPE_TAG_UINT8:
         {
-            object = PyInt_FromLong(arg->v_uint8);
+            object = PyInt_FromLong (arg->v_uint8);
             break;
         }
         case GI_TYPE_TAG_INT16:
         {
-            object = PyInt_FromLong(arg->v_int16);
+            object = PyInt_FromLong (arg->v_int16);
             break;
         }
         case GI_TYPE_TAG_UINT16:
         {
-            object = PyInt_FromLong(arg->v_uint16);
+            object = PyInt_FromLong (arg->v_uint16);
             break;
         }
         case GI_TYPE_TAG_INT32:
         {
-            object = PyInt_FromLong(arg->v_int32);
+            object = PyInt_FromLong (arg->v_int32);
             break;
         }
         case GI_TYPE_TAG_UINT32:
         {
-            object = PyLong_FromLongLong(arg->v_uint32);
+            object = PyLong_FromLongLong (arg->v_uint32);
             break;
         }
         case GI_TYPE_TAG_INT64:
         {
-            object = PyLong_FromLongLong(arg->v_int64);
+            object = PyLong_FromLongLong (arg->v_int64);
             break;
         }
         case GI_TYPE_TAG_UINT64:
         {
-            object = PyLong_FromUnsignedLongLong(arg->v_uint64);
+            object = PyLong_FromUnsignedLongLong (arg->v_uint64);
             break;
         }
         case GI_TYPE_TAG_SHORT:
         {
-            object = PyInt_FromLong(arg->v_short);
+            object = PyInt_FromLong (arg->v_short);
             break;
         }
         case GI_TYPE_TAG_USHORT:
         {
-            object = PyInt_FromLong(arg->v_ushort);
+            object = PyInt_FromLong (arg->v_ushort);
             break;
         }
         case GI_TYPE_TAG_INT:
         {
-            object = PyInt_FromLong(arg->v_int);
+            object = PyInt_FromLong (arg->v_int);
             break;
         }
         case GI_TYPE_TAG_UINT:
         {
-            object = PyLong_FromLongLong(arg->v_uint);
+            object = PyLong_FromLongLong (arg->v_uint);
             break;
         }
         case GI_TYPE_TAG_LONG:
         {
-            object = PyInt_FromLong(arg->v_long);
+            object = PyInt_FromLong (arg->v_long);
             break;
         }
         case GI_TYPE_TAG_ULONG:
         {
-            object = PyLong_FromUnsignedLongLong(arg->v_ulong);
+            object = PyLong_FromUnsignedLongLong (arg->v_ulong);
             break;
         }
         case GI_TYPE_TAG_SSIZE:
         {
-            object = PyInt_FromLong(arg->v_ssize);
+            object = PyInt_FromLong (arg->v_ssize);
             break;
         }
         case GI_TYPE_TAG_SIZE:
         {
-            object = PyLong_FromUnsignedLongLong(arg->v_size);
+            object = PyLong_FromUnsignedLongLong (arg->v_size);
             break;
         }
         case GI_TYPE_TAG_FLOAT:
         {
-            object = PyFloat_FromDouble(arg->v_float);
+            object = PyFloat_FromDouble (arg->v_float);
             break;
         }
         case GI_TYPE_TAG_DOUBLE:
         {
-            object = PyFloat_FromDouble(arg->v_double);
+            object = PyFloat_FromDouble (arg->v_double);
             break;
         }
         case GI_TYPE_TAG_TIME_T:
@@ -1312,32 +1312,32 @@ _pygi_argument_to_object (GArgument  *arg,
             time_t *time_;
             struct tm *datetime;
 
-            time_ = (time_t *)&arg->v_long;
+            time_ = (time_t *) &arg->v_long;
 
-            datetime = localtime(time_);
-            object = PyDateTime_FromDateAndTime(
-                    datetime->tm_year + 1900,
-                    datetime->tm_mon + 1,
-                    datetime->tm_mday,
-                    datetime->tm_hour,
-                    datetime->tm_min,
-                    datetime->tm_sec,
-                    0);
+            datetime = localtime (time_);
+            object = PyDateTime_FromDateAndTime (
+                         datetime->tm_year + 1900,
+                         datetime->tm_mon + 1,
+                         datetime->tm_mday,
+                         datetime->tm_hour,
+                         datetime->tm_min,
+                         datetime->tm_sec,
+                         0);
             break;
         }
         case GI_TYPE_TAG_GTYPE:
         {
-            object = pyg_type_wrapper_new((GType)arg->v_long);
+            object = pyg_type_wrapper_new ( (GType) arg->v_long);
             break;
         }
         case GI_TYPE_TAG_UTF8:
             if (arg->v_string == NULL) {
                 object = Py_None;
-                Py_INCREF(object);
+                Py_INCREF (object);
                 break;
             }
 
-            object = PyString_FromString(arg->v_string);
+            object = PyString_FromString (arg->v_string);
             break;
         case GI_TYPE_TAG_FILENAME:
         {
@@ -1346,20 +1346,20 @@ _pygi_argument_to_object (GArgument  *arg,
 
             if (arg->v_string == NULL) {
                 object = Py_None;
-                Py_INCREF(object);
+                Py_INCREF (object);
                 break;
             }
 
-            string = g_filename_to_utf8(arg->v_string, -1, NULL, NULL, &error);
+            string = g_filename_to_utf8 (arg->v_string, -1, NULL, NULL, &error);
             if (string == NULL) {
-                PyErr_SetString(PyExc_Exception, error->message);
+                PyErr_SetString (PyExc_Exception, error->message);
                 /* TODO: Convert the error to an exception. */
                 break;
             }
 
-            object = PyString_FromString(string);
+            object = PyString_FromString (string);
 
-            g_free(string);
+            g_free (string);
 
             break;
         }
@@ -1373,58 +1373,58 @@ _pygi_argument_to_object (GArgument  *arg,
 
             if (arg->v_pointer == NULL) {
                 object = Py_None;
-                Py_INCREF(object);
+                Py_INCREF (object);
                 break;
             }
 
             array = arg->v_pointer;
 
-            object = PyTuple_New(array->len);
+            object = PyTuple_New (array->len);
             if (object == NULL) {
                 break;
             }
 
-            item_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(item_type_info != NULL);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (item_type_info != NULL);
 
-            item_type_tag = g_type_info_get_tag(item_type_info);
+            item_type_tag = g_type_info_get_tag (item_type_info);
             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
-            item_size = g_array_get_element_size(array);
+            item_size = g_array_get_element_size (array);
 
-            for(i = 0; i < array->len; i++) {
+            for (i = 0; i < array->len; i++) {
                 GArgument item;
                 PyObject *py_item;
                 gboolean is_struct = FALSE;
 
                 if (item_type_tag == GI_TYPE_TAG_INTERFACE) {
-                    GIBaseInfo *iface_info = g_type_info_get_interface(item_type_info);
-                    switch (g_base_info_get_type(iface_info)) {
+                    GIBaseInfo *iface_info = g_type_info_get_interface (item_type_info);
+                    switch (g_base_info_get_type (iface_info)) {
                         case GI_INFO_TYPE_STRUCT:
                         case GI_INFO_TYPE_BOXED:
                             is_struct = TRUE;
                         default:
                             break;
                     }
-                    g_base_info_unref((GIBaseInfo *)iface_info);
+                    g_base_info_unref ( (GIBaseInfo *) iface_info);
                 }
 
                 if (is_struct) {
-                    item.v_pointer = &_g_array_index(array, GArgument, i);
+                    item.v_pointer = &_g_array_index (array, GArgument, i);
                 } else {
-                    memcpy(&item, &_g_array_index(array, GArgument, i), item_size);
+                    memcpy (&item, &_g_array_index (array, GArgument, i), item_size);
                 }
 
-                py_item = _pygi_argument_to_object(&item, item_type_info, item_transfer);
+                py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
                 if (py_item == NULL) {
-                    Py_CLEAR(object);
-                    _PyGI_ERROR_PREFIX("Item %zu: ", i);
+                    Py_CLEAR (object);
+                    _PyGI_ERROR_PREFIX ("Item %zu: ", i);
                     break;
                 }
 
-                PyTuple_SET_ITEM(object, i, py_item);
+                PyTuple_SET_ITEM (object, i, py_item);
             }
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
             break;
         }
         case GI_TYPE_TAG_INTERFACE:
@@ -1432,23 +1432,23 @@ _pygi_argument_to_object (GArgument  *arg,
             GIBaseInfo *info;
             GIInfoType info_type;
 
-            info = g_type_info_get_interface(type_info);
-            info_type = g_base_info_get_type(info);
+            info = g_type_info_get_interface (type_info);
+            info_type = g_base_info_get_type (info);
 
             switch (info_type) {
                 case GI_INFO_TYPE_CALLBACK:
                 {
-                  /* There is no way we can support a callback return
-                   * as we are never sure if the callback was set from C
-                   * or Python.  API that return callbacks are broken
-                   * so we print a warning and send back a None
-                   */
-
-                  g_warning("You are trying to use an API which returns a callback."
-                            "Callback returns can not be supported. Returning None instead.");
-                  object = Py_None;
-                  Py_INCREF(object);
-                  break;
+                    /* There is no way we can support a callback return
+                     * as we are never sure if the callback was set from C
+                     * or Python.  API that return callbacks are broken
+                     * so we print a warning and send back a None
+                     */
+
+                    g_warning ("You are trying to use an API which returns a callback."
+                               "Callback returns can not be supported. Returning None instead.");
+                    object = Py_None;
+                    Py_INCREF (object);
+                    break;
                 }
                 case GI_INFO_TYPE_BOXED:
                 case GI_INFO_TYPE_STRUCT:
@@ -1458,52 +1458,52 @@ _pygi_argument_to_object (GArgument  *arg,
 
                     if (arg->v_pointer == NULL) {
                         object = Py_None;
-                        Py_INCREF(object);
+                        Py_INCREF (object);
                         break;
                     }
 
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
-                    if (g_type_is_a(type, G_TYPE_VALUE)) {
-                        object = pyg_value_as_pyobject(arg->v_pointer, FALSE);
-                    } else if (g_type_is_a(type, G_TYPE_BOXED)) {
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
+                    if (g_type_is_a (type, G_TYPE_VALUE)) {
+                        object = pyg_value_as_pyobject (arg->v_pointer, FALSE);
+                    } else if (g_type_is_a (type, G_TYPE_BOXED)) {
                         PyObject *py_type;
 
-                        py_type = _pygi_type_get_from_g_type(type);
+                        py_type = _pygi_type_get_from_g_type (type);
                         if (py_type == NULL)
                             break;
 
-                        object = _pygi_boxed_new((PyTypeObject *)py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
+                        object = _pygi_boxed_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
 
-                        Py_DECREF(py_type);
-                    } else if (g_type_is_a(type, G_TYPE_POINTER)) {
+                        Py_DECREF (py_type);
+                    } else if (g_type_is_a (type, G_TYPE_POINTER)) {
                         PyObject *py_type;
 
-                        py_type = _pygi_type_get_from_g_type(type);
+                        py_type = _pygi_type_get_from_g_type (type);
 
-                        if (py_type == NULL || !PyType_IsSubtype((PyTypeObject *)type, &PyGIStruct_Type)) {
-                            g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
-                            object = pyg_pointer_new(type, arg->v_pointer);
+                        if (py_type == NULL || !PyType_IsSubtype ( (PyTypeObject *) type, &PyGIStruct_Type)) {
+                            g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
+                            object = pyg_pointer_new (type, arg->v_pointer);
                         } else {
-                            object = _pygi_struct_new((PyTypeObject *)py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
+                            object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
                         }
 
-                        Py_XDECREF(py_type);
-                    } else if ((type == G_TYPE_NONE) && (g_struct_info_is_foreign (info))) {
-                        object = pygi_struct_foreign_convert_from_g_argument(type_info, arg->v_pointer);
+                        Py_XDECREF (py_type);
+                    } else if ( (type == G_TYPE_NONE) && (g_struct_info_is_foreign (info))) {
+                        object = pygi_struct_foreign_convert_from_g_argument (type_info, arg->v_pointer);
                     } else if (type == G_TYPE_NONE) {
                         PyObject *py_type;
 
-                        py_type = _pygi_type_import_by_gi_info(info);
+                        py_type = _pygi_type_import_by_gi_info (info);
                         if (py_type == NULL) {
                             break;
                         }
 
-                        object = _pygi_struct_new((PyTypeObject *)py_type, arg->v_pointer,
-                                transfer == GI_TRANSFER_EVERYTHING);
+                        object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer,
+                                                    transfer == GI_TRANSFER_EVERYTHING);
 
-                        Py_DECREF(py_type);
+                        Py_DECREF (py_type);
                     } else {
-                        PyErr_Format(PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name(type));
+                        PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
                     }
 
                     break;
@@ -1513,32 +1513,32 @@ _pygi_argument_to_object (GArgument  *arg,
                 {
                     GType type;
 
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 
                     if (type == G_TYPE_NONE) {
                         /* An enum with a GType of None is an enum without GType */
-                        PyObject *py_type = _pygi_type_import_by_gi_info(info);
+                        PyObject *py_type = _pygi_type_import_by_gi_info (info);
                         PyObject *py_args = NULL;
 
                         if (!py_type)
                             return NULL;
 
-                        py_args = PyTuple_New(1);
-                        if (PyTuple_SetItem(py_args, 0, PyLong_FromLong(arg->v_long)) != 0) {
-                            Py_DECREF(py_args);
-                            Py_DECREF(py_type);
+                        py_args = PyTuple_New (1);
+                        if (PyTuple_SetItem (py_args, 0, PyLong_FromLong (arg->v_long)) != 0) {
+                            Py_DECREF (py_args);
+                            Py_DECREF (py_type);
                             return NULL;
                         }
 
-                        object = PyObject_CallFunction(py_type, "l", arg->v_long);
+                        object = PyObject_CallFunction (py_type, "l", arg->v_long);
 
-                        Py_DECREF(py_args);
-                        Py_DECREF(py_type);
+                        Py_DECREF (py_args);
+                        Py_DECREF (py_type);
 
                     } else if (info_type == GI_INFO_TYPE_ENUM) {
-                        object = pyg_enum_from_gtype(type, arg->v_long);
+                        object = pyg_enum_from_gtype (type, arg->v_long);
                     } else {
-                        object = pyg_flags_from_gtype(type, arg->v_long);
+                        object = pyg_flags_from_gtype (type, arg->v_long);
                     }
 
                     break;
@@ -1547,16 +1547,16 @@ _pygi_argument_to_object (GArgument  *arg,
                 case GI_INFO_TYPE_OBJECT:
                     if (arg->v_pointer == NULL) {
                         object = Py_None;
-                        Py_INCREF(object);
+                        Py_INCREF (object);
                         break;
                     }
-                    object = pygobject_new(arg->v_pointer);
+                    object = pygobject_new (arg->v_pointer);
                     break;
                 default:
                     g_assert_not_reached();
             }
 
-            g_base_info_unref(info);
+            g_base_info_unref (info);
             break;
         }
         case GI_TYPE_TAG_GLIST:
@@ -1569,35 +1569,35 @@ _pygi_argument_to_object (GArgument  *arg,
             gsize i;
 
             list = arg->v_pointer;
-            length = g_slist_length(list);
+            length = g_slist_length (list);
 
-            object = PyList_New(length);
+            object = PyList_New (length);
             if (object == NULL) {
                 break;
             }
 
-            item_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(item_type_info != NULL);
+            item_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (item_type_info != NULL);
 
             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 
-            for (i = 0; list != NULL; list = g_slist_next(list), i++) {
+            for (i = 0; list != NULL; list = g_slist_next (list), i++) {
                 GArgument item;
                 PyObject *py_item;
 
                 item.v_pointer = list->data;
 
-                py_item = _pygi_argument_to_object(&item, item_type_info, item_transfer);
+                py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
                 if (py_item == NULL) {
-                    Py_CLEAR(object);
-                    _PyGI_ERROR_PREFIX("Item %zu: ", i);
+                    Py_CLEAR (object);
+                    _PyGI_ERROR_PREFIX ("Item %zu: ", i);
                     break;
                 }
 
-                PyList_SET_ITEM(object, i, py_item);
+                PyList_SET_ITEM (object, i, py_item);
             }
 
-            g_base_info_unref((GIBaseInfo *)item_type_info);
+            g_base_info_unref ( (GIBaseInfo *) item_type_info);
             break;
         }
         case GI_TYPE_TAG_GHASH:
@@ -1611,7 +1611,7 @@ _pygi_argument_to_object (GArgument  *arg,
 
             if (arg->v_pointer == NULL) {
                 object = Py_None;
-                Py_INCREF(object);
+                Py_INCREF (object);
                 break;
             }
 
@@ -1620,44 +1620,44 @@ _pygi_argument_to_object (GArgument  *arg,
                 break;
             }
 
-            key_type_info = g_type_info_get_param_type(type_info, 0);
-            g_assert(key_type_info != NULL);
+            key_type_info = g_type_info_get_param_type (type_info, 0);
+            g_assert (key_type_info != NULL);
 
-            value_type_info = g_type_info_get_param_type(type_info, 1);
-            g_assert(value_type_info != NULL);
+            value_type_info = g_type_info_get_param_type (type_info, 1);
+            g_assert (value_type_info != NULL);
 
             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 
-            g_hash_table_iter_init(&hash_table_iter, (GHashTable *)arg->v_pointer);
-            while (g_hash_table_iter_next(&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
+            g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
+            while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
                 PyObject *py_key;
                 PyObject *py_value;
                 int retval;
 
-                py_key = _pygi_argument_to_object(&key, key_type_info, item_transfer);
+                py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
                 if (py_key == NULL) {
                     break;
                 }
 
-                py_value = _pygi_argument_to_object(&value, value_type_info, item_transfer);
+                py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
                 if (py_value == NULL) {
-                    Py_DECREF(py_key);
+                    Py_DECREF (py_key);
                     break;
                 }
 
-                retval = PyDict_SetItem(object, py_key, py_value);
+                retval = PyDict_SetItem (object, py_key, py_value);
 
-                Py_DECREF(py_key);
-                Py_DECREF(py_value);
+                Py_DECREF (py_key);
+                Py_DECREF (py_value);
 
                 if (retval < 0) {
-                    Py_CLEAR(object);
+                    Py_CLEAR (object);
                     break;
                 }
             }
 
-            g_base_info_unref((GIBaseInfo *)key_type_info);
-            g_base_info_unref((GIBaseInfo *)value_type_info);
+            g_base_info_unref ( (GIBaseInfo *) key_type_info);
+            g_base_info_unref ( (GIBaseInfo *) value_type_info);
             break;
         }
         case GI_TYPE_TAG_ERROR:
@@ -1676,9 +1676,9 @@ _pygi_argument_release (GArgument   *arg,
 {
     GITypeTag type_tag;
 
-    type_tag = g_type_info_get_tag(type_info);
+    type_tag = g_type_info_get_tag (type_info);
 
-    switch(type_tag) {
+    switch (type_tag) {
         case GI_TYPE_TAG_VOID:
             /* Don't do anything, it's transparent to the C side */
             break;
@@ -1707,10 +1707,10 @@ _pygi_argument_release (GArgument   *arg,
         case GI_TYPE_TAG_FILENAME:
         case GI_TYPE_TAG_UTF8:
             /* With allow-none support the string could be NULL */
-            if (arg->v_string != NULL && 
-                (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
+            if (arg->v_string != NULL &&
+                    (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
-                g_free(arg->v_string);
+                g_free (arg->v_string);
             }
             break;
         case GI_TYPE_TAG_ARRAY:
@@ -1724,28 +1724,28 @@ _pygi_argument_release (GArgument   *arg,
 
             array = arg->v_pointer;
 
-            if ((direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
+            if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
                 GITypeInfo *item_type_info;
                 GITransfer item_transfer;
 
-                item_type_info = g_type_info_get_param_type(type_info, 0);
+                item_type_info = g_type_info_get_param_type (type_info, 0);
 
                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
 
                 /* Free the items */
                 for (i = 0; i < array->len; i++) {
                     GArgument *item;
-                    item = &_g_array_index(array, GArgument, i);
-                    _pygi_argument_release(item, item_type_info, item_transfer, direction);
+                    item = &_g_array_index (array, GArgument, i);
+                    _pygi_argument_release (item, item_type_info, item_transfer, direction);
                 }
 
-                g_base_info_unref((GIBaseInfo *)item_type_info);
+                g_base_info_unref ( (GIBaseInfo *) item_type_info);
             }
 
-            if ((direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
+            if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
-                g_array_free(array, TRUE);
+                g_array_free (array, TRUE);
             }
 
             break;
@@ -1755,8 +1755,8 @@ _pygi_argument_release (GArgument   *arg,
             GIBaseInfo *info;
             GIInfoType info_type;
 
-            info = g_type_info_get_interface(type_info);
-            info_type = g_base_info_get_type(info);
+            info = g_type_info_get_interface (type_info);
+            info_type = g_base_info_get_type (info);
 
             switch (info_type) {
                 case GI_INFO_TYPE_CALLBACK:
@@ -1772,33 +1772,33 @@ _pygi_argument_release (GArgument   *arg,
                         return;
                     }
 
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 
-                    if (g_type_is_a(type, G_TYPE_VALUE)) {
+                    if (g_type_is_a (type, G_TYPE_VALUE)) {
                         GValue *value;
 
                         value = arg->v_pointer;
 
-                        if ((direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
+                        if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
                                 || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
-                            g_value_unset(value);
+                            g_value_unset (value);
                         }
 
-                        if ((direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
+                        if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
                                 || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
-                            g_slice_free(GValue, value);
+                            g_slice_free (GValue, value);
                         }
-                    } else if (g_type_is_a(type, G_TYPE_CLOSURE)) {
+                    } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
                         if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
-                            g_closure_unref(arg->v_pointer);
+                            g_closure_unref (arg->v_pointer);
                         }
-                    } else if (g_struct_info_is_foreign((GIStructInfo*)info)) {
+                    } else if (g_struct_info_is_foreign ( (GIStructInfo*) info)) {
                         if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
-                            pygi_struct_foreign_release_g_argument(transfer, type_info, arg);
+                            pygi_struct_foreign_release_g_argument (transfer, type_info, arg);
                         }
-                    } else if (g_type_is_a(type, G_TYPE_BOXED)) {
-                    } else if (g_type_is_a(type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
-                        g_warn_if_fail(!g_type_info_is_pointer(type_info) || transfer == GI_TRANSFER_NOTHING);
+                    } else if (g_type_is_a (type, G_TYPE_BOXED)) {
+                    } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
+                        g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
                     }
 
                     break;
@@ -1812,14 +1812,14 @@ _pygi_argument_release (GArgument   *arg,
                         return;
                     }
                     if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
-                        g_object_unref(arg->v_pointer);
+                        g_object_unref (arg->v_pointer);
                     }
                     break;
                 default:
                     g_assert_not_reached();
             }
 
-            g_base_info_unref(info);
+            g_base_info_unref (info);
             break;
         }
         case GI_TYPE_TAG_GLIST:
@@ -1833,33 +1833,33 @@ _pygi_argument_release (GArgument   *arg,
 
             list = arg->v_pointer;
 
-            if ((direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
+            if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
                 GITypeInfo *item_type_info;
                 GITransfer item_transfer;
                 GSList *item;
 
-                item_type_info = g_type_info_get_param_type(type_info, 0);
-                g_assert(item_type_info != NULL);
+                item_type_info = g_type_info_get_param_type (type_info, 0);
+                g_assert (item_type_info != NULL);
 
                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
 
                 /* Free the items */
-                for (item = list; item != NULL; item = g_slist_next(item)) {
-                    _pygi_argument_release((GArgument *)&item->data, item_type_info,
-                        item_transfer, direction);
+                for (item = list; item != NULL; item = g_slist_next (item)) {
+                    _pygi_argument_release ( (GArgument *) &item->data, item_type_info,
+                                             item_transfer, direction);
                 }
 
-                g_base_info_unref((GIBaseInfo *)item_type_info);
+                g_base_info_unref ( (GIBaseInfo *) item_type_info);
             }
 
-            if ((direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
+            if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
                 if (type_tag == GI_TYPE_TAG_GLIST) {
-                    g_list_free((GList *)list);
+                    g_list_free ( (GList *) list);
                 } else {
                     /* type_tag == GI_TYPE_TAG_GSLIST */
-                    g_slist_free(list);
+                    g_slist_free (list);
                 }
             }
 
@@ -1885,11 +1885,11 @@ _pygi_argument_release (GArgument   *arg,
                 gpointer key;
                 gpointer value;
 
-                key_type_info = g_type_info_get_param_type(type_info, 0);
-                g_assert(key_type_info != NULL);
+                key_type_info = g_type_info_get_param_type (type_info, 0);
+                g_assert (key_type_info != NULL);
 
-                value_type_info = g_type_info_get_param_type(type_info, 1);
-                g_assert(value_type_info != NULL);
+                value_type_info = g_type_info_get_param_type (type_info, 1);
+                g_assert (value_type_info != NULL);
 
                 if (direction == GI_DIRECTION_IN) {
                     item_transfer = GI_TRANSFER_NOTHING;
@@ -1897,25 +1897,25 @@ _pygi_argument_release (GArgument   *arg,
                     item_transfer = GI_TRANSFER_EVERYTHING;
                 }
 
-                g_hash_table_iter_init(&hash_table_iter, hash_table);
-                while (g_hash_table_iter_next(&hash_table_iter, &key, &value)) {
-                    _pygi_argument_release((GArgument *)&key, key_type_info,
-                        item_transfer, direction);
-                    _pygi_argument_release((GArgument *)&value, value_type_info,
-                        item_transfer, direction);
+                g_hash_table_iter_init (&hash_table_iter, hash_table);
+                while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
+                    _pygi_argument_release ( (GArgument *) &key, key_type_info,
+                                             item_transfer, direction);
+                    _pygi_argument_release ( (GArgument *) &value, value_type_info,
+                                             item_transfer, direction);
                 }
 
-                g_base_info_unref((GIBaseInfo *)key_type_info);
-                g_base_info_unref((GIBaseInfo *)value_type_info);
+                g_base_info_unref ( (GIBaseInfo *) key_type_info);
+                g_base_info_unref ( (GIBaseInfo *) value_type_info);
             } else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
                 /* Be careful to avoid keys and values being freed if the
                  * callee gave a destroy function. */
-                g_hash_table_steal_all(hash_table);
+                g_hash_table_steal_all (hash_table);
             }
 
-            if ((direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
+            if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
-                g_hash_table_unref(hash_table);
+                g_hash_table_unref (hash_table);
             }
 
             break;
@@ -1928,13 +1928,13 @@ _pygi_argument_release (GArgument   *arg,
                 return;
             }
 
-            error = *(GError **)arg->v_pointer;
+            error = * (GError **) arg->v_pointer;
 
             if (error != NULL) {
-                g_error_free(error);
+                g_error_free (error);
             }
 
-            g_slice_free(GError *, arg->v_pointer);
+            g_slice_free (GError *, arg->v_pointer);
             break;
         }
     }
diff --git a/gi/pygi-boxed.c b/gi/pygi-boxed.c
index c320796..4903834 100644
--- a/gi/pygi-boxed.c
+++ b/gi/pygi-boxed.c
@@ -31,20 +31,20 @@ _boxed_dealloc (PyGIBoxed *self)
 {
     GType g_type;
 
-    PyObject_GC_UnTrack((PyObject *)self);
+    PyObject_GC_UnTrack ( (PyObject *) self);
 
-    PyObject_ClearWeakRefs((PyObject *)self);
+    PyObject_ClearWeakRefs ( (PyObject *) self);
 
-    if (((PyGBoxed *)self)->free_on_dealloc) {
+    if ( ( (PyGBoxed *) self)->free_on_dealloc) {
         if (self->slice_allocated) {
-            g_slice_free1(self->size, ((PyGBoxed *)self)->boxed);
+            g_slice_free1 (self->size, ( (PyGBoxed *) self)->boxed);
         } else {
-            g_type = pyg_type_from_object((PyObject *)self);
-            g_boxed_free (g_type, ((PyGBoxed *)self)->boxed);
+            g_type = pyg_type_from_object ( (PyObject *) self);
+            g_boxed_free (g_type, ( (PyGBoxed *) self)->boxed);
         }
     }
 
-    ((PyGObject *)self)->ob_type->tp_free((PyObject *)self);
+    ( (PyGObject *) self)->ob_type->tp_free ( (PyObject *) self);
 }
 
 static PyObject *
@@ -59,42 +59,42 @@ _boxed_new (PyTypeObject *type,
     gpointer boxed;
     PyGIBoxed *self = NULL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "", kwlist)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs, "", kwlist)) {
         return NULL;
     }
 
-    info = _pygi_object_get_gi_info((PyObject *)type, &PyGIBaseInfo_Type);
+    info = _pygi_object_get_gi_info ( (PyObject *) type, &PyGIBaseInfo_Type);
     if (info == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-            PyErr_Format(PyExc_TypeError, "missing introspection information");
+        if (PyErr_ExceptionMatches (PyExc_AttributeError)) {
+            PyErr_Format (PyExc_TypeError, "missing introspection information");
         }
         return NULL;
     }
 
-    switch (g_base_info_get_type(info)) {
+    switch (g_base_info_get_type (info)) {
         case GI_INFO_TYPE_UNION:
-            size = g_union_info_get_size((GIUnionInfo *)info);
+            size = g_union_info_get_size ( (GIUnionInfo *) info);
             break;
         case GI_INFO_TYPE_BOXED:
         case GI_INFO_TYPE_STRUCT:
-            size = g_struct_info_get_size((GIStructInfo *)info);
+            size = g_struct_info_get_size ( (GIStructInfo *) info);
             break;
         default:
-            PyErr_Format(PyExc_TypeError,
-                         "info should be Boxed or Union, not '%d'",
-                         g_base_info_get_type(info));
+            PyErr_Format (PyExc_TypeError,
+                          "info should be Boxed or Union, not '%d'",
+                          g_base_info_get_type (info));
             return NULL;
     }
 
-    boxed = g_slice_alloc0(size);
+    boxed = g_slice_alloc0 (size);
     if (boxed == NULL) {
         PyErr_NoMemory();
         goto out;
     }
 
-    self = (PyGIBoxed *)_pygi_boxed_new(type, boxed, TRUE);
+    self = (PyGIBoxed *) _pygi_boxed_new (type, boxed, TRUE);
     if (self == NULL) {
-        g_slice_free1(size, boxed);
+        g_slice_free1 (size, boxed);
         goto out;
     }
 
@@ -102,15 +102,15 @@ _boxed_new (PyTypeObject *type,
     self->slice_allocated = TRUE;
 
 out:
-    g_base_info_unref(info);
+    g_base_info_unref (info);
 
-    return (PyObject *)self;
+    return (PyObject *) self;
 }
 
 static int
 _boxed_init (PyObject *self,
-              PyObject *args,
-              PyObject *kwargs)
+             PyObject *args,
+             PyObject *kwargs)
 {
     /* Don't call PyGBoxed's init, which raises an exception. */
     return 0;
@@ -118,38 +118,38 @@ _boxed_init (PyObject *self,
 
 
 PyTypeObject PyGIBoxed_Type = {
-    PyObject_HEAD_INIT(NULL)
+    PyObject_HEAD_INIT (NULL)
     0,
     "gi.Boxed",                                /* tp_name */
-    sizeof(PyGIBoxed),                         /* tp_basicsize */
+    sizeof (PyGIBoxed),                        /* tp_basicsize */
     0,                                         /* tp_itemsize */
-    (destructor)_boxed_dealloc,                /* tp_dealloc */
-    (printfunc)NULL,                           /* tp_print */
-    (getattrfunc)NULL,                         /* tp_getattr */
-    (setattrfunc)NULL,                         /* tp_setattr */
-    (cmpfunc)NULL,                             /* tp_compare */
-    (reprfunc)NULL,                            /* tp_repr */
+    (destructor) _boxed_dealloc,               /* tp_dealloc */
+    (printfunc) NULL,                          /* tp_print */
+    (getattrfunc) NULL,                        /* tp_getattr */
+    (setattrfunc) NULL,                        /* tp_setattr */
+    (cmpfunc) NULL,                            /* tp_compare */
+    (reprfunc) NULL,                           /* tp_repr */
     NULL,                                      /* tp_as_number */
     NULL,                                      /* tp_as_sequence */
     NULL,                                      /* tp_as_mapping */
-    (hashfunc)NULL,                            /* tp_hash */
-    (ternaryfunc)NULL,                         /* tp_call */
-    (reprfunc)NULL,                            /* tp_str */
-    (getattrofunc)NULL,                        /* tp_getattro */
-    (setattrofunc)NULL,                        /* tp_setattro */
+    (hashfunc) NULL,                           /* tp_hash */
+    (ternaryfunc) NULL,                        /* tp_call */
+    (reprfunc) NULL,                           /* tp_str */
+    (getattrofunc) NULL,                       /* tp_getattro */
+    (setattrofunc) NULL,                       /* tp_setattro */
     NULL,                                      /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */
     NULL,                                      /* tp_doc */
-    (traverseproc)NULL,                        /* tp_traverse */
-    (inquiry)NULL,                             /* tp_clear */
-    (richcmpfunc)NULL,                         /* tp_richcompare */
+    (traverseproc) NULL,                       /* tp_traverse */
+    (inquiry) NULL,                            /* tp_clear */
+    (richcmpfunc) NULL,                        /* tp_richcompare */
     0,                                         /* tp_weaklistoffset */
-    (getiterfunc)NULL,                         /* tp_iter */
-    (iternextfunc)NULL,                        /* tp_iternext */
+    (getiterfunc) NULL,                        /* tp_iter */
+    (iternextfunc) NULL,                       /* tp_iternext */
     NULL,                                      /* tp_methods */
     NULL,                                      /* tp_members */
     NULL,                                      /* tp_getset */
-    (PyTypeObject *)NULL,                      /* tp_base */
+    (PyTypeObject *) NULL,                     /* tp_base */
 };
 
 PyObject *
@@ -163,23 +163,23 @@ _pygi_boxed_new (PyTypeObject *type,
         Py_RETURN_NONE;
     }
 
-    if (!PyType_IsSubtype(type, &PyGIBoxed_Type)) {
-        PyErr_SetString(PyExc_TypeError, "must be a subtype of gi.Boxed");
+    if (!PyType_IsSubtype (type, &PyGIBoxed_Type)) {
+        PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Boxed");
         return NULL;
     }
 
-    self = (PyGIBoxed *)type->tp_alloc(type, 0);
+    self = (PyGIBoxed *) type->tp_alloc (type, 0);
     if (self == NULL) {
         return NULL;
     }
 
-    ((PyGBoxed *)self)->gtype = pyg_type_from_object((PyObject *)type);
-    ((PyGBoxed *)self)->boxed = boxed;
-    ((PyGBoxed *)self)->free_on_dealloc = free_on_dealloc;
+    ( (PyGBoxed *) self)->gtype = pyg_type_from_object ( (PyObject *) type);
+    ( (PyGBoxed *) self)->boxed = boxed;
+    ( (PyGBoxed *) self)->free_on_dealloc = free_on_dealloc;
     self->size = 0;
     self->slice_allocated = FALSE;
 
-    return (PyObject *)self;
+    return (PyObject *) self;
 }
 
 void
@@ -187,10 +187,10 @@ _pygi_boxed_register_types (PyObject *m)
 {
     PyGIBoxed_Type.ob_type = &PyType_Type;
     PyGIBoxed_Type.tp_base = &PyGBoxed_Type;
-    PyGIBoxed_Type.tp_new = (newfunc)_boxed_new;
-    PyGIBoxed_Type.tp_init = (initproc)_boxed_init;
-    if (PyType_Ready(&PyGIBoxed_Type))
+    PyGIBoxed_Type.tp_new = (newfunc) _boxed_new;
+    PyGIBoxed_Type.tp_init = (initproc) _boxed_init;
+    if (PyType_Ready (&PyGIBoxed_Type))
         return;
-    if (PyModule_AddObject(m, "Boxed", (PyObject *)&PyGIBoxed_Type))
+    if (PyModule_AddObject (m, "Boxed", (PyObject *) &PyGIBoxed_Type))
         return;
 }
diff --git a/gi/pygi-callbacks.c b/gi/pygi-callbacks.c
index 50bd62a..ac9ca6a 100644
--- a/gi/pygi-callbacks.c
+++ b/gi/pygi-callbacks.c
@@ -24,41 +24,41 @@
 static PyGICClosure *global_destroy_notify;
 
 static void
-_pygi_destroy_notify_callback_closure(ffi_cif *cif,
-                                      void *result,
-                                      void **args,
-                                      void *data)
+_pygi_destroy_notify_callback_closure (ffi_cif *cif,
+                                       void *result,
+                                       void **args,
+                                       void *data)
 {
-    PyGICClosure *info = *(void**)(args[0]);
+    PyGICClosure *info = * (void**) (args[0]);
 
-    g_assert(info);
+    g_assert (info);
 
-    _pygi_invoke_closure_free(info);    
+    _pygi_invoke_closure_free (info);
 }
 
 
 PyGICClosure*
-_pygi_destroy_notify_create(void)
+_pygi_destroy_notify_create (void)
 {
     if (!global_destroy_notify) {
-        
+
         ffi_status status;
-        PyGICClosure *destroy_notify = g_slice_new0(PyGICClosure);        
-
-        g_assert(destroy_notify);
-        
-        GIBaseInfo* glib_destroy_notify = g_irepository_find_by_name(NULL, "GLib", "DestroyNotify");
-        g_assert(glib_destroy_notify != NULL);
-        g_assert(g_base_info_get_type(glib_destroy_notify) == GI_INFO_TYPE_CALLBACK);
-        
-        destroy_notify->closure = g_callable_info_prepare_closure((GICallableInfo*)glib_destroy_notify,
-                                                                  &destroy_notify->cif,
-                                                                  _pygi_destroy_notify_callback_closure,
-                                                                  NULL);
+        PyGICClosure *destroy_notify = g_slice_new0 (PyGICClosure);
+
+        g_assert (destroy_notify);
+
+        GIBaseInfo* glib_destroy_notify = g_irepository_find_by_name (NULL, "GLib", "DestroyNotify");
+        g_assert (glib_destroy_notify != NULL);
+        g_assert (g_base_info_get_type (glib_destroy_notify) == GI_INFO_TYPE_CALLBACK);
+
+        destroy_notify->closure = g_callable_info_prepare_closure ( (GICallableInfo*) glib_destroy_notify,
+                                                                    &destroy_notify->cif,
+                                                                    _pygi_destroy_notify_callback_closure,
+                                                                    NULL);
 
         global_destroy_notify = destroy_notify;
     }
-    
+
     return global_destroy_notify;
 }
 
@@ -76,7 +76,7 @@ _pygi_scan_for_callbacks (GIFunctionInfo *function_info,
     *user_data_index = G_MAXUINT8;
     *destroy_notify_index = G_MAXUINT8;
 
-    n_args = g_callable_info_get_n_args((GICallableInfo *)function_info);
+    n_args = g_callable_info_get_n_args ( (GICallableInfo *) function_info);
     for (i = 0; i < n_args; i++) {
         GIDirection direction;
         GIArgInfo *arg_info;
@@ -84,42 +84,42 @@ _pygi_scan_for_callbacks (GIFunctionInfo *function_info,
         guint8 destroy, closure;
         GITypeTag type_tag;
 
-        arg_info = g_callable_info_get_arg((GICallableInfo*) function_info, i);
-        type_info = g_arg_info_get_type(arg_info);
-        type_tag = g_type_info_get_tag(type_info);    
+        arg_info = g_callable_info_get_arg ( (GICallableInfo*) function_info, i);
+        type_info = g_arg_info_get_type (arg_info);
+        type_tag = g_type_info_get_tag (type_info);
 
         if (type_tag == GI_TYPE_TAG_INTERFACE) {
             GIBaseInfo* interface_info;
             GIInfoType interface_type;
 
-            interface_info = g_type_info_get_interface(type_info);
-            interface_type = g_base_info_get_type(interface_info);
+            interface_info = g_type_info_get_interface (type_info);
+            interface_type = g_base_info_get_type (interface_info);
             if (interface_type == GI_INFO_TYPE_CALLBACK &&
-                !(strcmp(g_base_info_get_namespace((GIBaseInfo*) interface_info), "GLib") == 0 &&
-                  strcmp(g_base_info_get_name((GIBaseInfo*) interface_info), "DestroyNotify") == 0)) {
+                    ! (strcmp (g_base_info_get_namespace ( (GIBaseInfo*) interface_info), "GLib") == 0 &&
+                       strcmp (g_base_info_get_name ( (GIBaseInfo*) interface_info), "DestroyNotify") == 0)) {
                 if (*callback_index != G_MAXUINT8) {
-                    PyErr_Format(PyExc_TypeError, "Function %s.%s has multiple callbacks, not supported",
-                              g_base_info_get_namespace((GIBaseInfo*) function_info),
-                              g_base_info_get_name((GIBaseInfo*) function_info));
-                    g_base_info_unref(interface_info);
+                    PyErr_Format (PyExc_TypeError, "Function %s.%s has multiple callbacks, not supported",
+                                  g_base_info_get_namespace ( (GIBaseInfo*) function_info),
+                                  g_base_info_get_name ( (GIBaseInfo*) function_info));
+                    g_base_info_unref (interface_info);
                     return FALSE;
                 }
                 *callback_index = i;
             }
-            g_base_info_unref(interface_info);
+            g_base_info_unref (interface_info);
         }
-        destroy = g_arg_info_get_destroy(arg_info);
+        destroy = g_arg_info_get_destroy (arg_info);
         if (is_method)
             --destroy;
-        closure = g_arg_info_get_closure(arg_info);
+        closure = g_arg_info_get_closure (arg_info);
         if (is_method)
             --closure;
-        direction = g_arg_info_get_direction(arg_info);
+        direction = g_arg_info_get_direction (arg_info);
 
         if (destroy > 0 && destroy < n_args) {
             if (*destroy_notify_index != G_MAXUINT8) {
-                PyErr_Format(PyExc_TypeError, "Function %s has multiple GDestroyNotify, not supported",
-                             g_base_info_get_name((GIBaseInfo*)function_info));
+                PyErr_Format (PyExc_TypeError, "Function %s has multiple GDestroyNotify, not supported",
+                              g_base_info_get_name ( (GIBaseInfo*) function_info));
                 return FALSE;
             }
             *destroy_notify_index = destroy;
@@ -127,15 +127,15 @@ _pygi_scan_for_callbacks (GIFunctionInfo *function_info,
 
         if (closure > 0 && closure < n_args) {
             if (*user_data_index != G_MAXUINT8) {
-                 PyErr_Format(PyExc_TypeError, "Function %s has multiple user_data arguments, not supported",
-                          g_base_info_get_name((GIBaseInfo*)function_info));
+                PyErr_Format (PyExc_TypeError, "Function %s has multiple user_data arguments, not supported",
+                              g_base_info_get_name ( (GIBaseInfo*) function_info));
                 return FALSE;
             }
             *user_data_index = closure;
         }
 
-        g_base_info_unref((GIBaseInfo*)arg_info);
-        g_base_info_unref((GIBaseInfo*)type_info);
+        g_base_info_unref ( (GIBaseInfo*) arg_info);
+        g_base_info_unref ( (GIBaseInfo*) type_info);
     }
 
     return TRUE;
@@ -143,15 +143,15 @@ _pygi_scan_for_callbacks (GIFunctionInfo *function_info,
 
 gboolean
 _pygi_create_callback (GIBaseInfo  *function_info,
-                        gboolean       is_method,
-                        gboolean       is_constructor,
-                        int            n_args,
-                        Py_ssize_t     py_argc,
-                        PyObject      *py_argv,
-                        guint8         callback_index,
-                        guint8         user_data_index,
-                        guint8         destroy_notify_index,
-                        PyGICClosure **closure_out)
+                       gboolean       is_method,
+                       gboolean       is_constructor,
+                       int            n_args,
+                       Py_ssize_t     py_argc,
+                       PyObject      *py_argv,
+                       guint8         callback_index,
+                       guint8         user_data_index,
+                       guint8         destroy_notify_index,
+                       PyGICClosure **closure_out)
 {
     GIArgInfo *callback_arg;
     GITypeInfo *callback_type;
@@ -162,20 +162,20 @@ _pygi_create_callback (GIBaseInfo  *function_info,
     guint8 i, py_argv_pos;
     PyObject *py_user_data;
 
-    callback_arg = g_callable_info_get_arg((GICallableInfo*) function_info, callback_index);
-    scope = g_arg_info_get_scope(callback_arg);
+    callback_arg = g_callable_info_get_arg ( (GICallableInfo*) function_info, callback_index);
+    scope = g_arg_info_get_scope (callback_arg);
 
-    callback_type = g_arg_info_get_type(callback_arg);
-    g_assert(g_type_info_get_tag(callback_type) == GI_TYPE_TAG_INTERFACE);
+    callback_type = g_arg_info_get_type (callback_arg);
+    g_assert (g_type_info_get_tag (callback_type) == GI_TYPE_TAG_INTERFACE);
 
-    callback_info = (GICallbackInfo*)g_type_info_get_interface(callback_type);
-    g_assert(g_base_info_get_type((GIBaseInfo*)callback_info) == GI_INFO_TYPE_CALLBACK);
+    callback_info = (GICallbackInfo*) g_type_info_get_interface (callback_type);
+    g_assert (g_base_info_get_type ( (GIBaseInfo*) callback_info) == GI_INFO_TYPE_CALLBACK);
 
     /* Find the Python function passed for the callback */
     found_py_function = FALSE;
     py_function = Py_None;
     py_user_data = NULL;
-    
+
     /* if its a method then we need to skip over 'self' */
     if (is_method || is_constructor)
         py_argv_pos = 1;
@@ -184,33 +184,33 @@ _pygi_create_callback (GIBaseInfo  *function_info,
 
     for (i = 0; i < n_args && i < py_argc; i++) {
         if (i == callback_index) {
-            py_function = PyTuple_GetItem(py_argv, py_argv_pos);
+            py_function = PyTuple_GetItem (py_argv, py_argv_pos);
             found_py_function = TRUE;
-        } else if (i == user_data_index){
-            py_user_data = PyTuple_GetItem(py_argv, py_argv_pos);
+        } else if (i == user_data_index) {
+            py_user_data = PyTuple_GetItem (py_argv, py_argv_pos);
         }
         py_argv_pos++;
     }
 
     if (!found_py_function
-        || (py_function == Py_None || !PyCallable_Check(py_function))) {
-        PyErr_Format(PyExc_TypeError, "Error invoking %s.%s: Invalid callback given for argument %s",
-                  g_base_info_get_namespace((GIBaseInfo*) function_info),
-                  g_base_info_get_name((GIBaseInfo*) function_info),
-                  g_base_info_get_name((GIBaseInfo*) callback_arg));
-        g_base_info_unref((GIBaseInfo*) callback_info);
-        g_base_info_unref((GIBaseInfo*) callback_type);
+            || (py_function == Py_None || !PyCallable_Check (py_function))) {
+        PyErr_Format (PyExc_TypeError, "Error invoking %s.%s: Invalid callback given for argument %s",
+                      g_base_info_get_namespace ( (GIBaseInfo*) function_info),
+                      g_base_info_get_name ( (GIBaseInfo*) function_info),
+                      g_base_info_get_name ( (GIBaseInfo*) callback_arg));
+        g_base_info_unref ( (GIBaseInfo*) callback_info);
+        g_base_info_unref ( (GIBaseInfo*) callback_type);
         return FALSE;
     }
 
     /** Now actually build the closure **/
-    *closure_out = _pygi_make_native_closure((GICallableInfo *)callback_info,
-                                             g_arg_info_get_scope(callback_arg),
-                                             py_function,
-                                             py_user_data);
-    
-    g_base_info_unref((GIBaseInfo*) callback_info);
-    g_base_info_unref((GIBaseInfo*) callback_type);
+    *closure_out = _pygi_make_native_closure ( (GICallableInfo *) callback_info,
+                                               g_arg_info_get_scope (callback_arg),
+                                               py_function,
+                                               py_user_data);
+
+    g_base_info_unref ( (GIBaseInfo*) callback_info);
+    g_base_info_unref ( (GIBaseInfo*) callback_type);
 
     return TRUE;
 }
diff --git a/gi/pygi-callbacks.h b/gi/pygi-callbacks.h
index c2b137e..7535bba 100644
--- a/gi/pygi-callbacks.h
+++ b/gi/pygi-callbacks.h
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset: 4 -*-
  * vim: tabstop=4 shiftwidth=4 expandtab
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -22,9 +22,9 @@
 
 G_BEGIN_DECLS
 
-void _pygi_callback_notify_info_free(gpointer user_data);
- 
-PyGICClosure*_pygi_destroy_notify_create(void);
+void _pygi_callback_notify_info_free (gpointer user_data);
+
+PyGICClosure*_pygi_destroy_notify_create (void);
 
 gboolean _pygi_scan_for_callbacks (GIFunctionInfo *self,
                                    gboolean       is_method,
diff --git a/gi/pygi-closure.c b/gi/pygi-closure.c
index d3e32fa..a752ae2 100644
--- a/gi/pygi-closure.c
+++ b/gi/pygi-closure.c
@@ -29,7 +29,7 @@ static GSList* async_free_list;
 
 
 static GArgument *
-_pygi_closure_convert_ffi_arguments(GICallableInfo *callable_info, void **args)
+_pygi_closure_convert_ffi_arguments (GICallableInfo *callable_info, void **args)
 {
     gint num_args, i;
     GIArgInfo *arg_info;
@@ -38,145 +38,145 @@ _pygi_closure_convert_ffi_arguments(GICallableInfo *callable_info, void **args)
     GIDirection direction;
     GArgument *g_args;
 
-    num_args = g_callable_info_get_n_args(callable_info);
-    g_args = g_new0(GArgument, num_args);
+    num_args = g_callable_info_get_n_args (callable_info);
+    g_args = g_new0 (GArgument, num_args);
 
     for (i = 0; i < num_args; i++) {
-        arg_info = g_callable_info_get_arg(callable_info, i);
-        arg_type = g_arg_info_get_type(arg_info);
-        tag = g_type_info_get_tag(arg_type);
-        direction = g_arg_info_get_direction(arg_info);
+        arg_info = g_callable_info_get_arg (callable_info, i);
+        arg_type = g_arg_info_get_type (arg_info);
+        tag = g_type_info_get_tag (arg_type);
+        direction = g_arg_info_get_direction (arg_info);
 
         if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
-            g_args[i].v_pointer = *(gpointer *) args[i];
+            g_args[i].v_pointer = * (gpointer *) args[i];
         } else {
             switch (tag) {
                 case GI_TYPE_TAG_BOOLEAN:
-                    g_args[i].v_boolean = *(gboolean *) args[i];
+                    g_args[i].v_boolean = * (gboolean *) args[i];
                     break;
                 case GI_TYPE_TAG_INT8:
-                    g_args[i].v_int8 = *(gint8 *) args[i];
+                    g_args[i].v_int8 = * (gint8 *) args[i];
                     break;
                 case GI_TYPE_TAG_UINT8:
-                    g_args[i].v_uint8 = *(guint8 *) args[i];
+                    g_args[i].v_uint8 = * (guint8 *) args[i];
                     break;
                 case GI_TYPE_TAG_INT16:
-                    g_args[i].v_int16 = *(gint16 *) args[i];
+                    g_args[i].v_int16 = * (gint16 *) args[i];
                     break;
                 case GI_TYPE_TAG_UINT16:
-                    g_args[i].v_uint16 = *(guint16 *) args[i];
+                    g_args[i].v_uint16 = * (guint16 *) args[i];
                     break;
                 case GI_TYPE_TAG_INT32:
-                    g_args[i].v_int32 = *(gint32 *) args[i];
+                    g_args[i].v_int32 = * (gint32 *) args[i];
                     break;
                 case GI_TYPE_TAG_UINT32:
-                    g_args[i].v_uint32 = *(guint32 *) args[i];
+                    g_args[i].v_uint32 = * (guint32 *) args[i];
                     break;
                 case GI_TYPE_TAG_LONG:
                 case GI_TYPE_TAG_INT64:
-                    g_args[i].v_int64 = *(glong *) args[i];
+                    g_args[i].v_int64 = * (glong *) args[i];
                     break;
                 case GI_TYPE_TAG_ULONG:
                 case GI_TYPE_TAG_UINT64:
-                    g_args[i].v_uint64 = *(glong *) args[i];
+                    g_args[i].v_uint64 = * (glong *) args[i];
                     break;
                 case GI_TYPE_TAG_INT:
                 case GI_TYPE_TAG_SSIZE:
                 case GI_TYPE_TAG_SIZE:
-                    g_args[i].v_int32 = *(gint *) args[i];
+                    g_args[i].v_int32 = * (gint *) args[i];
                     break;
                 case GI_TYPE_TAG_UINT:
-                    g_args[i].v_uint32 = *(guint *) args[i];
+                    g_args[i].v_uint32 = * (guint *) args[i];
                     break;
                 case GI_TYPE_TAG_FLOAT:
-                    g_args[i].v_float = *(gfloat *) args[i];
+                    g_args[i].v_float = * (gfloat *) args[i];
                     break;
                 case GI_TYPE_TAG_DOUBLE:
-                    g_args[i].v_double = *(gdouble *) args[i];
+                    g_args[i].v_double = * (gdouble *) args[i];
                     break;
                 case GI_TYPE_TAG_UTF8:
-                    g_args[i].v_string = *(gchar **) args[i];
+                    g_args[i].v_string = * (gchar **) args[i];
                     break;
                 case GI_TYPE_TAG_INTERFACE:
-                    {
-                        GIBaseInfo *interface;
-                        GIInfoType interface_type;
-
-                        interface = g_type_info_get_interface(arg_type);
-                        interface_type = g_base_info_get_type(interface);
-
-                        if (interface_type == GI_INFO_TYPE_OBJECT ||
-                                interface_type == GI_INFO_TYPE_INTERFACE) {
-                            g_args[i].v_pointer = *(gpointer *) args[i];
-                            g_base_info_unref(interface);
-                            break;
-                        } else if (interface_type == GI_INFO_TYPE_ENUM ||
-                                   interface_type == GI_INFO_TYPE_FLAGS) {
-                            g_args[i].v_double = *(double *) args[i];
-                            g_base_info_unref(interface);
-                            break;
-                        } else if (interface_type == GI_INFO_TYPE_STRUCT) {
-                            g_args[i].v_pointer = *(gpointer *) args[i];
-                            g_base_info_unref(interface);
-                            break;
-                        }
-
-                        g_base_info_unref(interface);
+                {
+                    GIBaseInfo *interface;
+                    GIInfoType interface_type;
+
+                    interface = g_type_info_get_interface (arg_type);
+                    interface_type = g_base_info_get_type (interface);
+
+                    if (interface_type == GI_INFO_TYPE_OBJECT ||
+                            interface_type == GI_INFO_TYPE_INTERFACE) {
+                        g_args[i].v_pointer = * (gpointer *) args[i];
+                        g_base_info_unref (interface);
+                        break;
+                    } else if (interface_type == GI_INFO_TYPE_ENUM ||
+                               interface_type == GI_INFO_TYPE_FLAGS) {
+                        g_args[i].v_double = * (double *) args[i];
+                        g_base_info_unref (interface);
+                        break;
+                    } else if (interface_type == GI_INFO_TYPE_STRUCT) {
+                        g_args[i].v_pointer = * (gpointer *) args[i];
+                        g_base_info_unref (interface);
+                        break;
                     }
+
+                    g_base_info_unref (interface);
+                }
                 case GI_TYPE_TAG_GLIST:
                 case GI_TYPE_TAG_GSLIST:
-                    g_args[i].v_pointer = *(gpointer *) args[i];
+                    g_args[i].v_pointer = * (gpointer *) args[i];
                     break;
                 default:
                     g_args[i].v_pointer = 0;
             }
         }
-        g_base_info_unref((GIBaseInfo *) arg_info);
-        g_base_info_unref((GIBaseInfo *) arg_type);
+        g_base_info_unref ( (GIBaseInfo *) arg_info);
+        g_base_info_unref ( (GIBaseInfo *) arg_type);
     }
     return g_args;
 }
 
 static gboolean
-_pygi_closure_convert_arguments(GICallableInfo *callable_info, void **args,
+_pygi_closure_convert_arguments (GICallableInfo *callable_info, void **args,
                                  void *user_data, PyObject **py_args,
                                  GArgument **out_args)
 {
-    int n_args = g_callable_info_get_n_args(callable_info);
+    int n_args = g_callable_info_get_n_args (callable_info);
     int n_in_args = 0;
     int n_out_args = 0;
     int i;
     GArgument *g_args = NULL;
 
     *py_args = NULL;
-    *py_args = PyTuple_New(n_args);
+    *py_args = PyTuple_New (n_args);
     if (*py_args == NULL)
         goto error;
 
     *out_args = NULL;
-    *out_args = g_new0(GArgument, n_args);
-    g_args = _pygi_closure_convert_ffi_arguments(callable_info, args);
+    *out_args = g_new0 (GArgument, n_args);
+    g_args = _pygi_closure_convert_ffi_arguments (callable_info, args);
 
     for (i = 0; i < n_args; i++) {
-        GIArgInfo *arg_info = g_callable_info_get_arg(callable_info, i);
-        GIDirection direction = g_arg_info_get_direction(arg_info);
+        GIArgInfo *arg_info = g_callable_info_get_arg (callable_info, i);
+        GIDirection direction = g_arg_info_get_direction (arg_info);
 
         if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
-            GITypeInfo *arg_type = g_arg_info_get_type(arg_info);
-            GITypeTag arg_tag = g_type_info_get_tag(arg_type);
-            GITransfer transfer = g_arg_info_get_ownership_transfer(arg_info);
+            GITypeInfo *arg_type = g_arg_info_get_type (arg_info);
+            GITypeTag arg_tag = g_type_info_get_tag (arg_type);
+            GITransfer transfer = g_arg_info_get_ownership_transfer (arg_info);
             PyObject *value;
             GArgument *arg;
 
             if (direction == GI_DIRECTION_IN && arg_tag == GI_TYPE_TAG_VOID &&
-                g_type_info_is_pointer(arg_type)) {
+                    g_type_info_is_pointer (arg_type)) {
 
                 if (user_data == NULL) {
-                    Py_INCREF(Py_None);
+                    Py_INCREF (Py_None);
                     value = Py_None;
                 } else {
                     value = user_data;
-                    Py_INCREF(value);
+                    Py_INCREF (value);
                 }
             } else {
                 if (direction == GI_DIRECTION_IN)
@@ -184,46 +184,46 @@ _pygi_closure_convert_arguments(GICallableInfo *callable_info, void **args,
                 else
                     arg = (GArgument*) g_args[i].v_pointer;
 
-                value = _pygi_argument_to_object(arg, arg_type, transfer);
+                value = _pygi_argument_to_object (arg, arg_type, transfer);
                 if (value == NULL) {
-                    g_base_info_unref(arg_type);
-                    g_base_info_unref(arg_info);
+                    g_base_info_unref (arg_type);
+                    g_base_info_unref (arg_info);
                     goto error;
                 }
             }
-            PyTuple_SET_ITEM(*py_args, n_in_args, value);
+            PyTuple_SET_ITEM (*py_args, n_in_args, value);
             n_in_args++;
 
-            g_base_info_unref(arg_type);
+            g_base_info_unref (arg_type);
         }
 
         if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
-            (*out_args)[n_out_args] = g_args[i];
+            (*out_args) [n_out_args] = g_args[i];
             n_out_args++;
         }
 
-        g_base_info_unref(arg_info);
+        g_base_info_unref (arg_info);
     }
 
-    if (_PyTuple_Resize(py_args, n_in_args) == -1)
+    if (_PyTuple_Resize (py_args, n_in_args) == -1)
         goto error;
 
     return TRUE;
 
 error:
-    Py_CLEAR(*py_args);
+    Py_CLEAR (*py_args);
 
     if (*out_args != NULL)
-        g_free(*out_args);
+        g_free (*out_args);
 
     if (g_args != NULL)
-        g_free(g_args);
+        g_free (g_args);
 
     return FALSE;
 }
 
 static void
-_pygi_closure_set_out_arguments(GICallableInfo *callable_info,
+_pygi_closure_set_out_arguments (GICallableInfo *callable_info,
                                  PyObject *py_retval, GArgument *out_args,
                                  void *resp)
 {
@@ -232,48 +232,48 @@ _pygi_closure_set_out_arguments(GICallableInfo *callable_info,
     GITypeTag return_type_tag;
 
     i_py_retval = 0;
-    return_type_info = g_callable_info_get_return_type(callable_info);
-    return_type_tag = g_type_info_get_tag(return_type_info);
+    return_type_info = g_callable_info_get_return_type (callable_info);
+    return_type_tag = g_type_info_get_tag (return_type_info);
     if (return_type_tag != GI_TYPE_TAG_VOID) {
         GArgument arg;
-        GITransfer transfer = g_callable_info_get_caller_owns(callable_info);
-        if (PyTuple_Check(py_retval)) {
-            PyObject *item = PyTuple_GET_ITEM(py_retval, 0);
-            arg = _pygi_argument_from_object(item, return_type_info, transfer);
-            *((GArgument*)resp) = arg;
+        GITransfer transfer = g_callable_info_get_caller_owns (callable_info);
+        if (PyTuple_Check (py_retval)) {
+            PyObject *item = PyTuple_GET_ITEM (py_retval, 0);
+            arg = _pygi_argument_from_object (item, return_type_info, transfer);
+            * ( (GArgument*) resp) = arg;
         } else {
-            arg = _pygi_argument_from_object(py_retval, return_type_info, transfer);
-            *((GArgument*)resp) = arg;
+            arg = _pygi_argument_from_object (py_retval, return_type_info, transfer);
+            * ( (GArgument*) resp) = arg;
         }
         i_py_retval++;
     }
-    g_base_info_unref(return_type_info);
+    g_base_info_unref (return_type_info);
 
     i_out_args = 0;
-    n_args = g_callable_info_get_n_args(callable_info);
+    n_args = g_callable_info_get_n_args (callable_info);
     for (i = 1; i < n_args; i++) {
-        GIArgInfo *arg_info = g_callable_info_get_arg(callable_info, i);
-        GITypeInfo *type_info = g_arg_info_get_type(arg_info);
-        GIDirection direction = g_arg_info_get_direction(arg_info);
+        GIArgInfo *arg_info = g_callable_info_get_arg (callable_info, i);
+        GITypeInfo *type_info = g_arg_info_get_type (arg_info);
+        GIDirection direction = g_arg_info_get_direction (arg_info);
 
         if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
-            GITransfer transfer = g_arg_info_get_ownership_transfer(arg_info);
+            GITransfer transfer = g_arg_info_get_ownership_transfer (arg_info);
             GArgument arg;
-            if (PyTuple_Check(py_retval)) {
-                PyObject *item = PyTuple_GET_ITEM(py_retval, i_py_retval);
-                arg = _pygi_argument_from_object(item, type_info, transfer);
-                *((GArgument*)out_args[i_out_args].v_pointer) = arg;
+            if (PyTuple_Check (py_retval)) {
+                PyObject *item = PyTuple_GET_ITEM (py_retval, i_py_retval);
+                arg = _pygi_argument_from_object (item, type_info, transfer);
+                * ( (GArgument*) out_args[i_out_args].v_pointer) = arg;
             } else if (i_py_retval == 0) {
-                arg = _pygi_argument_from_object(py_retval, type_info, transfer);
-                *((GArgument*)out_args[i_out_args].v_pointer) = arg;
+                arg = _pygi_argument_from_object (py_retval, type_info, transfer);
+                * ( (GArgument*) out_args[i_out_args].v_pointer) = arg;
             } else
                 g_assert_not_reached();
 
             i_out_args++;
             i_py_retval++;
         }
-        g_base_info_unref(type_info);
-        g_base_info_unref(arg_info);
+        g_base_info_unref (type_info);
+        g_base_info_unref (arg_info);
     }
 }
 
@@ -296,69 +296,69 @@ _pygi_closure_handle (ffi_cif *cif,
       may be executing python code */
     state = PyGILState_Ensure();
 
-    return_type = g_callable_info_get_return_type(closure->info);
-    return_tag = g_type_info_get_tag(return_type);
-    return_transfer = g_callable_info_get_caller_owns(closure->info);
+    return_type = g_callable_info_get_return_type (closure->info);
+    return_tag = g_type_info_get_tag (return_type);
+    return_transfer = g_callable_info_get_caller_owns (closure->info);
 
-    if (!_pygi_closure_convert_arguments((GICallableInfo *)closure->info, args,
-                                         closure->user_data,
-                                         &py_args, &out_args)) {
+    if (!_pygi_closure_convert_arguments ( (GICallableInfo *) closure->info, args,
+                                           closure->user_data,
+                                           &py_args, &out_args)) {
         if (PyErr_Occurred ())
             PyErr_Print();
         goto end;
     }
 
-    retval = PyObject_CallObject((PyObject *)closure->function, py_args);
-    Py_DECREF(py_args);
+    retval = PyObject_CallObject ( (PyObject *) closure->function, py_args);
+    Py_DECREF (py_args);
 
     if (retval == NULL) {
         PyErr_Print();
         goto end;
     }
 
-    _pygi_closure_set_out_arguments(closure->info, retval, out_args, result);
+    _pygi_closure_set_out_arguments (closure->info, retval, out_args, result);
 
 end:
-    g_base_info_unref((GIBaseInfo*)return_type);
+    g_base_info_unref ( (GIBaseInfo*) return_type);
 
-    PyGILState_Release(state);
+    PyGILState_Release (state);
 
     /* Now that the closure has finished we can make a decision about how
        to free it.  Scope call gets free'd at the end of wrap_g_function_info_invoke
-       scope notified will be freed,  when the notify is called and we can free async 
+       scope notified will be freed,  when the notify is called and we can free async
        anytime we want as long as its after we return from this function (you can't free the closure
        you are currently using!)
     */
     switch (closure->scope) {
-    case GI_SCOPE_TYPE_CALL:
-    case GI_SCOPE_TYPE_NOTIFIED:        
-        break;
-    case GI_SCOPE_TYPE_ASYNC:
-        /* Append this PyGICClosure to a list of closure that we will free
-           after we're done with this function invokation */
-        async_free_list = g_slist_prepend(async_free_list, closure);
-        break;
-    default:
-       g_error("Invalid scope reached inside %s.  Possibly a bad annotation?",
-               g_base_info_get_name(closure->info));
+        case GI_SCOPE_TYPE_CALL:
+        case GI_SCOPE_TYPE_NOTIFIED:
+            break;
+        case GI_SCOPE_TYPE_ASYNC:
+            /* Append this PyGICClosure to a list of closure that we will free
+               after we're done with this function invokation */
+            async_free_list = g_slist_prepend (async_free_list, closure);
+            break;
+        default:
+            g_error ("Invalid scope reached inside %s.  Possibly a bad annotation?",
+                     g_base_info_get_name (closure->info));
     }
 }
 
-void _pygi_invoke_closure_free(gpointer data)
+void _pygi_invoke_closure_free (gpointer data)
 {
-    PyGICClosure* invoke_closure = (PyGICClosure *)data;
+    PyGICClosure* invoke_closure = (PyGICClosure *) data;
 
-    Py_DECREF(invoke_closure->function);
+    Py_DECREF (invoke_closure->function);
 
-    g_callable_info_free_closure(invoke_closure->info,
-                                 invoke_closure->closure);
+    g_callable_info_free_closure (invoke_closure->info,
+                                  invoke_closure->closure);
 
     if (invoke_closure->info)
-        g_base_info_unref((GIBaseInfo*)invoke_closure->info);
+        g_base_info_unref ( (GIBaseInfo*) invoke_closure->info);
 
-    Py_XDECREF(invoke_closure->user_data);
+    Py_XDECREF (invoke_closure->user_data);
 
-    g_slice_free(PyGICClosure, invoke_closure);
+    g_slice_free (PyGICClosure, invoke_closure);
 }
 
 
@@ -372,25 +372,25 @@ _pygi_make_native_closure (GICallableInfo* info,
     ffi_closure *fficlosure;
 
     /* Begin by cleaning up old async functions */
-    g_slist_foreach(async_free_list, (GFunc)_pygi_invoke_closure_free, NULL);
-    g_slist_free(async_free_list);
+    g_slist_foreach (async_free_list, (GFunc) _pygi_invoke_closure_free, NULL);
+    g_slist_free (async_free_list);
     async_free_list = NULL;
 
     /* Build the closure itself */
-    closure = g_slice_new0(PyGICClosure);   
-    closure->info = (GICallableInfo *) g_base_info_ref ((GIBaseInfo *) info);  
+    closure = g_slice_new0 (PyGICClosure);
+    closure->info = (GICallableInfo *) g_base_info_ref ( (GIBaseInfo *) info);
     closure->function = py_function;
     closure->user_data = py_user_data;
 
-    Py_INCREF(py_function);
+    Py_INCREF (py_function);
     if (closure->user_data)
-        Py_INCREF(closure->user_data);
+        Py_INCREF (closure->user_data);
 
     fficlosure =
         g_callable_info_prepare_closure (info, &closure->cif, _pygi_closure_handle,
                                          closure);
     closure->closure = fficlosure;
-    
+
     /* Give the closure the information it needs to determine when
        to free itself later */
     closure->scope = scope;
diff --git a/gi/pygi-closure.h b/gi/pygi-closure.h
index 550bf8a..6f98339 100644
--- a/gi/pygi-closure.h
+++ b/gi/pygi-closure.h
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset: 4 -*-
  * vim: tabstop=4 shiftwidth=4 expandtab
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -33,19 +33,19 @@ typedef struct _PyGICClosure
 {
     GICallableInfo *info;
     PyObject *function;
-    
+
     ffi_closure *closure;
     ffi_cif cif;
- 
+
     GIScopeType scope;
 
     PyObject* user_data;
-} PyGICClosure; 
- 
-void _pygi_closure_handle(ffi_cif *cif, void *result, void
-                          **args, void *userdata);
- 
-void _pygi_invoke_closure_free(gpointer user_data);
+} PyGICClosure;
+
+void _pygi_closure_handle (ffi_cif *cif, void *result, void
+                           **args, void *userdata);
+
+void _pygi_invoke_closure_free (gpointer user_data);
 
 PyGICClosure* _pygi_make_native_closure (GICallableInfo* info,
                                          GIScopeType scope,
diff --git a/gi/pygi-foreign-cairo.c b/gi/pygi-foreign-cairo.c
index a051d33..7ec71c1 100644
--- a/gi/pygi-foreign-cairo.c
+++ b/gi/pygi-foreign-cairo.c
@@ -29,16 +29,16 @@ extern Pycairo_CAPI_t *Pycairo_CAPI;
 #include "pygi-foreign-cairo.h"
 
 gboolean
-cairo_context_to_arg(PyObject       *value,
-                     GITypeInfo     *type_info,
-                     GITransfer      transfer,
-                     GArgument      *arg)
+cairo_context_to_arg (PyObject       *value,
+                      GITypeInfo     *type_info,
+                      GITransfer      transfer,
+                      GArgument      *arg)
 {
     cairo_t *cr;
 
     g_assert (transfer == GI_TRANSFER_NOTHING);
 
-    cr = PycairoContext_GET(value);
+    cr = PycairoContext_GET (value);
     if (!cr)
         return FALSE;
 
@@ -47,7 +47,7 @@ cairo_context_to_arg(PyObject       *value,
 }
 
 PyObject *
-cairo_context_from_arg(GITypeInfo *type_info, GArgument  *arg)
+cairo_context_from_arg (GITypeInfo *type_info, GArgument  *arg)
 {
     cairo_t *context = (cairo_t*) arg;
 
@@ -57,25 +57,25 @@ cairo_context_from_arg(GITypeInfo *type_info, GArgument  *arg)
 }
 
 gboolean
-cairo_context_release_arg(GITransfer  transfer, GITypeInfo *type_info,
-                          GArgument  *arg)
+cairo_context_release_arg (GITransfer  transfer, GITypeInfo *type_info,
+                           GArgument  *arg)
 {
-    cairo_destroy((cairo_t*)arg->v_pointer);
+    cairo_destroy ( (cairo_t*) arg->v_pointer);
     return TRUE;
 }
 
 
 gboolean
-cairo_surface_to_arg(PyObject       *value,
-                     GITypeInfo     *type_info,
-                     GITransfer      transfer,
-                     GArgument      *arg)
+cairo_surface_to_arg (PyObject       *value,
+                      GITypeInfo     *type_info,
+                      GITransfer      transfer,
+                      GArgument      *arg)
 {
     cairo_surface_t *surface;
 
     g_assert (transfer == GI_TRANSFER_NOTHING);
 
-    surface = ((PycairoSurface*)value)->surface;
+    surface = ( (PycairoSurface*) value)->surface;
     if (!surface)
         return FALSE;
 
@@ -84,7 +84,7 @@ cairo_surface_to_arg(PyObject       *value,
 }
 
 PyObject *
-cairo_surface_from_arg(GITypeInfo *type_info, GArgument  *arg)
+cairo_surface_from_arg (GITypeInfo *type_info, GArgument  *arg)
 {
     cairo_surface_t *surface = (cairo_surface_t*) arg;
 
@@ -94,10 +94,10 @@ cairo_surface_from_arg(GITypeInfo *type_info, GArgument  *arg)
 }
 
 gboolean
-cairo_surface_release_arg(GITransfer  transfer, GITypeInfo *type_info,
-                          GArgument  *arg)
+cairo_surface_release_arg (GITransfer  transfer, GITypeInfo *type_info,
+                           GArgument  *arg)
 {
-    cairo_surface_destroy((cairo_surface_t*)arg->v_pointer);
+    cairo_surface_destroy ( (cairo_surface_t*) arg->v_pointer);
     return TRUE;
 }
 
diff --git a/gi/pygi-foreign-cairo.h b/gi/pygi-foreign-cairo.h
index b8dbcaa..7bff01d 100644
--- a/gi/pygi-foreign-cairo.h
+++ b/gi/pygi-foreign-cairo.h
@@ -26,30 +26,30 @@
 
 #include "pygi-foreign.h"
 
-gboolean cairo_context_to_arg(PyObject       *value,
-                              GITypeInfo     *type_info,
-                              GITransfer      transfer,
-                              GArgument      *arg);
+gboolean cairo_context_to_arg (PyObject       *value,
+                               GITypeInfo     *type_info,
+                               GITransfer      transfer,
+                               GArgument      *arg);
 
-PyObject *cairo_context_from_arg(GITypeInfo *type_info,
-                                 GArgument  *arg);
+PyObject *cairo_context_from_arg (GITypeInfo *type_info,
+                                  GArgument  *arg);
 
-gboolean cairo_context_release_arg(GITransfer  transfer,
-                                   GITypeInfo *type_info,
-                                   GArgument  *arg);
+gboolean cairo_context_release_arg (GITransfer  transfer,
+                                    GITypeInfo *type_info,
+                                    GArgument  *arg);
 
 
-gboolean cairo_surface_to_arg(PyObject       *value,
-                              GITypeInfo     *type_info,
-                              GITransfer      transfer,
-                              GArgument      *arg);
+gboolean cairo_surface_to_arg (PyObject       *value,
+                               GITypeInfo     *type_info,
+                               GITransfer      transfer,
+                               GArgument      *arg);
 
-PyObject *cairo_surface_from_arg(GITypeInfo *type_info,
-                                 GArgument  *arg);
+PyObject *cairo_surface_from_arg (GITypeInfo *type_info,
+                                  GArgument  *arg);
 
-gboolean cairo_surface_release_arg(GITransfer  transfer,
-                                   GITypeInfo *type_info,
-                                   GArgument  *arg);
+gboolean cairo_surface_release_arg (GITransfer  transfer,
+                                    GITypeInfo *type_info,
+                                    GArgument  *arg);
 
 #endif /* __PYGI_FOREIGN_CAIRO_H__ */
 
diff --git a/gi/pygi-foreign.c b/gi/pygi-foreign.c
index cde56b0..d2613df 100644
--- a/gi/pygi-foreign.c
+++ b/gi/pygi-foreign.c
@@ -36,46 +36,48 @@ static struct {
     PyGIArgOverrideFromGArgumentFunc from_func;
     PyGIArgOverrideReleaseGArgumentFunc release_func;
 } foreign_structs[] = {
-    { "cairo", "Context", cairo_context_to_arg, cairo_context_from_arg,
-                          cairo_context_release_arg },
-    { "cairo", "Surface", cairo_surface_to_arg, cairo_surface_from_arg,
-                          cairo_surface_release_arg },
+    {   "cairo", "Context", cairo_context_to_arg, cairo_context_from_arg,
+        cairo_context_release_arg
+    },
+    {   "cairo", "Surface", cairo_surface_to_arg, cairo_surface_from_arg,
+        cairo_surface_release_arg
+    },
     { NULL }
 };
 
 static gint
-pygi_struct_foreign_lookup(GITypeInfo *type_info)
+pygi_struct_foreign_lookup (GITypeInfo *type_info)
 {
     GIBaseInfo *base_info;
 
-    base_info = g_type_info_get_interface(type_info);
+    base_info = g_type_info_get_interface (type_info);
     if (base_info) {
         gint i;
-        const gchar *namespace = g_base_info_get_namespace(base_info);
-        const gchar *name = g_base_info_get_name(base_info);
+        const gchar *namespace = g_base_info_get_namespace (base_info);
+        const gchar *name = g_base_info_get_name (base_info);
 
         for (i = 0; foreign_structs[i].namespace; ++i) {
 
-            if ((strcmp(namespace, foreign_structs[i].namespace) == 0) &&
-                (strcmp(name, foreign_structs[i].name) == 0)) {
-                g_base_info_unref(base_info);
+            if ( (strcmp (namespace, foreign_structs[i].namespace) == 0) &&
+                    (strcmp (name, foreign_structs[i].name) == 0)) {
+                g_base_info_unref (base_info);
                 return i;
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "Couldn't find type %s.%s", namespace,
-                     name);
+        PyErr_Format (PyExc_TypeError, "Couldn't find type %s.%s", namespace,
+                      name);
 
-        g_base_info_unref(base_info);
+        g_base_info_unref (base_info);
     }
     return -1;
 }
 
 gboolean
-pygi_struct_foreign_convert_to_g_argument(PyObject      *value,
-                                         GITypeInfo     *type_info,
-                                         GITransfer      transfer,
-                                         GArgument      *arg)
+pygi_struct_foreign_convert_to_g_argument (PyObject      *value,
+                                           GITypeInfo     *type_info,
+                                           GITransfer      transfer,
+                                           GArgument      *arg)
 {
     gint struct_index;
 
@@ -83,15 +85,15 @@ pygi_struct_foreign_convert_to_g_argument(PyObject      *value,
     if (struct_index < 0)
         return FALSE;
 
-    if (!foreign_structs[struct_index].to_func(value, type_info, transfer, arg))
+    if (!foreign_structs[struct_index].to_func (value, type_info, transfer, arg))
         return FALSE;
 
     return TRUE;
 }
 
 PyObject *
-pygi_struct_foreign_convert_from_g_argument(GITypeInfo *type_info,
-                                            GArgument  *arg)
+pygi_struct_foreign_convert_from_g_argument (GITypeInfo *type_info,
+                                             GArgument  *arg)
 {
     gint struct_index;
 
@@ -99,13 +101,13 @@ pygi_struct_foreign_convert_from_g_argument(GITypeInfo *type_info,
     if (struct_index < 0)
         return NULL;
 
-    return foreign_structs[struct_index].from_func(type_info, arg);
+    return foreign_structs[struct_index].from_func (type_info, arg);
 }
 
 gboolean
-pygi_struct_foreign_release_g_argument(GITransfer  transfer,
-                                       GITypeInfo *type_info,
-                                       GArgument  *arg)
+pygi_struct_foreign_release_g_argument (GITransfer  transfer,
+                                        GITypeInfo *type_info,
+                                        GArgument  *arg)
 {
     gint struct_index;
 
@@ -116,7 +118,7 @@ pygi_struct_foreign_release_g_argument(GITransfer  transfer,
     if (!foreign_structs[struct_index].release_func)
         return TRUE;
 
-   if (!foreign_structs[struct_index].release_func(transfer, type_info, arg))
+    if (!foreign_structs[struct_index].release_func (transfer, type_info, arg))
         return FALSE;
 
     return TRUE;
diff --git a/gi/pygi-foreign.h b/gi/pygi-foreign.h
index 2f13b0f..7962b49 100644
--- a/gi/pygi-foreign.h
+++ b/gi/pygi-foreign.h
@@ -43,10 +43,10 @@ gboolean pygi_struct_foreign_convert_to_g_argument (PyObject           *value,
                                                     GITypeInfo         *type_info,
                                                     GITransfer          transfer,
                                                     GArgument          *arg);
-PyObject *pygi_struct_foreign_convert_from_g_argument(GITypeInfo *type_info,
-                                                      GArgument  *arg);
-gboolean pygi_struct_foreign_release_g_argument    (GITransfer          transfer,
-                                                    GITypeInfo         *type_info,
-                                                    GArgument          *arg);
+PyObject *pygi_struct_foreign_convert_from_g_argument (GITypeInfo *type_info,
+                                                       GArgument  *arg);
+gboolean pygi_struct_foreign_release_g_argument (GITransfer          transfer,
+                                                 GITypeInfo         *type_info,
+                                                 GArgument          *arg);
 
 #endif /* __PYGI_FOREIGN_H__ */
diff --git a/gi/pygi-info.c b/gi/pygi-info.c
index 9882fd7..c6b7bab 100644
--- a/gi/pygi-info.c
+++ b/gi/pygi-info.c
@@ -68,13 +68,13 @@ PyTypeObject Py##cname##_Type = { \
 static void
 _base_info_dealloc (PyGIBaseInfo *self)
 {
-    PyObject_GC_UnTrack((PyObject *)self);
+    PyObject_GC_UnTrack ( (PyObject *) self);
 
-    PyObject_ClearWeakRefs((PyObject *)self);
+    PyObject_ClearWeakRefs ( (PyObject *) self);
 
-    g_base_info_unref(self->info);
+    g_base_info_unref (self->info);
 
-    self->ob_type->tp_free((PyObject *)self);
+    self->ob_type->tp_free ( (PyObject *) self);
 }
 
 static int
@@ -88,55 +88,55 @@ _base_info_traverse (PyGIBaseInfo *self,
 static PyObject *
 _base_info_repr (PyGIBaseInfo *self)
 {
-    return PyString_FromFormat("<%s object (%s) at 0x%p>",
-            self->ob_type->tp_name, g_base_info_get_name(self->info), (void *)self);
+    return PyString_FromFormat ("<%s object (%s) at 0x%p>",
+                                self->ob_type->tp_name, g_base_info_get_name (self->info), (void *) self);
 }
 
 static PyMethodDef _PyGIBaseInfo_methods[];
 
 PyTypeObject PyGIBaseInfo_Type = {
-    PyObject_HEAD_INIT(NULL)
+    PyObject_HEAD_INIT (NULL)
     0,
     "gi.BaseInfo",                             /* tp_name */
-    sizeof(PyGIBaseInfo),                      /* tp_basicsize */
+    sizeof (PyGIBaseInfo),                     /* tp_basicsize */
     0,                                         /* tp_itemsize */
-    (destructor)_base_info_dealloc,        /* tp_dealloc */
-    (printfunc)NULL,                           /* tp_print */
-    (getattrfunc)NULL,                         /* tp_getattr */
-    (setattrfunc)NULL,                         /* tp_setattr */
-    (cmpfunc)NULL,                             /* tp_compare */
-    (reprfunc)_base_info_repr,             /* tp_repr */
+    (destructor) _base_info_dealloc,       /* tp_dealloc */
+    (printfunc) NULL,                          /* tp_print */
+    (getattrfunc) NULL,                        /* tp_getattr */
+    (setattrfunc) NULL,                        /* tp_setattr */
+    (cmpfunc) NULL,                            /* tp_compare */
+    (reprfunc) _base_info_repr,            /* tp_repr */
     NULL,                                      /* tp_as_number */
     NULL,                                      /* tp_as_sequence */
     NULL,                                      /* tp_as_mapping */
-    (hashfunc)NULL,                            /* tp_hash */
-    (ternaryfunc)NULL,                         /* tp_call */
-    (reprfunc)NULL,                            /* tp_str */
-    (getattrofunc)NULL,                        /* tp_getattro */
-    (setattrofunc)NULL,                        /* tp_setattro */
+    (hashfunc) NULL,                           /* tp_hash */
+    (ternaryfunc) NULL,                        /* tp_call */
+    (reprfunc) NULL,                           /* tp_str */
+    (getattrofunc) NULL,                       /* tp_getattro */
+    (setattrofunc) NULL,                       /* tp_setattro */
     NULL,                                      /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
-        Py_TPFLAGS_HAVE_GC,                    /* tp_flags */
+    Py_TPFLAGS_HAVE_GC,                    /* tp_flags */
     NULL,                                      /* tp_doc */
-    (traverseproc)_base_info_traverse,     /* tp_traverse */
-    (inquiry)NULL,                             /* tp_clear */
-    (richcmpfunc)NULL,                         /* tp_richcompare */
-    offsetof(PyGIBaseInfo, inst_weakreflist),  /* tp_weaklistoffset */
-    (getiterfunc)NULL,                         /* tp_iter */
-    (iternextfunc)NULL,                        /* tp_iternext */
+    (traverseproc) _base_info_traverse,    /* tp_traverse */
+    (inquiry) NULL,                            /* tp_clear */
+    (richcmpfunc) NULL,                        /* tp_richcompare */
+    offsetof (PyGIBaseInfo, inst_weakreflist), /* tp_weaklistoffset */
+    (getiterfunc) NULL,                        /* tp_iter */
+    (iternextfunc) NULL,                       /* tp_iternext */
     _PyGIBaseInfo_methods,                     /* tp_methods */
 };
 
 static PyObject *
 _wrap_g_base_info_get_name (PyGIBaseInfo *self)
 {
-    return PyString_FromString(g_base_info_get_name(self->info));
+    return PyString_FromString (g_base_info_get_name (self->info));
 }
 
 static PyObject *
 _wrap_g_base_info_get_namespace (PyGIBaseInfo *self)
 {
-    return PyString_FromString(g_base_info_get_namespace(self->info));
+    return PyString_FromString (g_base_info_get_namespace (self->info));
 }
 
 static PyObject *
@@ -144,20 +144,20 @@ _wrap_g_base_info_get_container (PyGIBaseInfo *self)
 {
     GIBaseInfo *info;
 
-    info = g_base_info_get_container(self->info);
+    info = g_base_info_get_container (self->info);
 
     if (info == NULL) {
         Py_RETURN_NONE;
     }
 
-    return _pygi_info_new(info);
+    return _pygi_info_new (info);
 }
 
 
 static PyMethodDef _PyGIBaseInfo_methods[] = {
-    { "get_name", (PyCFunction)_wrap_g_base_info_get_name, METH_NOARGS },
-    { "get_namespace", (PyCFunction)_wrap_g_base_info_get_namespace, METH_NOARGS },
-    { "get_container", (PyCFunction)_wrap_g_base_info_get_container, METH_NOARGS },
+    { "get_name", (PyCFunction) _wrap_g_base_info_get_name, METH_NOARGS },
+    { "get_namespace", (PyCFunction) _wrap_g_base_info_get_namespace, METH_NOARGS },
+    { "get_container", (PyCFunction) _wrap_g_base_info_get_container, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
@@ -168,24 +168,24 @@ _pygi_info_new (GIBaseInfo *info)
     PyTypeObject *type = NULL;
     PyGIBaseInfo *self;
 
-    info_type = g_base_info_get_type(info);
+    info_type = g_base_info_get_type (info);
 
     switch (info_type)
     {
         case GI_INFO_TYPE_INVALID:
-            PyErr_SetString(PyExc_RuntimeError, "Invalid info type");
+            PyErr_SetString (PyExc_RuntimeError, "Invalid info type");
             return NULL;
         case GI_INFO_TYPE_FUNCTION:
             type = &PyGIFunctionInfo_Type;
             break;
         case GI_INFO_TYPE_CALLBACK:
-            PyErr_SetString(PyExc_NotImplementedError, "GICallbackInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GICallbackInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_STRUCT:
             type = &PyGIStructInfo_Type;
             break;
         case GI_INFO_TYPE_BOXED:
-            PyErr_SetString(PyExc_NotImplementedError, "GIBoxedInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GIBoxedInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_ENUM:
         case GI_INFO_TYPE_FLAGS:
@@ -201,7 +201,7 @@ _pygi_info_new (GIBaseInfo *info)
             type = &PyGIConstantInfo_Type;
             break;
         case GI_INFO_TYPE_ERROR_DOMAIN:
-            PyErr_SetString(PyExc_NotImplementedError, "GIErrorDomainInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GIErrorDomainInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_UNION:
             type = &PyGIUnionInfo_Type;
@@ -210,36 +210,36 @@ _pygi_info_new (GIBaseInfo *info)
             type = &PyGIValueInfo_Type;
             break;
         case GI_INFO_TYPE_SIGNAL:
-            PyErr_SetString(PyExc_NotImplementedError, "GISignalInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GISignalInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_VFUNC:
             type = &PyGIVFuncInfo_Type;
             break;
         case GI_INFO_TYPE_PROPERTY:
-            PyErr_SetString(PyExc_NotImplementedError, "GIPropertyInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GIPropertyInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_FIELD:
             type = &PyGIFieldInfo_Type;
             break;
         case GI_INFO_TYPE_ARG:
-            PyErr_SetString(PyExc_NotImplementedError, "GIArgInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GIArgInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_TYPE:
-            PyErr_SetString(PyExc_NotImplementedError, "GITypeInfo bindings not implemented");
+            PyErr_SetString (PyExc_NotImplementedError, "GITypeInfo bindings not implemented");
             return NULL;
         case GI_INFO_TYPE_UNRESOLVED:
             type = &PyGIUnresolvedInfo_Type;
             break;
     }
 
-    self = (PyGIBaseInfo *)type->tp_alloc(type, 0);
+    self = (PyGIBaseInfo *) type->tp_alloc (type, 0);
     if (self == NULL) {
         return NULL;
     }
 
-    self->info = g_base_info_ref(info);
+    self->info = g_base_info_ref (info);
 
-    return (PyObject *)self;
+    return (PyObject *) self;
 }
 
 GIBaseInfo *
@@ -249,28 +249,28 @@ _pygi_object_get_gi_info (PyObject     *object,
     PyObject *py_info;
     GIBaseInfo *info = NULL;
 
-    py_info = PyObject_GetAttrString(object, "__info__");
+    py_info = PyObject_GetAttrString (object, "__info__");
     if (py_info == NULL) {
         return NULL;
     }
-    if (!PyObject_TypeCheck(py_info, type)) {
-        PyErr_Format(PyExc_TypeError, "attribute '__info__' must be %s, not %s",
-            type->tp_name, py_info->ob_type->tp_name);
+    if (!PyObject_TypeCheck (py_info, type)) {
+        PyErr_Format (PyExc_TypeError, "attribute '__info__' must be %s, not %s",
+                      type->tp_name, py_info->ob_type->tp_name);
         goto out;
     }
 
-    info = ((PyGIBaseInfo *)py_info)->info;
-    g_base_info_ref(info);
+    info = ( (PyGIBaseInfo *) py_info)->info;
+    g_base_info_ref (info);
 
 out:
-    Py_DECREF(py_info);
+    Py_DECREF (py_info);
 
     return info;
 }
 
 
 /* CallableInfo */
-_PyGI_DEFINE_INFO_TYPE("CallableInfo", GICallableInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("CallableInfo", GICallableInfo, PyGIBaseInfo_Type);
 
 static PyMethodDef _PyGICallableInfo_methods[] = {
     { NULL, NULL, 0 }
@@ -278,7 +278,7 @@ static PyMethodDef _PyGICallableInfo_methods[] = {
 
 
 /* FunctionInfo */
-_PyGI_DEFINE_INFO_TYPE("FunctionInfo", GIFunctionInfo, PyGICallableInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("FunctionInfo", GIFunctionInfo, PyGICallableInfo_Type);
 
 static PyObject *
 _wrap_g_function_info_is_constructor (PyGIBaseInfo *self)
@@ -286,10 +286,10 @@ _wrap_g_function_info_is_constructor (PyGIBaseInfo *self)
     GIFunctionInfoFlags flags;
     gboolean is_constructor;
 
-    flags = g_function_info_get_flags((GIFunctionInfo*)self->info);
+    flags = g_function_info_get_flags ( (GIFunctionInfo*) self->info);
     is_constructor = flags & GI_FUNCTION_IS_CONSTRUCTOR;
 
-    return PyBool_FromLong(is_constructor);
+    return PyBool_FromLong (is_constructor);
 }
 
 static PyObject *
@@ -298,10 +298,10 @@ _wrap_g_function_info_is_method (PyGIBaseInfo *self)
     GIFunctionInfoFlags flags;
     gboolean is_method;
 
-    flags = g_function_info_get_flags((GIFunctionInfo*)self->info);
+    flags = g_function_info_get_flags ( (GIFunctionInfo*) self->info);
     is_method = flags & GI_FUNCTION_IS_METHOD;
 
-    return PyBool_FromLong(is_method);
+    return PyBool_FromLong (is_method);
 }
 
 gsize
@@ -309,53 +309,53 @@ _pygi_g_type_tag_size (GITypeTag type_tag)
 {
     gsize size = 0;
 
-    switch(type_tag) {
+    switch (type_tag) {
         case GI_TYPE_TAG_BOOLEAN:
-            size = sizeof(gboolean);
+            size = sizeof (gboolean);
             break;
         case GI_TYPE_TAG_INT8:
         case GI_TYPE_TAG_UINT8:
-            size = sizeof(gint8);
+            size = sizeof (gint8);
             break;
         case GI_TYPE_TAG_INT16:
         case GI_TYPE_TAG_UINT16:
-            size = sizeof(gint16);
+            size = sizeof (gint16);
             break;
         case GI_TYPE_TAG_INT32:
         case GI_TYPE_TAG_UINT32:
-            size = sizeof(gint32);
+            size = sizeof (gint32);
             break;
         case GI_TYPE_TAG_INT64:
         case GI_TYPE_TAG_UINT64:
-            size = sizeof(gint64);
+            size = sizeof (gint64);
             break;
         case GI_TYPE_TAG_SHORT:
         case GI_TYPE_TAG_USHORT:
-            size = sizeof(gshort);
+            size = sizeof (gshort);
             break;
         case GI_TYPE_TAG_INT:
         case GI_TYPE_TAG_UINT:
-            size = sizeof(gint);
+            size = sizeof (gint);
             break;
         case GI_TYPE_TAG_LONG:
         case GI_TYPE_TAG_ULONG:
-            size = sizeof(glong);
+            size = sizeof (glong);
             break;
         case GI_TYPE_TAG_SIZE:
         case GI_TYPE_TAG_SSIZE:
-            size = sizeof(gsize);
+            size = sizeof (gsize);
             break;
         case GI_TYPE_TAG_FLOAT:
-            size = sizeof(gfloat);
+            size = sizeof (gfloat);
             break;
         case GI_TYPE_TAG_DOUBLE:
-            size = sizeof(gdouble);
+            size = sizeof (gdouble);
             break;
         case GI_TYPE_TAG_TIME_T:
-            size = sizeof(time_t);
+            size = sizeof (time_t);
             break;
         case GI_TYPE_TAG_GTYPE:
-            size = sizeof(GType);
+            size = sizeof (GType);
             break;
         case GI_TYPE_TAG_VOID:
         case GI_TYPE_TAG_UTF8:
@@ -366,9 +366,9 @@ _pygi_g_type_tag_size (GITypeTag type_tag)
         case GI_TYPE_TAG_GSLIST:
         case GI_TYPE_TAG_GHASH:
         case GI_TYPE_TAG_ERROR:
-            PyErr_Format(PyExc_TypeError,
-                "Unable to know the size (assuming %s is not a pointer)",
-                g_type_tag_to_string(type_tag));
+            PyErr_Format (PyExc_TypeError,
+                          "Unable to know the size (assuming %s is not a pointer)",
+                          g_type_tag_to_string (type_tag));
             break;
     }
 
@@ -382,8 +382,8 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
 
     GITypeTag type_tag;
 
-    type_tag = g_type_info_get_tag(type_info);
-    switch(type_tag) {
+    type_tag = g_type_info_get_tag (type_info);
+    switch (type_tag) {
         case GI_TYPE_TAG_BOOLEAN:
         case GI_TYPE_TAG_INT8:
         case GI_TYPE_TAG_UINT8:
@@ -405,11 +405,11 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
         case GI_TYPE_TAG_DOUBLE:
         case GI_TYPE_TAG_TIME_T:
         case GI_TYPE_TAG_GTYPE:
-            if (g_type_info_is_pointer(type_info)) {
-                size = sizeof(gpointer);
+            if (g_type_info_is_pointer (type_info)) {
+                size = sizeof (gpointer);
             } else {
-                size = _pygi_g_type_tag_size(type_tag);
-                g_assert(size > 0);
+                size = _pygi_g_type_tag_size (type_tag);
+                g_assert (size > 0);
             }
             break;
         case GI_TYPE_TAG_INTERFACE:
@@ -417,40 +417,40 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
             GIBaseInfo *info;
             GIInfoType info_type;
 
-            info = g_type_info_get_interface(type_info);
-            info_type = g_base_info_get_type(info);
+            info = g_type_info_get_interface (type_info);
+            info_type = g_base_info_get_type (info);
 
             switch (info_type) {
                 case GI_INFO_TYPE_STRUCT:
-                    if (g_type_info_is_pointer(type_info)) {
-                        size = sizeof(gpointer);
+                    if (g_type_info_is_pointer (type_info)) {
+                        size = sizeof (gpointer);
                     } else {
-                        size = g_struct_info_get_size((GIStructInfo *)info);
+                        size = g_struct_info_get_size ( (GIStructInfo *) info);
                     }
                     break;
                 case GI_INFO_TYPE_UNION:
-                    if (g_type_info_is_pointer(type_info)) {
-                        size = sizeof(gpointer);
+                    if (g_type_info_is_pointer (type_info)) {
+                        size = sizeof (gpointer);
                     } else {
-                        size = g_union_info_get_size((GIUnionInfo *)info);
+                        size = g_union_info_get_size ( (GIUnionInfo *) info);
                     }
                     break;
                 case GI_INFO_TYPE_ENUM:
                 case GI_INFO_TYPE_FLAGS:
-                    if (g_type_info_is_pointer(type_info)) {
-                        size = sizeof(gpointer);
+                    if (g_type_info_is_pointer (type_info)) {
+                        size = sizeof (gpointer);
                     } else {
                         GITypeTag type_tag;
 
-                        type_tag = g_enum_info_get_storage_type((GIEnumInfo *)info);
-                        size = _pygi_g_type_tag_size(type_tag);
+                        type_tag = g_enum_info_get_storage_type ( (GIEnumInfo *) info);
+                        size = _pygi_g_type_tag_size (type_tag);
                     }
                     break;
                 case GI_INFO_TYPE_BOXED:
                 case GI_INFO_TYPE_OBJECT:
                 case GI_INFO_TYPE_INTERFACE:
                 case GI_INFO_TYPE_CALLBACK:
-                    size = sizeof(gpointer);
+                    size = sizeof (gpointer);
                     break;
                 case GI_INFO_TYPE_VFUNC:
                 case GI_INFO_TYPE_INVALID:
@@ -468,7 +468,7 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
                     break;
             }
 
-            g_base_info_unref(info);
+            g_base_info_unref (info);
             break;
         }
         case GI_TYPE_TAG_ARRAY:
@@ -479,7 +479,7 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
         case GI_TYPE_TAG_GSLIST:
         case GI_TYPE_TAG_GHASH:
         case GI_TYPE_TAG_ERROR:
-            size = sizeof(gpointer);
+            size = sizeof (gpointer);
             break;
     }
 
@@ -487,34 +487,34 @@ _pygi_g_type_info_size (GITypeInfo *type_info)
 }
 
 static PyMethodDef _PyGIFunctionInfo_methods[] = {
-    { "is_constructor", (PyCFunction)_wrap_g_function_info_is_constructor, METH_NOARGS },
-    { "is_method", (PyCFunction)_wrap_g_function_info_is_method, METH_NOARGS },
-    { "invoke", (PyCFunction)_wrap_g_function_info_invoke, METH_VARARGS },
+    { "is_constructor", (PyCFunction) _wrap_g_function_info_is_constructor, METH_NOARGS },
+    { "is_method", (PyCFunction) _wrap_g_function_info_is_method, METH_NOARGS },
+    { "invoke", (PyCFunction) _wrap_g_function_info_invoke, METH_VARARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* RegisteredTypeInfo */
-_PyGI_DEFINE_INFO_TYPE("RegisteredTypeInfo", GIRegisteredTypeInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("RegisteredTypeInfo", GIRegisteredTypeInfo, PyGIBaseInfo_Type);
 
 static PyObject *
 _wrap_g_registered_type_info_get_g_type (PyGIBaseInfo *self)
 {
     GType type;
 
-    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)self->info);
+    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) self->info);
 
-    return pyg_type_wrapper_new(type);
+    return pyg_type_wrapper_new (type);
 }
 
 static PyMethodDef _PyGIRegisteredTypeInfo_methods[] = {
-    { "get_g_type", (PyCFunction)_wrap_g_registered_type_info_get_g_type, METH_NOARGS },
+    { "get_g_type", (PyCFunction) _wrap_g_registered_type_info_get_g_type, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* GIStructInfo */
-_PyGI_DEFINE_INFO_TYPE("StructInfo", GIStructInfo, PyGIRegisteredTypeInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("StructInfo", GIStructInfo, PyGIRegisteredTypeInfo_Type);
 
 static PyObject *
 _get_fields (PyGIBaseInfo *self, GIInfoType info_type)
@@ -525,16 +525,16 @@ _get_fields (PyGIBaseInfo *self, GIInfoType info_type)
 
     switch (info_type) {
         case GI_INFO_TYPE_STRUCT:
-            n_infos = g_struct_info_get_n_fields((GIStructInfo *)self->info);
+            n_infos = g_struct_info_get_n_fields ( (GIStructInfo *) self->info);
             break;
         case GI_INFO_TYPE_OBJECT:
-            n_infos = g_object_info_get_n_fields((GIObjectInfo *)self->info);
+            n_infos = g_object_info_get_n_fields ( (GIObjectInfo *) self->info);
             break;
         default:
             g_assert_not_reached();
     }
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -545,26 +545,26 @@ _get_fields (PyGIBaseInfo *self, GIInfoType info_type)
 
         switch (info_type) {
             case GI_INFO_TYPE_STRUCT:
-                info = (GIBaseInfo *)g_struct_info_get_field((GIStructInfo *)self->info, i);
+                info = (GIBaseInfo *) g_struct_info_get_field ( (GIStructInfo *) self->info, i);
                 break;
             case GI_INFO_TYPE_OBJECT:
-                info = (GIBaseInfo *)g_object_info_get_field((GIObjectInfo *)self->info, i);
+                info = (GIBaseInfo *) g_object_info_get_field ( (GIObjectInfo *) self->info, i);
                 break;
             default:
                 g_assert_not_reached();
         }
-        g_assert(info != NULL);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -579,16 +579,16 @@ _get_methods (PyGIBaseInfo *self, GIInfoType info_type)
 
     switch (info_type) {
         case GI_INFO_TYPE_STRUCT:
-            n_infos = g_struct_info_get_n_methods((GIStructInfo *)self->info);
+            n_infos = g_struct_info_get_n_methods ( (GIStructInfo *) self->info);
             break;
         case GI_INFO_TYPE_OBJECT:
-            n_infos = g_object_info_get_n_methods((GIObjectInfo *)self->info);
+            n_infos = g_object_info_get_n_methods ( (GIObjectInfo *) self->info);
             break;
         default:
             g_assert_not_reached();
     }
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -599,26 +599,26 @@ _get_methods (PyGIBaseInfo *self, GIInfoType info_type)
 
         switch (info_type) {
             case GI_INFO_TYPE_STRUCT:
-                info = (GIBaseInfo *)g_struct_info_get_method((GIStructInfo *)self->info, i);
+                info = (GIBaseInfo *) g_struct_info_get_method ( (GIStructInfo *) self->info, i);
                 break;
             case GI_INFO_TYPE_OBJECT:
-                info = (GIBaseInfo *)g_object_info_get_method((GIObjectInfo *)self->info, i);
+                info = (GIBaseInfo *) g_object_info_get_method ( (GIObjectInfo *) self->info, i);
                 break;
             default:
                 g_assert_not_reached();
         }
-        g_assert(info != NULL);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -633,16 +633,16 @@ _get_constants (PyGIBaseInfo *self, GIInfoType info_type)
 
     switch (info_type) {
         case GI_INFO_TYPE_INTERFACE:
-            n_infos = g_interface_info_get_n_constants((GIInterfaceInfo *)self->info);
+            n_infos = g_interface_info_get_n_constants ( (GIInterfaceInfo *) self->info);
             break;
         case GI_INFO_TYPE_OBJECT:
-            n_infos = g_object_info_get_n_constants((GIObjectInfo *)self->info);
+            n_infos = g_object_info_get_n_constants ( (GIObjectInfo *) self->info);
             break;
         default:
             g_assert_not_reached();
     }
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -653,26 +653,26 @@ _get_constants (PyGIBaseInfo *self, GIInfoType info_type)
 
         switch (info_type) {
             case GI_INFO_TYPE_INTERFACE:
-                info = (GIBaseInfo *)g_interface_info_get_constant((GIInterfaceInfo *)self->info, i);
+                info = (GIBaseInfo *) g_interface_info_get_constant ( (GIInterfaceInfo *) self->info, i);
                 break;
             case GI_INFO_TYPE_OBJECT:
-                info = (GIBaseInfo *)g_object_info_get_constant((GIObjectInfo *)self->info, i);
+                info = (GIBaseInfo *) g_object_info_get_constant ( (GIObjectInfo *) self->info, i);
                 break;
             default:
                 g_assert_not_reached();
         }
-        g_assert(info != NULL);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -687,16 +687,16 @@ _get_vfuncs (PyGIBaseInfo *self, GIInfoType info_type)
 
     switch (info_type) {
         case GI_INFO_TYPE_INTERFACE:
-            n_infos = g_interface_info_get_n_vfuncs((GIInterfaceInfo *)self->info);
+            n_infos = g_interface_info_get_n_vfuncs ( (GIInterfaceInfo *) self->info);
             break;
         case GI_INFO_TYPE_OBJECT:
-            n_infos = g_object_info_get_n_vfuncs((GIObjectInfo *)self->info);
+            n_infos = g_object_info_get_n_vfuncs ( (GIObjectInfo *) self->info);
             break;
         default:
             g_assert_not_reached();
     }
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -707,26 +707,26 @@ _get_vfuncs (PyGIBaseInfo *self, GIInfoType info_type)
 
         switch (info_type) {
             case GI_INFO_TYPE_INTERFACE:
-                info = (GIBaseInfo *)g_interface_info_get_vfunc((GIInterfaceInfo *)self->info, i);
+                info = (GIBaseInfo *) g_interface_info_get_vfunc ( (GIInterfaceInfo *) self->info, i);
                 break;
             case GI_INFO_TYPE_OBJECT:
-                info = (GIBaseInfo *)g_object_info_get_vfunc((GIObjectInfo *)self->info, i);
+                info = (GIBaseInfo *) g_object_info_get_vfunc ( (GIObjectInfo *) self->info, i);
                 break;
             default:
                 g_assert_not_reached();
         }
-        g_assert(info != NULL);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -735,18 +735,18 @@ _get_vfuncs (PyGIBaseInfo *self, GIInfoType info_type)
 static PyObject *
 _wrap_g_struct_info_get_fields (PyGIBaseInfo *self)
 {
-    return _get_fields(self, GI_INFO_TYPE_STRUCT);
+    return _get_fields (self, GI_INFO_TYPE_STRUCT);
 }
 
 static PyObject *
 _wrap_g_struct_info_get_methods (PyGIBaseInfo *self)
 {
-    return _get_methods(self, GI_INFO_TYPE_STRUCT);
+    return _get_methods (self, GI_INFO_TYPE_STRUCT);
 }
 
 static PyMethodDef _PyGIStructInfo_methods[] = {
-    { "get_fields", (PyCFunction)_wrap_g_struct_info_get_fields, METH_NOARGS },
-    { "get_methods", (PyCFunction)_wrap_g_struct_info_get_methods, METH_NOARGS },
+    { "get_fields", (PyCFunction) _wrap_g_struct_info_get_fields, METH_NOARGS },
+    { "get_methods", (PyCFunction) _wrap_g_struct_info_get_methods, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
@@ -759,18 +759,18 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
 
     is_simple = TRUE;
 
-    n_field_infos = g_struct_info_get_n_fields(struct_info);
+    n_field_infos = g_struct_info_get_n_fields (struct_info);
 
     for (i = 0; i < n_field_infos && is_simple; i++) {
         GIFieldInfo *field_info;
         GITypeInfo *field_type_info;
 
-        field_info = g_struct_info_get_field(struct_info, i);
-        field_type_info = g_field_info_get_type(field_info);
+        field_info = g_struct_info_get_field (struct_info, i);
+        field_type_info = g_field_info_get_type (field_info);
 
         GITypeTag field_type_tag;
 
-        field_type_tag = g_type_info_get_tag(field_type_info);
+        field_type_tag = g_type_info_get_tag (field_type_info);
 
         switch (field_type_tag) {
             case GI_TYPE_TAG_BOOLEAN:
@@ -793,7 +793,7 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
             case GI_TYPE_TAG_FLOAT:
             case GI_TYPE_TAG_DOUBLE:
             case GI_TYPE_TAG_TIME_T:
-                if (g_type_info_is_pointer(field_type_info)) {
+                if (g_type_info_is_pointer (field_type_info)) {
                     is_simple = FALSE;
                 }
                 break;
@@ -813,15 +813,15 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
                 GIBaseInfo *info;
                 GIInfoType info_type;
 
-                info = g_type_info_get_interface(field_type_info);
-                info_type = g_base_info_get_type(info);
+                info = g_type_info_get_interface (field_type_info);
+                info_type = g_base_info_get_type (info);
 
                 switch (info_type) {
                     case GI_INFO_TYPE_STRUCT:
-                        if (g_type_info_is_pointer(field_type_info)) {
+                        if (g_type_info_is_pointer (field_type_info)) {
                             is_simple = FALSE;
                         } else {
-                            is_simple = pygi_g_struct_info_is_simple((GIStructInfo *)info);
+                            is_simple = pygi_g_struct_info_is_simple ( (GIStructInfo *) info);
                         }
                         break;
                     case GI_INFO_TYPE_UNION:
@@ -830,7 +830,7 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
                         break;
                     case GI_INFO_TYPE_ENUM:
                     case GI_INFO_TYPE_FLAGS:
-                        if (g_type_info_is_pointer(field_type_info)) {
+                        if (g_type_info_is_pointer (field_type_info)) {
                             is_simple = FALSE;
                         }
                         break;
@@ -855,13 +855,13 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
                         g_assert_not_reached();
                 }
 
-                g_base_info_unref(info);
+                g_base_info_unref (info);
                 break;
             }
         }
 
-        g_base_info_unref((GIBaseInfo *)field_type_info);
-        g_base_info_unref((GIBaseInfo *)field_info);
+        g_base_info_unref ( (GIBaseInfo *) field_type_info);
+        g_base_info_unref ( (GIBaseInfo *) field_info);
     }
 
     return is_simple;
@@ -869,7 +869,7 @@ pygi_g_struct_info_is_simple (GIStructInfo *struct_info)
 
 
 /* EnumInfo */
-_PyGI_DEFINE_INFO_TYPE("EnumInfo", GIEnumInfo, PyGIRegisteredTypeInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("EnumInfo", GIEnumInfo, PyGIRegisteredTypeInfo_Type);
 
 static PyObject *
 _wrap_g_enum_info_get_values (PyGIBaseInfo *self)
@@ -878,9 +878,9 @@ _wrap_g_enum_info_get_values (PyGIBaseInfo *self)
     PyObject *infos;
     gssize i;
 
-    n_infos = g_enum_info_get_n_values((GIEnumInfo *)self->info);
+    n_infos = g_enum_info_get_n_values ( (GIEnumInfo *) self->info);
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -889,32 +889,32 @@ _wrap_g_enum_info_get_values (PyGIBaseInfo *self)
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = (GIBaseInfo *)g_enum_info_get_value((GIEnumInfo *)self->info, i);
-        g_assert(info != NULL);
+        info = (GIBaseInfo *) g_enum_info_get_value ( (GIEnumInfo *) self->info, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
 }
 
 static PyMethodDef _PyGIEnumInfo_methods[] = {
-    { "get_values", (PyCFunction)_wrap_g_enum_info_get_values, METH_NOARGS },
+    { "get_values", (PyCFunction) _wrap_g_enum_info_get_values, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* ObjectInfo */
-_PyGI_DEFINE_INFO_TYPE("ObjectInfo", GIObjectInfo, PyGIRegisteredTypeInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("ObjectInfo", GIObjectInfo, PyGIRegisteredTypeInfo_Type);
 
 static PyObject *
 _wrap_g_object_info_get_parent (PyGIBaseInfo *self)
@@ -922,15 +922,15 @@ _wrap_g_object_info_get_parent (PyGIBaseInfo *self)
     GIBaseInfo *info;
     PyObject *py_info;
 
-    info = (GIBaseInfo *)g_object_info_get_parent((GIObjectInfo*)self->info);
+    info = (GIBaseInfo *) g_object_info_get_parent ( (GIObjectInfo*) self->info);
 
     if (info == NULL) {
         Py_RETURN_NONE;
     }
 
-    py_info = _pygi_info_new(info);
+    py_info = _pygi_info_new (info);
 
-    g_base_info_unref(info);
+    g_base_info_unref (info);
 
     return py_info;
 }
@@ -938,13 +938,13 @@ _wrap_g_object_info_get_parent (PyGIBaseInfo *self)
 static PyObject *
 _wrap_g_object_info_get_methods (PyGIBaseInfo *self)
 {
-    return _get_methods(self, GI_INFO_TYPE_OBJECT);
+    return _get_methods (self, GI_INFO_TYPE_OBJECT);
 }
 
 static PyObject *
 _wrap_g_object_info_get_fields (PyGIBaseInfo *self)
 {
-    return _get_fields(self, GI_INFO_TYPE_OBJECT);
+    return _get_fields (self, GI_INFO_TYPE_OBJECT);
 }
 
 static PyObject *
@@ -954,9 +954,9 @@ _wrap_g_object_info_get_interfaces (PyGIBaseInfo *self)
     PyObject *infos;
     gssize i;
 
-    n_infos = g_object_info_get_n_interfaces((GIObjectInfo *)self->info);
+    n_infos = g_object_info_get_n_interfaces ( (GIObjectInfo *) self->info);
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -965,19 +965,19 @@ _wrap_g_object_info_get_interfaces (PyGIBaseInfo *self)
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = (GIBaseInfo *)g_object_info_get_interface((GIObjectInfo *)self->info, i);
-        g_assert(info != NULL);
+        info = (GIBaseInfo *) g_object_info_get_interface ( (GIObjectInfo *) self->info, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -986,28 +986,28 @@ _wrap_g_object_info_get_interfaces (PyGIBaseInfo *self)
 static PyObject *
 _wrap_g_object_info_get_constants (PyGIBaseInfo *self)
 {
-    return _get_constants(self, GI_INFO_TYPE_OBJECT);
+    return _get_constants (self, GI_INFO_TYPE_OBJECT);
 }
 
 static PyObject *
 _wrap_g_object_info_get_vfuncs (PyGIBaseInfo *self)
 {
-    return _get_vfuncs(self, GI_INFO_TYPE_OBJECT);
+    return _get_vfuncs (self, GI_INFO_TYPE_OBJECT);
 }
 
 static PyMethodDef _PyGIObjectInfo_methods[] = {
-    { "get_parent", (PyCFunction)_wrap_g_object_info_get_parent, METH_NOARGS },
-    { "get_methods", (PyCFunction)_wrap_g_object_info_get_methods, METH_NOARGS },
-    { "get_fields", (PyCFunction)_wrap_g_object_info_get_fields, METH_NOARGS },
-    { "get_interfaces", (PyCFunction)_wrap_g_object_info_get_interfaces, METH_NOARGS },
-    { "get_constants", (PyCFunction)_wrap_g_object_info_get_constants, METH_NOARGS },
-    { "get_vfuncs", (PyCFunction)_wrap_g_object_info_get_vfuncs, METH_NOARGS },
+    { "get_parent", (PyCFunction) _wrap_g_object_info_get_parent, METH_NOARGS },
+    { "get_methods", (PyCFunction) _wrap_g_object_info_get_methods, METH_NOARGS },
+    { "get_fields", (PyCFunction) _wrap_g_object_info_get_fields, METH_NOARGS },
+    { "get_interfaces", (PyCFunction) _wrap_g_object_info_get_interfaces, METH_NOARGS },
+    { "get_constants", (PyCFunction) _wrap_g_object_info_get_constants, METH_NOARGS },
+    { "get_vfuncs", (PyCFunction) _wrap_g_object_info_get_vfuncs, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* GIInterfaceInfo */
-_PyGI_DEFINE_INFO_TYPE("InterfaceInfo", GIInterfaceInfo, PyGIRegisteredTypeInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("InterfaceInfo", GIInterfaceInfo, PyGIRegisteredTypeInfo_Type);
 
 static PyObject *
 _wrap_g_interface_info_get_methods (PyGIBaseInfo *self)
@@ -1016,9 +1016,9 @@ _wrap_g_interface_info_get_methods (PyGIBaseInfo *self)
     PyObject *infos;
     gssize i;
 
-    n_infos = g_interface_info_get_n_methods((GIInterfaceInfo *)self->info);
+    n_infos = g_interface_info_get_n_methods ( (GIInterfaceInfo *) self->info);
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -1027,19 +1027,19 @@ _wrap_g_interface_info_get_methods (PyGIBaseInfo *self)
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = (GIBaseInfo *)g_interface_info_get_method((GIInterfaceInfo *)self->info, i);
-        g_assert(info != NULL);
+        info = (GIBaseInfo *) g_interface_info_get_method ( (GIInterfaceInfo *) self->info, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -1048,24 +1048,24 @@ _wrap_g_interface_info_get_methods (PyGIBaseInfo *self)
 static PyObject *
 _wrap_g_interface_info_get_constants (PyGIBaseInfo *self)
 {
-    return _get_constants(self, GI_INFO_TYPE_INTERFACE);
+    return _get_constants (self, GI_INFO_TYPE_INTERFACE);
 }
 
 static PyObject *
 _wrap_g_interface_info_get_vfuncs (PyGIBaseInfo *self)
 {
-    return _get_vfuncs(self, GI_INFO_TYPE_INTERFACE);
+    return _get_vfuncs (self, GI_INFO_TYPE_INTERFACE);
 }
 
 static PyMethodDef _PyGIInterfaceInfo_methods[] = {
-    { "get_methods", (PyCFunction)_wrap_g_interface_info_get_methods, METH_NOARGS },
-    { "get_constants", (PyCFunction)_wrap_g_interface_info_get_constants, METH_NOARGS },
-    { "get_vfuncs", (PyCFunction)_wrap_g_interface_info_get_vfuncs, METH_NOARGS },
+    { "get_methods", (PyCFunction) _wrap_g_interface_info_get_methods, METH_NOARGS },
+    { "get_constants", (PyCFunction) _wrap_g_interface_info_get_constants, METH_NOARGS },
+    { "get_vfuncs", (PyCFunction) _wrap_g_interface_info_get_vfuncs, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 /* GIConstantInfo */
-_PyGI_DEFINE_INFO_TYPE("ConstantInfo", GIConstantInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("ConstantInfo", GIConstantInfo, PyGIBaseInfo_Type);
 
 static PyObject *
 _wrap_g_constant_info_get_value (PyGIBaseInfo *self)
@@ -1074,47 +1074,47 @@ _wrap_g_constant_info_get_value (PyGIBaseInfo *self)
     GArgument value;
     PyObject *py_value;
 
-    if (g_constant_info_get_value((GIConstantInfo *)self->info, &value) < 0) {
-        PyErr_SetString(PyExc_RuntimeError, "unable to get value");
+    if (g_constant_info_get_value ( (GIConstantInfo *) self->info, &value) < 0) {
+        PyErr_SetString (PyExc_RuntimeError, "unable to get value");
         return NULL;
     }
 
-    type_info = g_constant_info_get_type((GIConstantInfo *)self->info);
+    type_info = g_constant_info_get_type ( (GIConstantInfo *) self->info);
 
-    py_value = _pygi_argument_to_object(&value, type_info, GI_TRANSFER_NOTHING);
+    py_value = _pygi_argument_to_object (&value, type_info, GI_TRANSFER_NOTHING);
 
-    g_base_info_unref((GIBaseInfo *)type_info);
+    g_base_info_unref ( (GIBaseInfo *) type_info);
 
     return py_value;
 }
 
 static PyMethodDef _PyGIConstantInfo_methods[] = {
-    { "get_value", (PyCFunction)_wrap_g_constant_info_get_value, METH_NOARGS },
+    { "get_value", (PyCFunction) _wrap_g_constant_info_get_value, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 /* GIValueInfo */
-_PyGI_DEFINE_INFO_TYPE("ValueInfo", GIValueInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("ValueInfo", GIValueInfo, PyGIBaseInfo_Type);
 
 static PyObject *
 _wrap_g_value_info_get_value (PyGIBaseInfo *self)
 {
     glong value;
 
-    value = g_value_info_get_value((GIValueInfo *)self->info);
+    value = g_value_info_get_value ( (GIValueInfo *) self->info);
 
-    return PyInt_FromLong(value);
+    return PyInt_FromLong (value);
 }
 
 
 static PyMethodDef _PyGIValueInfo_methods[] = {
-    { "get_value", (PyCFunction)_wrap_g_value_info_get_value, METH_NOARGS },
+    { "get_value", (PyCFunction) _wrap_g_value_info_get_value, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* GIFieldInfo */
-_PyGI_DEFINE_INFO_TYPE("FieldInfo", GIFieldInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("FieldInfo", GIFieldInfo, PyGIBaseInfo_Type);
 
 static PyObject *
 _wrap_g_field_info_get_value (PyGIBaseInfo *self,
@@ -1128,28 +1128,28 @@ _wrap_g_field_info_get_value (PyGIBaseInfo *self,
     GArgument value;
     PyObject *py_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "O:FieldInfo.get_value", &instance)) {
+    if (!PyArg_ParseTuple (args, "O:FieldInfo.get_value", &instance)) {
         return NULL;
     }
 
-    container_info = g_base_info_get_container(self->info);
-    g_assert(container_info != NULL);
+    container_info = g_base_info_get_container (self->info);
+    g_assert (container_info != NULL);
 
     /* Check the instance. */
-    if (!_pygi_g_registered_type_info_check_object((GIRegisteredTypeInfo *)container_info, TRUE, instance)) {
-        _PyGI_ERROR_PREFIX("argument 1: ");
+    if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
+        _PyGI_ERROR_PREFIX ("argument 1: ");
         return NULL;
     }
 
     /* Get the pointer to the container. */
-    container_info_type = g_base_info_get_type(container_info);
+    container_info_type = g_base_info_get_type (container_info);
     switch (container_info_type) {
         case GI_INFO_TYPE_UNION:
         case GI_INFO_TYPE_STRUCT:
-            pointer = pyg_boxed_get(instance, void);
+            pointer = pyg_boxed_get (instance, void);
             break;
         case GI_INFO_TYPE_OBJECT:
-            pointer = pygobject_get(instance);
+            pointer = pygobject_get (instance);
             break;
         default:
             /* Other types don't have fields. */
@@ -1157,34 +1157,34 @@ _wrap_g_field_info_get_value (PyGIBaseInfo *self,
     }
 
     /* Get the field's value. */
-    field_type_info = g_field_info_get_type((GIFieldInfo *)self->info);
+    field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
 
     /* A few types are not handled by g_field_info_get_field, so do it here. */
-    if (!g_type_info_is_pointer(field_type_info)
-            && g_type_info_get_tag(field_type_info) == GI_TYPE_TAG_INTERFACE) {
+    if (!g_type_info_is_pointer (field_type_info)
+            && g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
         GIBaseInfo *info;
         GIInfoType info_type;
 
-        if (!(g_field_info_get_flags((GIFieldInfo *)self->info) & GI_FIELD_IS_READABLE)) {
-            PyErr_SetString(PyExc_RuntimeError, "field is not readable");
+        if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_READABLE)) {
+            PyErr_SetString (PyExc_RuntimeError, "field is not readable");
             goto out;
         }
 
-        info = g_type_info_get_interface(field_type_info);
+        info = g_type_info_get_interface (field_type_info);
 
-        info_type = g_base_info_get_type(info);
+        info_type = g_base_info_get_type (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
-        switch(info_type) {
+        switch (info_type) {
             case GI_INFO_TYPE_UNION:
-                PyErr_SetString(PyExc_NotImplementedError, "getting an union is not supported yet");
+                PyErr_SetString (PyExc_NotImplementedError, "getting an union is not supported yet");
                 goto out;
             case GI_INFO_TYPE_STRUCT:
             {
                 gsize offset;
 
-                offset = g_field_info_get_offset((GIFieldInfo *)self->info);
+                offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
 
                 value.v_pointer = pointer + offset;
 
@@ -1196,16 +1196,16 @@ _wrap_g_field_info_get_value (PyGIBaseInfo *self,
         }
     }
 
-    if (!g_field_info_get_field((GIFieldInfo *)self->info, pointer, &value)) {
-        PyErr_SetString(PyExc_RuntimeError, "unable to get the value");
+    if (!g_field_info_get_field ( (GIFieldInfo *) self->info, pointer, &value)) {
+        PyErr_SetString (PyExc_RuntimeError, "unable to get the value");
         goto out;
     }
 
 argument_to_object:
-    py_value = _pygi_argument_to_object(&value, field_type_info, GI_TRANSFER_NOTHING);
+    py_value = _pygi_argument_to_object (&value, field_type_info, GI_TRANSFER_NOTHING);
 
 out:
-    g_base_info_unref((GIBaseInfo *)field_type_info);
+    g_base_info_unref ( (GIBaseInfo *) field_type_info);
 
     return py_value;
 }
@@ -1223,70 +1223,70 @@ _wrap_g_field_info_set_value (PyGIBaseInfo *self,
     GArgument value;
     PyObject *retval = NULL;
 
-    if (!PyArg_ParseTuple(args, "OO:FieldInfo.set_value", &instance, &py_value)) {
+    if (!PyArg_ParseTuple (args, "OO:FieldInfo.set_value", &instance, &py_value)) {
         return NULL;
     }
 
-    container_info = g_base_info_get_container(self->info);
-    g_assert(container_info != NULL);
+    container_info = g_base_info_get_container (self->info);
+    g_assert (container_info != NULL);
 
     /* Check the instance. */
-    if (!_pygi_g_registered_type_info_check_object((GIRegisteredTypeInfo *)container_info, TRUE, instance)) {
-        _PyGI_ERROR_PREFIX("argument 1: ");
+    if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
+        _PyGI_ERROR_PREFIX ("argument 1: ");
         return NULL;
     }
 
     /* Get the pointer to the container. */
-    container_info_type = g_base_info_get_type(container_info);
+    container_info_type = g_base_info_get_type (container_info);
     switch (container_info_type) {
         case GI_INFO_TYPE_UNION:
         case GI_INFO_TYPE_STRUCT:
-            pointer = pyg_boxed_get(instance, void);
+            pointer = pyg_boxed_get (instance, void);
             break;
         case GI_INFO_TYPE_OBJECT:
-            pointer = pygobject_get(instance);
+            pointer = pygobject_get (instance);
             break;
         default:
             /* Other types don't have fields. */
             g_assert_not_reached();
     }
 
-    field_type_info = g_field_info_get_type((GIFieldInfo *)self->info);
+    field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
 
     /* Check the value. */
     {
         gboolean retval;
 
-        retval = _pygi_g_type_info_check_object(field_type_info, py_value, TRUE);
+        retval = _pygi_g_type_info_check_object (field_type_info, py_value, TRUE);
         if (retval < 0) {
             goto out;
         }
 
         if (!retval) {
-            _PyGI_ERROR_PREFIX("argument 2: ");
+            _PyGI_ERROR_PREFIX ("argument 2: ");
             goto out;
         }
     }
 
     /* Set the field's value. */
     /* A few types are not handled by g_field_info_set_field, so do it here. */
-    if (!g_type_info_is_pointer(field_type_info)
-            && g_type_info_get_tag(field_type_info) == GI_TYPE_TAG_INTERFACE) {
+    if (!g_type_info_is_pointer (field_type_info)
+            && g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
         GIBaseInfo *info;
         GIInfoType info_type;
 
-        if (!(g_field_info_get_flags((GIFieldInfo *)self->info) & GI_FIELD_IS_WRITABLE)) {
-            PyErr_SetString(PyExc_RuntimeError, "field is not writable");
+        if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_WRITABLE)) {
+            PyErr_SetString (PyExc_RuntimeError, "field is not writable");
             goto out;
         }
 
-        info = g_type_info_get_interface(field_type_info);
+        info = g_type_info_get_interface (field_type_info);
 
-        info_type = g_base_info_get_type(info);
+        info_type = g_base_info_get_type (info);
 
         switch (info_type) {
             case GI_INFO_TYPE_UNION:
-                PyErr_SetString(PyExc_NotImplementedError, "setting an union is not supported yet");
+                PyErr_SetString (PyExc_NotImplementedError, "setting an union is not supported yet");
                 goto out;
             case GI_INFO_TYPE_STRUCT:
             {
@@ -1294,28 +1294,28 @@ _wrap_g_field_info_set_value (PyGIBaseInfo *self,
                 gsize offset;
                 gssize size;
 
-                is_simple = pygi_g_struct_info_is_simple((GIStructInfo *)info);
+                is_simple = pygi_g_struct_info_is_simple ( (GIStructInfo *) info);
 
                 if (!is_simple) {
-                    PyErr_SetString(PyExc_TypeError,
-                            "cannot set a structure which has no well-defined ownership transfer rules");
-                    g_base_info_unref(info);
+                    PyErr_SetString (PyExc_TypeError,
+                                     "cannot set a structure which has no well-defined ownership transfer rules");
+                    g_base_info_unref (info);
                     goto out;
                 }
 
-                value = _pygi_argument_from_object(py_value, field_type_info, GI_TRANSFER_NOTHING);
+                value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
                 if (PyErr_Occurred()) {
-                    g_base_info_unref(info);
+                    g_base_info_unref (info);
                     goto out;
                 }
 
-                offset = g_field_info_get_offset((GIFieldInfo *)self->info);
-                size = g_struct_info_get_size((GIStructInfo *)info);
-                g_assert(size > 0);
+                offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
+                size = g_struct_info_get_size ( (GIStructInfo *) info);
+                g_assert (size > 0);
 
-                g_memmove(pointer + offset, value.v_pointer, size);
+                g_memmove (pointer + offset, value.v_pointer, size);
 
-                g_base_info_unref(info);
+                g_base_info_unref (info);
 
                 retval = Py_None;
                 goto out;
@@ -1325,45 +1325,45 @@ _wrap_g_field_info_set_value (PyGIBaseInfo *self,
                 break;
         }
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
     }
 
-    value = _pygi_argument_from_object(py_value, field_type_info, GI_TRANSFER_EVERYTHING);
+    value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_EVERYTHING);
     if (PyErr_Occurred()) {
         goto out;
     }
 
-    if (!g_field_info_set_field((GIFieldInfo *)self->info, pointer, &value)) {
-        _pygi_argument_release(&value, field_type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
-        PyErr_SetString(PyExc_RuntimeError, "unable to set value for field");
+    if (!g_field_info_set_field ( (GIFieldInfo *) self->info, pointer, &value)) {
+        _pygi_argument_release (&value, field_type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+        PyErr_SetString (PyExc_RuntimeError, "unable to set value for field");
         goto out;
     }
 
     retval = Py_None;
 
 out:
-    g_base_info_unref((GIBaseInfo *)field_type_info);
+    g_base_info_unref ( (GIBaseInfo *) field_type_info);
 
-    Py_XINCREF(retval);
+    Py_XINCREF (retval);
     return retval;
 }
 
 static PyMethodDef _PyGIFieldInfo_methods[] = {
-    { "get_value", (PyCFunction)_wrap_g_field_info_get_value, METH_VARARGS },
-    { "set_value", (PyCFunction)_wrap_g_field_info_set_value, METH_VARARGS },
+    { "get_value", (PyCFunction) _wrap_g_field_info_get_value, METH_VARARGS },
+    { "set_value", (PyCFunction) _wrap_g_field_info_set_value, METH_VARARGS },
     { NULL, NULL, 0 }
 };
 
 
 /* GIUnresolvedInfo */
-_PyGI_DEFINE_INFO_TYPE("UnresolvedInfo", GIUnresolvedInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("UnresolvedInfo", GIUnresolvedInfo, PyGIBaseInfo_Type);
 
 static PyMethodDef _PyGIUnresolvedInfo_methods[] = {
     { NULL, NULL, 0 }
 };
 
 /* GIVFuncInfo */
-_PyGI_DEFINE_INFO_TYPE("VFuncInfo", GIVFuncInfo, PyGIBaseInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("VFuncInfo", GIVFuncInfo, PyGIBaseInfo_Type);
 
 static PyMethodDef _PyGIVFuncInfo_methods[] = {
     { NULL, NULL, 0 }
@@ -1371,7 +1371,7 @@ static PyMethodDef _PyGIVFuncInfo_methods[] = {
 
 
 /* GIUnionInfo */
-_PyGI_DEFINE_INFO_TYPE("UnionInfo", GIUnionInfo, PyGIRegisteredTypeInfo_Type);
+_PyGI_DEFINE_INFO_TYPE ("UnionInfo", GIUnionInfo, PyGIRegisteredTypeInfo_Type);
 
 static PyObject *
 _wrap_g_union_info_get_fields (PyGIBaseInfo *self)
@@ -1380,9 +1380,9 @@ _wrap_g_union_info_get_fields (PyGIBaseInfo *self)
     PyObject *infos;
     gssize i;
 
-    n_infos = g_union_info_get_n_fields((GIUnionInfo *)self->info);
+    n_infos = g_union_info_get_n_fields ( (GIUnionInfo *) self->info);
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -1391,19 +1391,19 @@ _wrap_g_union_info_get_fields (PyGIBaseInfo *self)
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = (GIBaseInfo *)g_union_info_get_field((GIUnionInfo *)self->info, i);
-        g_assert(info != NULL);
+        info = (GIBaseInfo *) g_union_info_get_field ( (GIUnionInfo *) self->info, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -1416,9 +1416,9 @@ _wrap_g_union_info_get_methods (PyGIBaseInfo *self)
     PyObject *infos;
     gssize i;
 
-    n_infos = g_union_info_get_n_methods((GIUnionInfo *)self->info);
+    n_infos = g_union_info_get_n_methods ( (GIUnionInfo *) self->info);
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
     if (infos == NULL) {
         return NULL;
     }
@@ -1427,27 +1427,27 @@ _wrap_g_union_info_get_methods (PyGIBaseInfo *self)
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = (GIBaseInfo *)g_union_info_get_method((GIUnionInfo *)self->info, i);
-        g_assert(info != NULL);
+        info = (GIBaseInfo *) g_union_info_get_method ( (GIUnionInfo *) self->info, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
 }
 
 static PyMethodDef _PyGIUnionInfo_methods[] = {
-    { "get_fields", (PyCFunction)_wrap_g_union_info_get_fields, METH_NOARGS },
-    { "get_methods", (PyCFunction)_wrap_g_union_info_get_methods, METH_NOARGS },
+    { "get_fields", (PyCFunction) _wrap_g_union_info_get_fields, METH_NOARGS },
+    { "get_methods", (PyCFunction) _wrap_g_union_info_get_methods, METH_NOARGS },
     { NULL, NULL, 0 }
 };
 
@@ -1459,16 +1459,16 @@ _pygi_g_base_info_get_fullname (GIBaseInfo *info)
     GIBaseInfo *container_info;
     gchar *fullname;
 
-    container_info = g_base_info_get_container(info);
+    container_info = g_base_info_get_container (info);
     if (container_info != NULL) {
-        fullname = g_strdup_printf("%s.%s.%s",
-                g_base_info_get_namespace(container_info),
-                g_base_info_get_name(container_info),
-                g_base_info_get_name(info));
+        fullname = g_strdup_printf ("%s.%s.%s",
+                                    g_base_info_get_namespace (container_info),
+                                    g_base_info_get_name (container_info),
+                                    g_base_info_get_name (info));
     } else {
-        fullname = g_strdup_printf("%s.%s",
-                g_base_info_get_namespace(info),
-                g_base_info_get_name(info));
+        fullname = g_strdup_printf ("%s.%s",
+                                    g_base_info_get_namespace (info),
+                                    g_base_info_get_name (info));
     }
 
     if (fullname == NULL) {
@@ -1488,20 +1488,20 @@ _pygi_info_register_types (PyObject *m)
     if (PyModule_AddObject(m, name, (PyObject *)&type)) \
         return
 
-    _PyGI_REGISTER_TYPE(m, PyGIBaseInfo_Type, "BaseInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIUnresolvedInfo_Type, "UnresolvedInfo");
-    _PyGI_REGISTER_TYPE(m, PyGICallableInfo_Type, "CallableInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIFunctionInfo_Type, "FunctionInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIRegisteredTypeInfo_Type, "RegisteredTypeInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIStructInfo_Type, "StructInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIEnumInfo_Type, "EnumInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIObjectInfo_Type, "ObjectInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIInterfaceInfo_Type, "InterfaceInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIConstantInfo_Type, "ConstantInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIValueInfo_Type, "ValueInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIFieldInfo_Type, "FieldInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIVFuncInfo_Type, "VFuncInfo");
-    _PyGI_REGISTER_TYPE(m, PyGIUnionInfo_Type, "UnionInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIBaseInfo_Type, "BaseInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIUnresolvedInfo_Type, "UnresolvedInfo");
+    _PyGI_REGISTER_TYPE (m, PyGICallableInfo_Type, "CallableInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIFunctionInfo_Type, "FunctionInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIRegisteredTypeInfo_Type, "RegisteredTypeInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIStructInfo_Type, "StructInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIEnumInfo_Type, "EnumInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIObjectInfo_Type, "ObjectInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIInterfaceInfo_Type, "InterfaceInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIConstantInfo_Type, "ConstantInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIValueInfo_Type, "ValueInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIFieldInfo_Type, "FieldInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIVFuncInfo_Type, "VFuncInfo");
+    _PyGI_REGISTER_TYPE (m, PyGIUnionInfo_Type, "UnionInfo");
 
 #undef _PyGI_REGISTER_TYPE
 }
diff --git a/gi/pygi-invoke.c b/gi/pygi-invoke.c
index e5e3617..bf220e7 100644
--- a/gi/pygi-invoke.c
+++ b/gi/pygi-invoke.c
@@ -41,7 +41,7 @@ struct invocation_state
     guint8 user_data_index;
     guint8 destroy_notify_index;
     PyGICClosure *closure;
-    
+
     glong error_arg_pos;
 
     GIArgInfo **arg_infos;
@@ -68,27 +68,27 @@ _initialize_invocation_state (struct invocation_state *state,
 {
     GIFunctionInfoFlags flags;
 
-    flags = g_function_info_get_flags(info);
+    flags = g_function_info_get_flags (info);
     state->is_method = (flags & GI_FUNCTION_IS_METHOD) != 0;
     state->is_constructor = (flags & GI_FUNCTION_IS_CONSTRUCTOR) != 0;
 
     /* Count arguments. */
-    state->n_args = g_callable_info_get_n_args((GICallableInfo *)info);
+    state->n_args = g_callable_info_get_n_args ( (GICallableInfo *) info);
     state->n_in_args = 0;
     state->n_out_args = 0;
     state->n_backup_args = 0;
     state->n_aux_in_args = 0;
     state->n_aux_out_args = 0;
-    
+
     /* Check the argument count. */
-    state->n_py_args = PyTuple_Size(py_args);
-    g_assert(state->n_py_args >= 0);
+    state->n_py_args = PyTuple_Size (py_args);
+    g_assert (state->n_py_args >= 0);
 
     state->error_arg_pos = -1;
 
-    state->arg_infos = g_slice_alloc0(sizeof(gpointer) * state->n_args);
-    state->arg_type_infos = g_slice_alloc0(sizeof(gpointer) * state->n_args);
-    state->args_is_auxiliary = g_slice_alloc0(sizeof(gboolean) * state->n_args);
+    state->arg_infos = g_slice_alloc0 (sizeof (gpointer) * state->n_args);
+    state->arg_type_infos = g_slice_alloc0 (sizeof (gpointer) * state->n_args);
+    state->args_is_auxiliary = g_slice_alloc0 (sizeof (gboolean) * state->n_args);
 
     state->return_value = NULL;
     state->closure = NULL;
@@ -111,12 +111,12 @@ _prepare_invocation_state (struct invocation_state *state,
                                    &state->callback_index, &state->user_data_index,
                                    &state->destroy_notify_index))
         return FALSE;
-        
+
     if (state->callback_index != G_MAXUINT8) {
         if (!_pygi_create_callback (function_info,
                                     state->is_method,
                                     state->is_constructor,
-                                    state->n_args, state->n_py_args, 
+                                    state->n_args, state->n_py_args,
                                     py_args, state->callback_index,
                                     state->user_data_index,
                                     state->destroy_notify_index, &state->closure))
@@ -141,15 +141,15 @@ _prepare_invocation_state (struct invocation_state *state,
         GIDirection direction;
         GITransfer transfer;
         GITypeTag arg_type_tag;
-        
-        state->arg_infos[i] = g_callable_info_get_arg((GICallableInfo *)function_info,
-                                                 i);
 
-        state->arg_type_infos[i] = g_arg_info_get_type(state->arg_infos[i]);
-        
-        direction = g_arg_info_get_direction(state->arg_infos[i]);
-        transfer = g_arg_info_get_ownership_transfer(state->arg_infos[i]);
-        arg_type_tag = g_type_info_get_tag(state->arg_type_infos[i]);
+        state->arg_infos[i] = g_callable_info_get_arg ( (GICallableInfo *) function_info,
+                                                        i);
+
+        state->arg_type_infos[i] = g_arg_info_get_type (state->arg_infos[i]);
+
+        direction = g_arg_info_get_direction (state->arg_infos[i]);
+        transfer = g_arg_info_get_ownership_transfer (state->arg_infos[i]);
+        arg_type_tag = g_type_info_get_tag (state->arg_type_infos[i]);
 
         if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
             state->n_in_args += 1;
@@ -170,7 +170,7 @@ _prepare_invocation_state (struct invocation_state *state,
             {
                 gint length_arg_pos;
 
-                length_arg_pos = g_type_info_get_array_length(state->arg_type_infos[i]);
+                length_arg_pos = g_type_info_get_array_length (state->arg_type_infos[i]);
 
                 if (state->is_method)
                     length_arg_pos--; // length_arg_pos refers to C args
@@ -179,7 +179,7 @@ _prepare_invocation_state (struct invocation_state *state,
                     break;
                 }
 
-                g_assert(length_arg_pos < state->n_args);
+                g_assert (length_arg_pos < state->n_args);
                 state->args_is_auxiliary[length_arg_pos] = TRUE;
 
                 if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
@@ -192,7 +192,7 @@ _prepare_invocation_state (struct invocation_state *state,
                 break;
             }
             case GI_TYPE_TAG_ERROR:
-                g_warn_if_fail(state->error_arg_pos < 0);
+                g_warn_if_fail (state->error_arg_pos < 0);
                 state->error_arg_pos = i;
                 break;
             default:
@@ -200,18 +200,18 @@ _prepare_invocation_state (struct invocation_state *state,
         }
     }
 
-    state->return_type_info = g_callable_info_get_return_type((GICallableInfo *)function_info);
-    state->return_type_tag = g_type_info_get_tag(state->return_type_info);
+    state->return_type_info = g_callable_info_get_return_type ( (GICallableInfo *) function_info);
+    state->return_type_tag = g_type_info_get_tag (state->return_type_info);
 
     if (state->return_type_tag == GI_TYPE_TAG_ARRAY) {
         gint length_arg_pos;
-        length_arg_pos = g_type_info_get_array_length(state->return_type_info);
+        length_arg_pos = g_type_info_get_array_length (state->return_type_info);
 
         if (state->is_method)
             length_arg_pos--; // length_arg_pos refers to C args
 
         if (length_arg_pos >= 0) {
-            g_assert(length_arg_pos < state->n_args);
+            g_assert (length_arg_pos < state->n_args);
             state->args_is_auxiliary[length_arg_pos] = TRUE;
             state->n_aux_out_args += 1;
         }
@@ -227,14 +227,14 @@ _prepare_invocation_state (struct invocation_state *state,
         Py_ssize_t py_args_pos;
 
         n_py_args_expected = state->n_in_args
-            + (state->is_constructor ? 1 : 0)
-            - state->n_aux_in_args
-            - (state->error_arg_pos >= 0 ? 1 : 0);
+                             + (state->is_constructor ? 1 : 0)
+                             - state->n_aux_in_args
+                             - (state->error_arg_pos >= 0 ? 1 : 0);
 
         if (state->n_py_args != n_py_args_expected) {
-            PyErr_Format(PyExc_TypeError,
-                "takes exactly %zd argument(s) (%zd given)",
-                n_py_args_expected, state->n_py_args);
+            PyErr_Format (PyExc_TypeError,
+                          "takes exactly %zd argument(s) (%zd given)",
+                          n_py_args_expected, state->n_py_args);
             return FALSE;
         }
 
@@ -251,8 +251,8 @@ _prepare_invocation_state (struct invocation_state *state,
             gint retval;
             gboolean allow_none;
 
-            direction = g_arg_info_get_direction(state->arg_infos[i]);
-            type_tag = g_type_info_get_tag(state->arg_type_infos[i]);
+            direction = g_arg_info_get_direction (state->arg_infos[i]);
+            type_tag = g_type_info_get_tag (state->arg_type_infos[i]);
 
             if (direction == GI_DIRECTION_OUT
                     || state->args_is_auxiliary[i]
@@ -260,33 +260,33 @@ _prepare_invocation_state (struct invocation_state *state,
                 continue;
             }
 
-            g_assert(py_args_pos < state->n_py_args);
-            py_arg = PyTuple_GET_ITEM(py_args, py_args_pos);
+            g_assert (py_args_pos < state->n_py_args);
+            py_arg = PyTuple_GET_ITEM (py_args, py_args_pos);
 
-            allow_none = g_arg_info_may_be_null(state->arg_infos[i]);
+            allow_none = g_arg_info_may_be_null (state->arg_infos[i]);
 
-            retval = _pygi_g_type_info_check_object(state->arg_type_infos[i],
-                                                    py_arg,
-                                                    allow_none);
+            retval = _pygi_g_type_info_check_object (state->arg_type_infos[i],
+                                                     py_arg,
+                                                     allow_none);
 
             if (retval < 0) {
                 return FALSE;
             } else if (!retval) {
-                _PyGI_ERROR_PREFIX("argument %zd: ", py_args_pos);
+                _PyGI_ERROR_PREFIX ("argument %zd: ", py_args_pos);
                 return FALSE;
             }
 
             py_args_pos += 1;
         }
 
-        g_assert(py_args_pos == state->n_py_args);
+        g_assert (py_args_pos == state->n_py_args);
     }
 
-    state->args = g_slice_alloc0(sizeof(gpointer) * state->n_args);
-    state->in_args = g_slice_alloc0(sizeof(GArgument) * state->n_in_args);
-    state->out_args = g_slice_alloc0(sizeof(GArgument) * state->n_out_args);
-    state->out_values = g_slice_alloc0(sizeof(GArgument) * state->n_out_args);
-    state->backup_args = g_slice_alloc0(sizeof(GArgument) * state->n_backup_args);
+    state->args = g_slice_alloc0 (sizeof (gpointer) * state->n_args);
+    state->in_args = g_slice_alloc0 (sizeof (GArgument) * state->n_in_args);
+    state->out_args = g_slice_alloc0 (sizeof (GArgument) * state->n_out_args);
+    state->out_values = g_slice_alloc0 (sizeof (GArgument) * state->n_out_args);
+    state->backup_args = g_slice_alloc0 (sizeof (GArgument) * state->n_backup_args);
 
     /* Bind args so we can use an unique index. */
     {
@@ -299,21 +299,21 @@ _prepare_invocation_state (struct invocation_state *state,
         for (i = 0; i < state->n_args; i++) {
             GIDirection direction;
 
-            direction = g_arg_info_get_direction(state->arg_infos[i]);
+            direction = g_arg_info_get_direction (state->arg_infos[i]);
 
             switch (direction) {
                 case GI_DIRECTION_IN:
-                    g_assert(in_args_pos < state->n_in_args);
+                    g_assert (in_args_pos < state->n_in_args);
                     state->args[i] = &state->in_args[in_args_pos];
                     in_args_pos += 1;
                     break;
                 case GI_DIRECTION_INOUT:
-                    g_assert(in_args_pos < state->n_in_args);
-                    g_assert(out_args_pos < state->n_out_args);
+                    g_assert (in_args_pos < state->n_in_args);
+                    g_assert (out_args_pos < state->n_out_args);
                     state->in_args[in_args_pos].v_pointer = &state->out_values[out_args_pos];
                     in_args_pos += 1;
                 case GI_DIRECTION_OUT:
-                    g_assert(out_args_pos < state->n_out_args);
+                    g_assert (out_args_pos < state->n_out_args);
                     state->out_args[out_args_pos].v_pointer = &state->out_values[out_args_pos];
                     state->out_values[out_args_pos].v_pointer = NULL;
                     state->args[i] = &state->out_values[out_args_pos];
@@ -321,8 +321,8 @@ _prepare_invocation_state (struct invocation_state *state,
             }
         }
 
-        g_assert(in_args_pos == state->n_in_args);
-        g_assert(out_args_pos == state->n_out_args);
+        g_assert (in_args_pos == state->n_in_args);
+        g_assert (out_args_pos == state->n_out_args);
     }
 
     /* Convert the input arguments. */
@@ -342,28 +342,28 @@ _prepare_invocation_state (struct invocation_state *state,
             GIInfoType container_info_type;
             PyObject *py_arg;
 
-            container_info = g_base_info_get_container(function_info);
-            container_info_type = g_base_info_get_type(container_info);
+            container_info = g_base_info_get_container (function_info);
+            container_info_type = g_base_info_get_type (container_info);
 
-            g_assert(py_args_pos < state->n_py_args);
-            py_arg = PyTuple_GET_ITEM(py_args, py_args_pos);
+            g_assert (py_args_pos < state->n_py_args);
+            py_arg = PyTuple_GET_ITEM (py_args, py_args_pos);
 
-            switch(container_info_type) {
+            switch (container_info_type) {
                 case GI_INFO_TYPE_UNION:
                 case GI_INFO_TYPE_STRUCT:
                 {
                     GType type;
 
-                    type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)container_info);
+                    type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) container_info);
 
-                    if (g_type_is_a(type, G_TYPE_BOXED)) {
-                        g_assert(state->n_in_args > 0);
-                        state->in_args[0].v_pointer = pyg_boxed_get(py_arg, void);
-                    } else if (g_type_is_a(type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
-                        g_assert(state->n_in_args > 0);
-                        state->in_args[0].v_pointer = pyg_pointer_get(py_arg, void);
+                    if (g_type_is_a (type, G_TYPE_BOXED)) {
+                        g_assert (state->n_in_args > 0);
+                        state->in_args[0].v_pointer = pyg_boxed_get (py_arg, void);
+                    } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
+                        g_assert (state->n_in_args > 0);
+                        state->in_args[0].v_pointer = pyg_pointer_get (py_arg, void);
                     } else {
-                        PyErr_Format(PyExc_TypeError, "unable to convert an instance of '%s'", g_type_name(type));
+                        PyErr_Format (PyExc_TypeError, "unable to convert an instance of '%s'", g_type_name (type));
                         return FALSE;
                     }
 
@@ -371,8 +371,8 @@ _prepare_invocation_state (struct invocation_state *state,
                 }
                 case GI_INFO_TYPE_OBJECT:
                 case GI_INFO_TYPE_INTERFACE:
-                    g_assert(state->n_in_args > 0);
-                    state->in_args[0].v_pointer = pygobject_get(py_arg);
+                    g_assert (state->n_in_args > 0);
+                    state->in_args[0].v_pointer = pygobject_get (py_arg);
                     break;
                 default:
                     /* Other types don't have methods. */
@@ -398,36 +398,36 @@ _prepare_invocation_state (struct invocation_state *state,
                 state->args[i]->v_pointer = destroy_notify->closure;
                 continue;
             }
-            
+
             if (state->args_is_auxiliary[i]) {
                 continue;
             }
 
-            direction = g_arg_info_get_direction(state->arg_infos[i]);
+            direction = g_arg_info_get_direction (state->arg_infos[i]);
 
             if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
                 PyObject *py_arg;
                 GITypeTag arg_type_tag;
                 GITransfer transfer;
 
-                arg_type_tag = g_type_info_get_tag(state->arg_type_infos[i]);
+                arg_type_tag = g_type_info_get_tag (state->arg_type_infos[i]);
 
                 if (arg_type_tag == GI_TYPE_TAG_ERROR) {
                     GError **error;
 
-                    error = g_slice_new(GError *);
+                    error = g_slice_new (GError *);
                     *error = NULL;
 
                     state->args[i]->v_pointer = error;
                     continue;
                 }
 
-                transfer = g_arg_info_get_ownership_transfer(state->arg_infos[i]);
+                transfer = g_arg_info_get_ownership_transfer (state->arg_infos[i]);
 
-                g_assert(py_args_pos < state->n_py_args);
-                py_arg = PyTuple_GET_ITEM(py_args, py_args_pos);
+                g_assert (py_args_pos < state->n_py_args);
+                py_arg = PyTuple_GET_ITEM (py_args, py_args_pos);
 
-                *state->args[i] = _pygi_argument_from_object(py_arg, state->arg_type_infos[i], transfer);
+                *state->args[i] = _pygi_argument_from_object (py_arg, state->arg_type_infos[i], transfer);
 
                 if (PyErr_Occurred()) {
                     /* TODO: release previous input arguments. */
@@ -436,7 +436,7 @@ _prepare_invocation_state (struct invocation_state *state,
 
                 if (direction == GI_DIRECTION_INOUT && transfer == GI_TRANSFER_NOTHING) {
                     /* We need to keep a copy of the argument to be able to release it later. */
-                    g_assert(backup_args_pos < state->n_backup_args);
+                    g_assert (backup_args_pos < state->n_backup_args);
                     state->backup_args[backup_args_pos] = *state->args[i];
                     backup_args_pos += 1;
                 } else if (transfer == GI_TRANSFER_CONTAINER) {
@@ -450,23 +450,23 @@ _prepare_invocation_state (struct invocation_state *state,
 
                             array = state->args[i]->v_pointer;
 
-                            item_size = g_array_get_element_size(array);
+                            item_size = g_array_get_element_size (array);
 
-                            new_array = g_array_sized_new(FALSE, FALSE, item_size, array->len);
-                            g_array_append_vals(new_array, array->data, array->len);
+                            new_array = g_array_sized_new (FALSE, FALSE, item_size, array->len);
+                            g_array_append_vals (new_array, array->data, array->len);
 
-                            g_assert(backup_args_pos < state->n_backup_args);
+                            g_assert (backup_args_pos < state->n_backup_args);
                             state->backup_args[backup_args_pos].v_pointer = new_array;
 
                             break;
                         }
                         case GI_TYPE_TAG_GLIST:
-                            g_assert(backup_args_pos < state->n_backup_args);
-                            state->backup_args[backup_args_pos].v_pointer = g_list_copy(state->args[i]->v_pointer);
+                            g_assert (backup_args_pos < state->n_backup_args);
+                            state->backup_args[backup_args_pos].v_pointer = g_list_copy (state->args[i]->v_pointer);
                             break;
                         case GI_TYPE_TAG_GSLIST:
-                            g_assert(backup_args_pos < state->n_backup_args);
-                            state->backup_args[backup_args_pos].v_pointer = g_slist_copy(state->args[i]->v_pointer);
+                            g_assert (backup_args_pos < state->n_backup_args);
+                            state->backup_args[backup_args_pos].v_pointer = g_slist_copy (state->args[i]->v_pointer);
                             break;
                         case GI_TYPE_TAG_GHASH:
                         {
@@ -476,11 +476,11 @@ _prepare_invocation_state (struct invocation_state *state,
 
                             hash_table = state->args[i]->v_pointer;
 
-                            keys = g_hash_table_get_keys(hash_table);
-                            values = g_hash_table_get_values(hash_table);
+                            keys = g_hash_table_get_keys (hash_table);
+                            values = g_hash_table_get_values (hash_table);
 
-                            g_assert(backup_args_pos < state->n_backup_args);
-                            state->backup_args[backup_args_pos].v_pointer = g_list_concat(keys, values);
+                            g_assert (backup_args_pos < state->n_backup_args);
+                            state->backup_args[backup_args_pos].v_pointer = g_list_concat (keys, values);
 
                             break;
                         }
@@ -497,26 +497,26 @@ _prepare_invocation_state (struct invocation_state *state,
 
                     array = state->args[i]->v_pointer;
 
-                    length_arg_pos = g_type_info_get_array_length(state->arg_type_infos[i]);
+                    length_arg_pos = g_type_info_get_array_length (state->arg_type_infos[i]);
                     if (state->is_method)
                         length_arg_pos--; // length_arg_pos refers to C args
                     if (length_arg_pos >= 0) {
-                    	int len = 0;
+                        int len = 0;
                         /* Set the auxiliary argument holding the length. */
-                    	if (array)
-                    		len = array->len;
+                        if (array)
+                            len = array->len;
 
                         state->args[length_arg_pos]->v_size = len;
                     }
 
                     /* Get rid of the GArray. */
-                    if ((array != NULL) &&
-                        (g_type_info_get_array_type(state->arg_type_infos[i]) == GI_ARRAY_TYPE_C)) {
+                    if ( (array != NULL) &&
+                            (g_type_info_get_array_type (state->arg_type_infos[i]) == GI_ARRAY_TYPE_C)) {
                         state->args[i]->v_pointer = array->data;
 
                         if (direction != GI_DIRECTION_INOUT || transfer != GI_TRANSFER_NOTHING) {
                             /* The array hasn't been referenced anywhere, so free it to avoid losing memory. */
-                            g_array_free(array, FALSE);
+                            g_array_free (array, FALSE);
                         }
                     }
                 }
@@ -525,8 +525,8 @@ _prepare_invocation_state (struct invocation_state *state,
             }
         }
 
-        g_assert(py_args_pos == state->n_py_args);
-        g_assert(backup_args_pos == state->n_backup_args);
+        g_assert (py_args_pos == state->n_py_args);
+        g_assert (backup_args_pos == state->n_backup_args);
     }
 
     return TRUE;
@@ -541,13 +541,13 @@ _invoke_function (struct invocation_state *state,
 
     error = NULL;
 
-    retval = g_function_info_invoke((GIFunctionInfo *)function_info,
-            state->in_args, state->n_in_args, state->out_args, state->n_out_args, &state->return_arg, &error);
+    retval = g_function_info_invoke ( (GIFunctionInfo *) function_info,
+                                      state->in_args, state->n_in_args, state->out_args, state->n_out_args, &state->return_arg, &error);
     if (!retval) {
-        g_assert(error != NULL);
+        g_assert (error != NULL);
         /* TODO: raise the right error, out of the error domain. */
-        PyErr_SetString(PyExc_RuntimeError, error->message);
-        g_error_free(error);
+        PyErr_SetString (PyExc_RuntimeError, error->message);
+        g_error_free (error);
 
         /* TODO: release input arguments. */
 
@@ -561,8 +561,8 @@ _invoke_function (struct invocation_state *state,
 
         if (*error != NULL) {
             /* TODO: raise the right error, out of the error domain, if applicable. */
-            PyErr_SetString(PyExc_Exception, (*error)->message);
-            g_error_free(*error);
+            PyErr_SetString (PyExc_Exception, (*error)->message);
+            g_error_free (*error);
 
             /* TODO: release input arguments. */
 
@@ -586,45 +586,45 @@ _process_invocation_state (struct invocation_state *state,
         GIInfoType info_type;
         GITransfer transfer;
 
-        g_assert(state->n_py_args > 0);
-        py_type = (PyTypeObject *)PyTuple_GET_ITEM(py_args, 0);
+        g_assert (state->n_py_args > 0);
+        py_type = (PyTypeObject *) PyTuple_GET_ITEM (py_args, 0);
 
-        info = g_type_info_get_interface(state->return_type_info);
-        g_assert(info != NULL);
+        info = g_type_info_get_interface (state->return_type_info);
+        g_assert (info != NULL);
 
-        info_type = g_base_info_get_type(info);
+        info_type = g_base_info_get_type (info);
 
-        transfer = g_callable_info_get_caller_owns((GICallableInfo *)function_info);
+        transfer = g_callable_info_get_caller_owns ( (GICallableInfo *) function_info);
 
         switch (info_type) {
             case GI_INFO_TYPE_UNION:
                 /* TODO */
-                PyErr_SetString(PyExc_NotImplementedError, "creating unions is not supported yet");
-                g_base_info_unref(info);
+                PyErr_SetString (PyExc_NotImplementedError, "creating unions is not supported yet");
+                g_base_info_unref (info);
                 return FALSE;
             case GI_INFO_TYPE_STRUCT:
             {
                 GType type;
 
-                type = g_registered_type_info_get_g_type((GIRegisteredTypeInfo *)info);
+                type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 
-                if (g_type_is_a(type, G_TYPE_BOXED)) {
+                if (g_type_is_a (type, G_TYPE_BOXED)) {
                     if (state->return_arg.v_pointer == NULL) {
-                        PyErr_SetString(PyExc_TypeError, "constructor returned NULL");
+                        PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
                         break;
                     }
-                    g_warn_if_fail(transfer == GI_TRANSFER_EVERYTHING);
-                    state->return_value = _pygi_boxed_new(py_type, state->return_arg.v_pointer, transfer == GI_TRANSFER_EVERYTHING);
-                } else if (g_type_is_a(type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
+                    g_warn_if_fail (transfer == GI_TRANSFER_EVERYTHING);
+                    state->return_value = _pygi_boxed_new (py_type, state->return_arg.v_pointer, transfer == GI_TRANSFER_EVERYTHING);
+                } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
                     if (state->return_arg.v_pointer == NULL) {
-                        PyErr_SetString(PyExc_TypeError, "constructor returned NULL");
+                        PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
                         break;
                     }
-                    g_warn_if_fail(transfer == GI_TRANSFER_NOTHING);
-                    state->return_value = _pygi_struct_new(py_type, state->return_arg.v_pointer, transfer == GI_TRANSFER_EVERYTHING);
+                    g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
+                    state->return_value = _pygi_struct_new (py_type, state->return_arg.v_pointer, transfer == GI_TRANSFER_EVERYTHING);
                 } else {
-                    PyErr_Format(PyExc_TypeError, "cannot create '%s' instances", py_type->tp_name);
-                    g_base_info_unref(info);
+                    PyErr_Format (PyExc_TypeError, "cannot create '%s' instances", py_type->tp_name);
+                    g_base_info_unref (info);
                     return FALSE;
                 }
 
@@ -632,10 +632,10 @@ _process_invocation_state (struct invocation_state *state,
             }
             case GI_INFO_TYPE_OBJECT:
                 if (state->return_arg.v_pointer == NULL) {
-                    PyErr_SetString(PyExc_TypeError, "constructor returned NULL");
+                    PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
                     break;
                 }
-                state->return_value = pygobject_new(state->return_arg.v_pointer);
+                state->return_value = pygobject_new (state->return_arg.v_pointer);
                 if (transfer == GI_TRANSFER_EVERYTHING) {
                     /* The new wrapper increased the reference count, so decrease it. */
                     g_object_unref (state->return_arg.v_pointer);
@@ -646,7 +646,7 @@ _process_invocation_state (struct invocation_state *state,
                 g_assert_not_reached();
         }
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (state->return_value == NULL) {
             /* TODO: release arguments. */
@@ -655,26 +655,26 @@ _process_invocation_state (struct invocation_state *state,
     } else {
         GITransfer transfer;
 
-        if ((state->return_type_tag == GI_TYPE_TAG_ARRAY) &&
-            (g_type_info_get_array_type(state->return_type_info) == GI_ARRAY_TYPE_C)) {
+        if ( (state->return_type_tag == GI_TYPE_TAG_ARRAY) &&
+                (g_type_info_get_array_type (state->return_type_info) == GI_ARRAY_TYPE_C)) {
             /* Create a #GArray. */
-            state->return_arg.v_pointer = _pygi_argument_to_array(&state->return_arg, state->args, state->return_type_info, state->is_method);
+            state->return_arg.v_pointer = _pygi_argument_to_array (&state->return_arg, state->args, state->return_type_info, state->is_method);
         }
 
-        transfer = g_callable_info_get_caller_owns((GICallableInfo *)function_info);
+        transfer = g_callable_info_get_caller_owns ( (GICallableInfo *) function_info);
 
-        state->return_value = _pygi_argument_to_object(&state->return_arg, state->return_type_info, transfer);
+        state->return_value = _pygi_argument_to_object (&state->return_arg, state->return_type_info, transfer);
         if (state->return_value == NULL) {
             /* TODO: release argument. */
             return FALSE;
         }
 
-        _pygi_argument_release(&state->return_arg, state->return_type_info, transfer, GI_DIRECTION_OUT);
+        _pygi_argument_release (&state->return_arg, state->return_type_info, transfer, GI_DIRECTION_OUT);
 
         if (state->return_type_tag == GI_TYPE_TAG_ARRAY
                 && transfer == GI_TRANSFER_NOTHING) {
             /* We created a #GArray, so free it. */
-            state->return_arg.v_pointer = g_array_free(state->return_arg.v_pointer, FALSE);
+            state->return_arg.v_pointer = g_array_free (state->return_arg.v_pointer, FALSE);
         }
     }
 
@@ -690,7 +690,7 @@ _process_invocation_state (struct invocation_state *state,
             /* Return a tuple. */
             PyObject *return_values;
 
-            return_values = PyTuple_New(state->n_return_values);
+            return_values = PyTuple_New (state->n_return_values);
             if (return_values == NULL) {
                 /* TODO: release arguments. */
                 return FALSE;
@@ -698,11 +698,11 @@ _process_invocation_state (struct invocation_state *state,
 
             if (state->return_type_tag == GI_TYPE_TAG_VOID) {
                 /* The current return value is None. */
-                Py_DECREF(state->return_value);
+                Py_DECREF (state->return_value);
             } else {
                 /* Put the return value first. */
-                g_assert(state->return_value != NULL);
-                PyTuple_SET_ITEM(return_values, return_values_pos, state->return_value);
+                g_assert (state->return_value != NULL);
+                PyTuple_SET_ITEM (return_values, return_values_pos, state->return_value);
                 return_values_pos += 1;
             }
 
@@ -719,35 +719,35 @@ _process_invocation_state (struct invocation_state *state,
                 continue;
             }
 
-            direction = g_arg_info_get_direction(state->arg_infos[i]);
-            transfer = g_arg_info_get_ownership_transfer(state->arg_infos[i]);
+            direction = g_arg_info_get_direction (state->arg_infos[i]);
+            transfer = g_arg_info_get_ownership_transfer (state->arg_infos[i]);
 
-            type_tag = g_type_info_get_tag(state->arg_type_infos[i]);
+            type_tag = g_type_info_get_tag (state->arg_type_infos[i]);
 
-            if ((type_tag == GI_TYPE_TAG_ARRAY) &&
-                (g_type_info_get_array_type(state->arg_type_infos[i]) == GI_ARRAY_TYPE_C) &&
-                (direction != GI_DIRECTION_IN || transfer == GI_TRANSFER_NOTHING)) {
+            if ( (type_tag == GI_TYPE_TAG_ARRAY) &&
+                    (g_type_info_get_array_type (state->arg_type_infos[i]) == GI_ARRAY_TYPE_C) &&
+                    (direction != GI_DIRECTION_IN || transfer == GI_TRANSFER_NOTHING)) {
                 /* Create a #GArray. */
-                state->args[i]->v_pointer = _pygi_argument_to_array(state->args[i], state->args, state->arg_type_infos[i], state->is_method);
+                state->args[i]->v_pointer = _pygi_argument_to_array (state->args[i], state->args, state->arg_type_infos[i], state->is_method);
             }
 
             if (direction == GI_DIRECTION_INOUT || direction == GI_DIRECTION_OUT) {
                 /* Convert the argument. */
                 PyObject *obj;
 
-                obj = _pygi_argument_to_object(state->args[i], state->arg_type_infos[i], transfer);
+                obj = _pygi_argument_to_object (state->args[i], state->arg_type_infos[i], transfer);
                 if (obj == NULL) {
                     /* TODO: release arguments. */
                     return FALSE;
                 }
 
-                g_assert(return_values_pos < state->n_return_values);
+                g_assert (return_values_pos < state->n_return_values);
 
                 if (state->n_return_values > 1) {
-                    PyTuple_SET_ITEM(state->return_value, return_values_pos, obj);
+                    PyTuple_SET_ITEM (state->return_value, return_values_pos, obj);
                 } else {
                     /* The current return value is None. */
-                    Py_DECREF(state->return_value);
+                    Py_DECREF (state->return_value);
                     state->return_value = obj;
                 }
 
@@ -756,16 +756,16 @@ _process_invocation_state (struct invocation_state *state,
 
             /* Release the argument. */
 
-            if ((direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT)
+            if ( (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT)
                     && transfer == GI_TRANSFER_CONTAINER) {
                 /* Release the items we kept in another container. */
                 switch (type_tag) {
                     case GI_TYPE_TAG_ARRAY:
                     case GI_TYPE_TAG_GLIST:
                     case GI_TYPE_TAG_GSLIST:
-                        g_assert(backup_args_pos < state->n_backup_args);
-                        _pygi_argument_release(&state->backup_args[backup_args_pos], state->arg_type_infos[i],
-                            transfer, GI_DIRECTION_IN);
+                        g_assert (backup_args_pos < state->n_backup_args);
+                        _pygi_argument_release (&state->backup_args[backup_args_pos], state->arg_type_infos[i],
+                                                transfer, GI_DIRECTION_IN);
                         break;
                     case GI_TYPE_TAG_GHASH:
                     {
@@ -775,25 +775,25 @@ _process_invocation_state (struct invocation_state *state,
                         gsize length;
                         gsize j;
 
-                        key_type_info = g_type_info_get_param_type(state->arg_type_infos[i], 0);
-                        value_type_info = g_type_info_get_param_type(state->arg_type_infos[i], 1);
+                        key_type_info = g_type_info_get_param_type (state->arg_type_infos[i], 0);
+                        value_type_info = g_type_info_get_param_type (state->arg_type_infos[i], 1);
 
-                        g_assert(backup_args_pos < state->n_backup_args);
+                        g_assert (backup_args_pos < state->n_backup_args);
                         item = state->backup_args[backup_args_pos].v_pointer;
 
-                        length = g_list_length(item) / 2;
+                        length = g_list_length (item) / 2;
 
-                        for (j = 0; j < length; j++, item = g_list_next(item)) {
-                            _pygi_argument_release((GArgument *)&item->data, key_type_info,
-                                GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                        for (j = 0; j < length; j++, item = g_list_next (item)) {
+                            _pygi_argument_release ( (GArgument *) &item->data, key_type_info,
+                                                     GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                         }
 
-                        for (j = 0; j < length; j++, item = g_list_next(item)) {
-                            _pygi_argument_release((GArgument *)&item->data, value_type_info,
-                                GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                        for (j = 0; j < length; j++, item = g_list_next (item)) {
+                            _pygi_argument_release ( (GArgument *) &item->data, value_type_info,
+                                                     GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                         }
 
-                        g_list_free(state->backup_args[backup_args_pos].v_pointer);
+                        g_list_free (state->backup_args[backup_args_pos].v_pointer);
 
                         break;
                     }
@@ -803,34 +803,34 @@ _process_invocation_state (struct invocation_state *state,
 
                 if (direction == GI_DIRECTION_INOUT) {
                     /* Release the output argument. */
-                    _pygi_argument_release(state->args[i], state->arg_type_infos[i], GI_TRANSFER_CONTAINER,
-                        GI_DIRECTION_OUT);
+                    _pygi_argument_release (state->args[i], state->arg_type_infos[i], GI_TRANSFER_CONTAINER,
+                                            GI_DIRECTION_OUT);
                 }
 
                 backup_args_pos += 1;
             } else if (direction == GI_DIRECTION_INOUT) {
                 if (transfer == GI_TRANSFER_NOTHING) {
-                    g_assert(backup_args_pos < state->n_backup_args);
-                    _pygi_argument_release(&state->backup_args[backup_args_pos], state->arg_type_infos[i],
-                        GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
+                    g_assert (backup_args_pos < state->n_backup_args);
+                    _pygi_argument_release (&state->backup_args[backup_args_pos], state->arg_type_infos[i],
+                                            GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
                     backup_args_pos += 1;
                 }
 
-                _pygi_argument_release(state->args[i], state->arg_type_infos[i], transfer,
-                    GI_DIRECTION_OUT);
+                _pygi_argument_release (state->args[i], state->arg_type_infos[i], transfer,
+                                        GI_DIRECTION_OUT);
             } else {
-                _pygi_argument_release(state->args[i], state->arg_type_infos[i], transfer, direction);
+                _pygi_argument_release (state->args[i], state->arg_type_infos[i], transfer, direction);
             }
 
             if (type_tag == GI_TYPE_TAG_ARRAY
                     && (direction != GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)) {
                 /* We created a #GArray and it has not been released above, so free it. */
-                state->args[i]->v_pointer = g_array_free(state->args[i]->v_pointer, FALSE);
+                state->args[i]->v_pointer = g_array_free (state->args[i]->v_pointer, FALSE);
             }
         }
 
-        g_assert(state->n_return_values <= 1 || return_values_pos == state->n_return_values);
-        g_assert(backup_args_pos == state->n_backup_args);
+        g_assert (state->n_return_values <= 1 || return_values_pos == state->n_return_values);
+        g_assert (backup_args_pos == state->n_backup_args);
     }
 
     return TRUE;
@@ -842,55 +842,55 @@ _free_invocation_state (struct invocation_state *state)
     gsize i;
 
     if (state->return_type_info != NULL) {
-        g_base_info_unref((GIBaseInfo *)state->return_type_info);
+        g_base_info_unref ( (GIBaseInfo *) state->return_type_info);
     }
 
     if (state->closure != NULL) {
-        if (state->closure->scope == GI_SCOPE_TYPE_CALL) 
-            _pygi_invoke_closure_free(state->closure);
+        if (state->closure->scope == GI_SCOPE_TYPE_CALL)
+            _pygi_invoke_closure_free (state->closure);
     }
 
     for (i = 0; i < state->n_args; i++) {
         if (state->arg_type_infos[i] != NULL)
-            g_base_info_unref((GIBaseInfo *)state->arg_type_infos[i]);
+            g_base_info_unref ( (GIBaseInfo *) state->arg_type_infos[i]);
         if (state->arg_infos[i] != NULL)
-            g_base_info_unref((GIBaseInfo *)state->arg_infos[i]);
+            g_base_info_unref ( (GIBaseInfo *) state->arg_infos[i]);
     }
 
     if (state->arg_infos != NULL) {
-        g_slice_free1(sizeof(gpointer) * state->n_args, state->arg_infos);
+        g_slice_free1 (sizeof (gpointer) * state->n_args, state->arg_infos);
     }
 
     if (state->arg_type_infos != NULL) {
-        g_slice_free1(sizeof(gpointer) * state->n_args, state->arg_type_infos);
+        g_slice_free1 (sizeof (gpointer) * state->n_args, state->arg_type_infos);
     }
 
     if (state->args != NULL) {
-        g_slice_free1(sizeof(gpointer) * state->n_args, state->args);
+        g_slice_free1 (sizeof (gpointer) * state->n_args, state->args);
     }
 
     if (state->args_is_auxiliary != NULL) {
-        g_slice_free1(sizeof(gboolean) * state->n_args, state->args_is_auxiliary);
+        g_slice_free1 (sizeof (gboolean) * state->n_args, state->args_is_auxiliary);
     }
 
     if (state->in_args != NULL) {
-        g_slice_free1(sizeof(GArgument) * state->n_in_args, state->in_args);
+        g_slice_free1 (sizeof (GArgument) * state->n_in_args, state->in_args);
     }
 
     if (state->out_args != NULL) {
-        g_slice_free1(sizeof(GArgument) * state->n_out_args, state->out_args);
+        g_slice_free1 (sizeof (GArgument) * state->n_out_args, state->out_args);
     }
 
     if (state->out_values != NULL) {
-        g_slice_free1(sizeof(GArgument) * state->n_out_args, state->out_values);
+        g_slice_free1 (sizeof (GArgument) * state->n_out_args, state->out_values);
     }
 
     if (state->backup_args != NULL) {
-        g_slice_free1(sizeof(GArgument) * state->n_backup_args, state->backup_args);
+        g_slice_free1 (sizeof (GArgument) * state->n_backup_args, state->backup_args);
     }
 
     if (PyErr_Occurred()) {
-        Py_CLEAR(state->return_value);
+        Py_CLEAR (state->return_value);
     }
 }
 
diff --git a/gi/pygi-repository.c b/gi/pygi-repository.c
index f84fc7b..783b4aa 100644
--- a/gi/pygi-repository.c
+++ b/gi/pygi-repository.c
@@ -28,34 +28,34 @@ PyObject *PyGIRepositoryError;
 static PyMethodDef _PyGIRepository_methods[];
 
 PyTypeObject PyGIRepository_Type = {
-    PyObject_HEAD_INIT(NULL)
+    PyObject_HEAD_INIT (NULL)
     0,
     "gi.Repository",         /* tp_name */
-    sizeof(PyGIRepository),  /* tp_basicsize */
+    sizeof (PyGIRepository), /* tp_basicsize */
     0,                       /* tp_itemsize */
-    (destructor)NULL,        /* tp_dealloc */
-    (printfunc)NULL,         /* tp_print */
-    (getattrfunc)NULL,       /* tp_getattr */
-    (setattrfunc)NULL,       /* tp_setattr */
-    (cmpfunc)NULL,           /* tp_compare */
-    (reprfunc)NULL,          /* tp_repr */
+    (destructor) NULL,       /* tp_dealloc */
+    (printfunc) NULL,        /* tp_print */
+    (getattrfunc) NULL,      /* tp_getattr */
+    (setattrfunc) NULL,      /* tp_setattr */
+    (cmpfunc) NULL,          /* tp_compare */
+    (reprfunc) NULL,         /* tp_repr */
     NULL,                    /* tp_as_number */
     NULL,                    /* tp_as_sequence */
     NULL,                    /* tp_as_mapping */
-    (hashfunc)NULL,          /* tp_hash */
-    (ternaryfunc)NULL,       /* tp_call */
-    (reprfunc)NULL,          /* tp_str */
-    (getattrofunc)NULL,      /* tp_getattro */
-    (setattrofunc)NULL,      /* tp_setattro */
+    (hashfunc) NULL,         /* tp_hash */
+    (ternaryfunc) NULL,      /* tp_call */
+    (reprfunc) NULL,         /* tp_str */
+    (getattrofunc) NULL,     /* tp_getattro */
+    (setattrofunc) NULL,     /* tp_setattro */
     NULL,                    /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT,      /* tp_flags */
     NULL,                    /* tp_doc */
-    (traverseproc)NULL,      /* tp_traverse */
-    (inquiry)NULL,           /* tp_clear */
-    (richcmpfunc)NULL,       /* tp_richcompare */
+    (traverseproc) NULL,     /* tp_traverse */
+    (inquiry) NULL,          /* tp_clear */
+    (richcmpfunc) NULL,      /* tp_richcompare */
     0,                       /* tp_weaklistoffset */
-    (getiterfunc)NULL,       /* tp_iter */
-    (iternextfunc)NULL,      /* tp_iternext */
+    (getiterfunc) NULL,      /* tp_iter */
+    (iternextfunc) NULL,     /* tp_iternext */
     _PyGIRepository_methods, /* tp_methods */
 };
 
@@ -65,7 +65,7 @@ _wrap_g_irepository_get_default (PyObject *self)
     static PyGIRepository *repository = NULL;
 
     if (!repository) {
-        repository = (PyGIRepository *)PyObject_New(PyGIRepository, &PyGIRepository_Type);
+        repository = (PyGIRepository *) PyObject_New (PyGIRepository, &PyGIRepository_Type);
         if (repository == NULL) {
             return NULL;
         }
@@ -73,8 +73,8 @@ _wrap_g_irepository_get_default (PyObject *self)
         repository->repository = g_irepository_get_default();
     }
 
-    Py_INCREF((PyObject *)repository);
-    return (PyObject *)repository;
+    Py_INCREF ( (PyObject *) repository);
+    return (PyObject *) repository;
 }
 
 static PyObject *
@@ -91,20 +91,20 @@ _wrap_g_irepository_require (PyGIRepository *self,
     GTypelib *typelib;
     GError *error;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|sO:Repository.require",
-            kwlist, &namespace_, &version, &lazy)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs, "s|sO:Repository.require",
+                                      kwlist, &namespace_, &version, &lazy)) {
         return NULL;
     }
 
-    if (lazy != NULL && PyObject_IsTrue(lazy)) {
+    if (lazy != NULL && PyObject_IsTrue (lazy)) {
         flags |= G_IREPOSITORY_LOAD_FLAG_LAZY;
     }
 
     error = NULL;
-    typelib = g_irepository_require(self->repository, namespace_, version, flags, &error);
+    typelib = g_irepository_require (self->repository, namespace_, version, flags, &error);
     if (error != NULL) {
-        PyErr_SetString(PyGIRepositoryError, error->message);
-        g_error_free(error);
+        PyErr_SetString (PyGIRepositoryError, error->message);
+        g_error_free (error);
         return NULL;
     }
 
@@ -123,19 +123,19 @@ _wrap_g_irepository_find_by_name (PyGIRepository *self,
     GIBaseInfo *info;
     PyObject *py_info;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-            "ss:Repository.find_by_name", kwlist, &namespace_, &name)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "ss:Repository.find_by_name", kwlist, &namespace_, &name)) {
         return NULL;
     }
 
-    info = g_irepository_find_by_name(self->repository, namespace_, name);
+    info = g_irepository_find_by_name (self->repository, namespace_, name);
     if (info == NULL) {
         Py_RETURN_NONE;
     }
 
-    py_info = _pygi_info_new(info);
+    py_info = _pygi_info_new (info);
 
-    g_base_info_unref(info);
+    g_base_info_unref (info);
 
     return py_info;
 }
@@ -152,36 +152,36 @@ _wrap_g_irepository_get_infos (PyGIRepository *self,
     PyObject *infos;
     gssize i;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:Repository.get_infos",
-            kwlist, &namespace_)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs, "s:Repository.get_infos",
+                                      kwlist, &namespace_)) {
         return NULL;
     }
 
-    n_infos = g_irepository_get_n_infos(self->repository, namespace_);
+    n_infos = g_irepository_get_n_infos (self->repository, namespace_);
     if (n_infos < 0) {
-        PyErr_Format(PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_);
+        PyErr_Format (PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_);
         return NULL;
     }
 
-    infos = PyTuple_New(n_infos);
+    infos = PyTuple_New (n_infos);
 
     for (i = 0; i < n_infos; i++) {
         GIBaseInfo *info;
         PyObject *py_info;
 
-        info = g_irepository_get_info(self->repository, namespace_, i);
-        g_assert(info != NULL);
+        info = g_irepository_get_info (self->repository, namespace_, i);
+        g_assert (info != NULL);
 
-        py_info = _pygi_info_new(info);
+        py_info = _pygi_info_new (info);
 
-        g_base_info_unref(info);
+        g_base_info_unref (info);
 
         if (py_info == NULL) {
-            Py_CLEAR(infos);
+            Py_CLEAR (infos);
             break;
         }
 
-        PyTuple_SET_ITEM(infos, i, py_info);
+        PyTuple_SET_ITEM (infos, i, py_info);
     }
 
     return infos;
@@ -196,26 +196,26 @@ _wrap_g_irepository_get_typelib_path (PyGIRepository *self,
     const char *namespace_;
     const gchar *typelib_path;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-            "s:Repository.get_typelib_path", kwlist, &namespace_)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "s:Repository.get_typelib_path", kwlist, &namespace_)) {
         return NULL;
     }
 
-    typelib_path = g_irepository_get_typelib_path(self->repository, namespace_);
+    typelib_path = g_irepository_get_typelib_path (self->repository, namespace_);
     if (typelib_path == NULL) {
-        PyErr_Format(PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_);
+        PyErr_Format (PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_);
         return NULL;
     }
 
-    return PyString_FromString(typelib_path);
+    return PyString_FromString (typelib_path);
 }
 
 static PyMethodDef _PyGIRepository_methods[] = {
-    { "get_default", (PyCFunction)_wrap_g_irepository_get_default, METH_STATIC|METH_NOARGS },
-    { "require", (PyCFunction)_wrap_g_irepository_require, METH_VARARGS|METH_KEYWORDS },
-    { "get_infos", (PyCFunction)_wrap_g_irepository_get_infos, METH_VARARGS|METH_KEYWORDS },
-    { "find_by_name", (PyCFunction)_wrap_g_irepository_find_by_name, METH_VARARGS|METH_KEYWORDS },
-    { "get_typelib_path", (PyCFunction)_wrap_g_irepository_get_typelib_path, METH_VARARGS|METH_KEYWORDS },
+    { "get_default", (PyCFunction) _wrap_g_irepository_get_default, METH_STATIC | METH_NOARGS },
+    { "require", (PyCFunction) _wrap_g_irepository_require, METH_VARARGS | METH_KEYWORDS },
+    { "get_infos", (PyCFunction) _wrap_g_irepository_get_infos, METH_VARARGS | METH_KEYWORDS },
+    { "find_by_name", (PyCFunction) _wrap_g_irepository_find_by_name, METH_VARARGS | METH_KEYWORDS },
+    { "get_typelib_path", (PyCFunction) _wrap_g_irepository_get_typelib_path, METH_VARARGS | METH_KEYWORDS },
     { NULL, NULL, 0 }
 };
 
@@ -223,15 +223,15 @@ void
 _pygi_repository_register_types (PyObject *m)
 {
     PyGIRepository_Type.ob_type = &PyType_Type;
-    if (PyType_Ready(&PyGIRepository_Type)) {
+    if (PyType_Ready (&PyGIRepository_Type)) {
         return;
     }
-    if (PyModule_AddObject(m, "Repository", (PyObject *)&PyGIRepository_Type)) {
+    if (PyModule_AddObject (m, "Repository", (PyObject *) &PyGIRepository_Type)) {
         return;
     }
 
-    PyGIRepositoryError = PyErr_NewException("gi.RepositoryError", NULL, NULL);
-    if (PyModule_AddObject(m, "RepositoryError", PyGIRepositoryError)) {
+    PyGIRepositoryError = PyErr_NewException ("gi.RepositoryError", NULL, NULL);
+    if (PyModule_AddObject (m, "RepositoryError", PyGIRepositoryError)) {
         return;
     }
 }
diff --git a/gi/pygi-struct.c b/gi/pygi-struct.c
index f15a6cd..2f1ce42 100644
--- a/gi/pygi-struct.c
+++ b/gi/pygi-struct.c
@@ -29,15 +29,15 @@
 static void
 _struct_dealloc (PyGIStruct *self)
 {
-    PyObject_GC_UnTrack((PyObject *)self);
+    PyObject_GC_UnTrack ( (PyObject *) self);
 
-    PyObject_ClearWeakRefs((PyObject *)self);
+    PyObject_ClearWeakRefs ( (PyObject *) self);
 
     if (self->free_on_dealloc) {
-        g_free(((PyGPointer *)self)->pointer);
+        g_free ( ( (PyGPointer *) self)->pointer);
     }
 
-    ((PyGPointer *)self)->ob_type->tp_free((PyObject *)self);
+    ( (PyGPointer *) self)->ob_type->tp_free ( (PyObject *) self);
 }
 
 static PyObject *
@@ -53,34 +53,34 @@ _struct_new (PyTypeObject *type,
     gpointer pointer;
     PyObject *self = NULL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "", kwlist)) {
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs, "", kwlist)) {
         return NULL;
     }
 
-    info = _pygi_object_get_gi_info((PyObject *)type, &PyGIStructInfo_Type);
+    info = _pygi_object_get_gi_info ( (PyObject *) type, &PyGIStructInfo_Type);
     if (info == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-            PyErr_Format(PyExc_TypeError, "missing introspection information");
+        if (PyErr_ExceptionMatches (PyExc_AttributeError)) {
+            PyErr_Format (PyExc_TypeError, "missing introspection information");
         }
         return NULL;
     }
 
-    size = g_struct_info_get_size((GIStructInfo *)info);
-    pointer = g_try_malloc0(size);
+    size = g_struct_info_get_size ( (GIStructInfo *) info);
+    pointer = g_try_malloc0 (size);
     if (pointer == NULL) {
         PyErr_NoMemory();
         goto out;
     }
 
-    self = _pygi_struct_new(type, pointer, TRUE);
+    self = _pygi_struct_new (type, pointer, TRUE);
     if (self == NULL) {
-        g_free(pointer);
+        g_free (pointer);
     }
 
 out:
-    g_base_info_unref(info);
+    g_base_info_unref (info);
 
-    return (PyObject *)self;
+    return (PyObject *) self;
 }
 
 static int
@@ -94,38 +94,38 @@ _struct_init (PyObject *self,
 
 
 PyTypeObject PyGIStruct_Type = {
-    PyObject_HEAD_INIT(NULL)
+    PyObject_HEAD_INIT (NULL)
     0,
     "gi.Struct",                               /* tp_name */
-    sizeof(PyGIStruct),                        /* tp_basicsize */
+    sizeof (PyGIStruct),                       /* tp_basicsize */
     0,                                         /* tp_itemsize */
-    (destructor)_struct_dealloc,               /* tp_dealloc */
-    (printfunc)NULL,                           /* tp_print */
-    (getattrfunc)NULL,                         /* tp_getattr */
-    (setattrfunc)NULL,                         /* tp_setattr */
-    (cmpfunc)NULL,                             /* tp_compare */
-    (reprfunc)NULL,                            /* tp_repr */
+    (destructor) _struct_dealloc,              /* tp_dealloc */
+    (printfunc) NULL,                          /* tp_print */
+    (getattrfunc) NULL,                        /* tp_getattr */
+    (setattrfunc) NULL,                        /* tp_setattr */
+    (cmpfunc) NULL,                            /* tp_compare */
+    (reprfunc) NULL,                           /* tp_repr */
     NULL,                                      /* tp_as_number */
     NULL,                                      /* tp_as_sequence */
     NULL,                                      /* tp_as_mapping */
-    (hashfunc)NULL,                            /* tp_hash */
-    (ternaryfunc)NULL,                         /* tp_call */
-    (reprfunc)NULL,                            /* tp_str */
-    (getattrofunc)NULL,                        /* tp_getattro */
-    (setattrofunc)NULL,                        /* tp_setattro */
+    (hashfunc) NULL,                           /* tp_hash */
+    (ternaryfunc) NULL,                        /* tp_call */
+    (reprfunc) NULL,                           /* tp_str */
+    (getattrofunc) NULL,                       /* tp_getattro */
+    (setattrofunc) NULL,                       /* tp_setattro */
     NULL,                                      /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */
     NULL,                                     /* tp_doc */
-    (traverseproc)NULL,                       /* tp_traverse */
-    (inquiry)NULL,                            /* tp_clear */
-    (richcmpfunc)NULL,                        /* tp_richcompare */
+    (traverseproc) NULL,                      /* tp_traverse */
+    (inquiry) NULL,                           /* tp_clear */
+    (richcmpfunc) NULL,                       /* tp_richcompare */
     0,                                        /* tp_weaklistoffset */
-    (getiterfunc)NULL,                        /* tp_iter */
-    (iternextfunc)NULL,                       /* tp_iternext */
+    (getiterfunc) NULL,                       /* tp_iter */
+    (iternextfunc) NULL,                      /* tp_iternext */
     NULL,                                     /* tp_methods */
     NULL,                                     /* tp_members */
     NULL,                                     /* tp_getset */
-    (PyTypeObject *)NULL,                     /* tp_base */
+    (PyTypeObject *) NULL,                    /* tp_base */
 };
 
 PyObject *
@@ -136,23 +136,23 @@ _pygi_struct_new (PyTypeObject *type,
     PyGIStruct *self;
     GType g_type;
 
-    if (!PyType_IsSubtype(type, &PyGIStruct_Type)) {
-        PyErr_SetString(PyExc_TypeError, "must be a subtype of gi.Struct");
+    if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
+        PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
         return NULL;
     }
 
-    self = (PyGIStruct *)type->tp_alloc(type, 0);
+    self = (PyGIStruct *) type->tp_alloc (type, 0);
     if (self == NULL) {
         return NULL;
     }
 
-    g_type = pyg_type_from_object((PyObject *)type);
+    g_type = pyg_type_from_object ( (PyObject *) type);
 
-    ((PyGPointer *)self)->gtype = g_type;
-    ((PyGPointer *)self)->pointer = pointer;
+    ( (PyGPointer *) self)->gtype = g_type;
+    ( (PyGPointer *) self)->pointer = pointer;
     self->free_on_dealloc = free_on_dealloc;
 
-    return (PyObject *)self;
+    return (PyObject *) self;
 }
 
 void
@@ -160,10 +160,10 @@ _pygi_struct_register_types (PyObject *m)
 {
     PyGIStruct_Type.ob_type = &PyType_Type;
     PyGIStruct_Type.tp_base = &PyGPointer_Type;
-    PyGIStruct_Type.tp_new = (newfunc)_struct_new;
-    PyGIStruct_Type.tp_init = (initproc)_struct_init;
-    if (PyType_Ready(&PyGIStruct_Type))
+    PyGIStruct_Type.tp_new = (newfunc) _struct_new;
+    PyGIStruct_Type.tp_init = (initproc) _struct_init;
+    if (PyType_Ready (&PyGIStruct_Type))
         return;
-    if (PyModule_AddObject(m, "Struct", (PyObject *)&PyGIStruct_Type))
+    if (PyModule_AddObject (m, "Struct", (PyObject *) &PyGIStruct_Type))
         return;
 }
diff --git a/gi/pygi-type.c b/gi/pygi-type.c
index c95da86..410efe1 100644
--- a/gi/pygi-type.c
+++ b/gi/pygi-type.c
@@ -33,22 +33,22 @@ _pygi_type_import_by_gi_info (GIBaseInfo *info)
     PyObject *py_module;
     PyObject *py_object;
 
-    namespace_ = g_base_info_get_namespace(info);
-    name = g_base_info_get_name(info);
+    namespace_ = g_base_info_get_namespace (info);
+    name = g_base_info_get_name (info);
 
-    module_name = g_strconcat("gi.repository.", namespace_, NULL);
+    module_name = g_strconcat ("gi.repository.", namespace_, NULL);
 
-    py_module = PyImport_ImportModule(module_name);
+    py_module = PyImport_ImportModule (module_name);
+
+    g_free (module_name);
 
-    g_free(module_name);
-        
     if (py_module == NULL) {
         return NULL;
     }
 
-    py_object = PyObject_GetAttrString(py_module, name);
+    py_object = PyObject_GetAttrString (py_module, name);
 
-    Py_DECREF(py_module);
+    Py_DECREF (py_module);
 
     return py_object;
 }
@@ -62,34 +62,34 @@ pygi_type_import_by_g_type (GType g_type)
 
     repository = g_irepository_get_default();
 
-    info = g_irepository_find_by_gtype(repository, g_type);
+    info = g_irepository_find_by_gtype (repository, g_type);
     if (info == NULL) {
         return NULL;
     }
 
-    type = _pygi_type_import_by_gi_info(info);
-    g_base_info_unref(info);
+    type = _pygi_type_import_by_gi_info (info);
+    g_base_info_unref (info);
 
     return type;
 }
 
 PyObject *
-_pygi_type_get_from_g_type(GType g_type)
+_pygi_type_get_from_g_type (GType g_type)
 {
     PyObject *py_g_type;
     PyObject *py_type;
 
-    py_g_type = pyg_type_wrapper_new(g_type);
+    py_g_type = pyg_type_wrapper_new (g_type);
     if (py_g_type == NULL) {
         return NULL;
     }
 
-    py_type = PyObject_GetAttrString(py_g_type, "pytype");
+    py_type = PyObject_GetAttrString (py_g_type, "pytype");
     if (py_type == Py_None) {
-        py_type = pygi_type_import_by_g_type(g_type);
+        py_type = pygi_type_import_by_g_type (g_type);
     }
 
-    Py_DECREF(py_g_type);
+    Py_DECREF (py_g_type);
 
     return py_type;
 }
diff --git a/gi/pygi.h b/gi/pygi.h
index 5ee8d94..a9c4665 100644
--- a/gi/pygi.h
+++ b/gi/pygi.h
@@ -73,27 +73,27 @@ pygi_import (void)
         return 1;
     }
 
-    module = PyImport_ImportModule("gi");
+    module = PyImport_ImportModule ("gi");
     if (module == NULL) {
         return -1;
     }
 
-    api = PyObject_GetAttrString(module, "_API");
+    api = PyObject_GetAttrString (module, "_API");
     if (api == NULL) {
-        Py_DECREF(module);
+        Py_DECREF (module);
         return -1;
     }
-    if (!PyCObject_Check(api)) {
-        Py_DECREF(module);
-        Py_DECREF(api);
-        PyErr_Format(PyExc_TypeError, "gi._API must be cobject, not %s",
-                api->ob_type->tp_name);
+    if (!PyCObject_Check (api)) {
+        Py_DECREF (module);
+        Py_DECREF (api);
+        PyErr_Format (PyExc_TypeError, "gi._API must be cobject, not %s",
+                      api->ob_type->tp_name);
         return -1;
     }
 
-    PyGI_API = (struct PyGI_API *)PyCObject_AsVoidPtr(api);
+    PyGI_API = (struct PyGI_API *) PyCObject_AsVoidPtr (api);
 
-    Py_DECREF(api);
+    Py_DECREF (api);
 
     return 0;
 }
diff --git a/gi/pygobject-external.h b/gi/pygobject-external.h
index 9e9965b..00b8b6f 100644
--- a/gi/pygobject-external.h
+++ b/gi/pygobject-external.h
@@ -32,7 +32,7 @@ static PyTypeObject *_PyGTypeWrapper_Type;
 #define PyGObject_Type (*_PyGObject_Type)
 #define PyGTypeWrapper_Type (*_PyGTypeWrapper_Type)
 
-__attribute__((unused))
+__attribute__ ( (unused))
 static int
 _pygobject_import (void)
 {
@@ -45,26 +45,26 @@ _pygobject_import (void)
         return 1;
     }
 
-    from_list = Py_BuildValue("(ss)", "GObject", "GTypeWrapper");
+    from_list = Py_BuildValue ("(ss)", "GObject", "GTypeWrapper");
     if (from_list == NULL) {
         return -1;
     }
 
-    module = PyImport_ImportModuleEx("gobject", NULL, NULL, from_list);
+    module = PyImport_ImportModuleEx ("gobject", NULL, NULL, from_list);
 
-    Py_DECREF(from_list);
+    Py_DECREF (from_list);
 
     if (module == NULL) {
         return -1;
     }
 
-    _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+    _PyGObject_Type = (PyTypeObject *) PyObject_GetAttrString (module, "GObject");
     if (_PyGObject_Type == NULL) {
         retval = -1;
         goto out;
     }
 
-    _PyGTypeWrapper_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GType");
+    _PyGTypeWrapper_Type = (PyTypeObject *) PyObject_GetAttrString (module, "GType");
     if (_PyGTypeWrapper_Type == NULL) {
         retval = -1;
         goto out;
@@ -73,7 +73,7 @@ _pygobject_import (void)
     imported = TRUE;
 
 out:
-    Py_DECREF(module);
+    Py_DECREF (module);
 
     return retval;
 }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]