diff --git a/Modules/flmodule.c b/Modules/flmodule.c
index d2c2506..b5a78cf 100644
--- a/Modules/flmodule.c
+++ b/Modules/flmodule.c
@@ -22,11 +22,11 @@
 /* Generic Forms Objects */
 
 typedef struct {
-	PyObject_HEAD
-	FL_OBJECT *ob_generic;
-	PyMethodDef *ob_methods;
-	PyObject *ob_callback;
-	PyObject *ob_callback_arg;
+    PyObject_HEAD
+    FL_OBJECT *ob_generic;
+    PyMethodDef *ob_methods;
+    PyObject *ob_callback;
+    PyObject *ob_callback_arg;
 } genericobject;
 
 static PyTypeObject GenericObjecttype;
@@ -43,32 +43,32 @@
 static void
 knowgeneric(genericobject *g)
 {
-	int i, n;
-	/* Create the list if it doesn't already exist */
-	if (allgenerics == NULL) {
-		allgenerics = PyList_New(0);
-		if (allgenerics == NULL) {
-			PyErr_Clear();
-			return; /* Too bad, live without allgenerics... */
-		}
-	}
-	if (nfreeslots > 0) {
-		/* Search the list for reusable slots (NULL items) */
-		/* XXX This can be made faster! */
-		n = PyList_Size(allgenerics);
-		for (i = 0; i < n; i++) {
-			if (PyList_GetItem(allgenerics, i) == NULL) {
-				Py_INCREF(g);
-				PyList_SetItem(allgenerics, i, (PyObject *)g);
-				nfreeslots--;
-				return;
-			}
-		}
-		/* Strange... no free slots found... */
-		nfreeslots = 0;
-	}
-	/* No free entries, append new item to the end */
-	PyList_Append(allgenerics, (PyObject *)g);
+    int i, n;
+    /* Create the list if it doesn't already exist */
+    if (allgenerics == NULL) {
+        allgenerics = PyList_New(0);
+        if (allgenerics == NULL) {
+            PyErr_Clear();
+            return; /* Too bad, live without allgenerics... */
+        }
+    }
+    if (nfreeslots > 0) {
+        /* Search the list for reusable slots (NULL items) */
+        /* XXX This can be made faster! */
+        n = PyList_Size(allgenerics);
+        for (i = 0; i < n; i++) {
+            if (PyList_GetItem(allgenerics, i) == NULL) {
+                Py_INCREF(g);
+                PyList_SetItem(allgenerics, i, (PyObject *)g);
+                nfreeslots--;
+                return;
+            }
+        }
+        /* Strange... no free slots found... */
+        nfreeslots = 0;
+    }
+    /* No free entries, append new item to the end */
+    PyList_Append(allgenerics, (PyObject *)g);
 }
 
 /* Find an object in the list of known objects */
@@ -76,18 +76,18 @@
 static genericobject *
 findgeneric(FL_OBJECT *generic)
 {
-	int i, n;
-	genericobject *g;
-	
-	if (allgenerics == NULL)
-		return NULL; /* No objects known yet */
-	n = PyList_Size(allgenerics);
-	for (i = 0; i < n; i++) {
-		g = (genericobject *)PyList_GetItem(allgenerics, i);
-		if (g != NULL && g->ob_generic == generic)
-			return g;
-	}
-	return NULL; /* Unknown object */
+    int i, n;
+    genericobject *g;
+
+    if (allgenerics == NULL)
+        return NULL; /* No objects known yet */
+    n = PyList_Size(allgenerics);
+    for (i = 0; i < n; i++) {
+        g = (genericobject *)PyList_GetItem(allgenerics, i);
+        if (g != NULL && g->ob_generic == generic)
+            return g;
+    }
+    return NULL; /* Unknown object */
 }
 
 /* Remove an object from the list of known objects */
@@ -95,22 +95,22 @@
 static void
 forgetgeneric(genericobject *g)
 {
-	int i, n;
-	
-	Py_XDECREF(g->ob_callback);
-	g->ob_callback = NULL;
-	Py_XDECREF(g->ob_callback_arg);
-	g->ob_callback_arg = NULL;
-	if (allgenerics == NULL)
-		return; /* No objects known yet */
-	n = PyList_Size(allgenerics);
-	for (i = 0; i < n; i++) {
-		if (g == (genericobject *)PyList_GetItem(allgenerics, i)) {
-			PyList_SetItem(allgenerics, i, (PyObject *)NULL);
-			nfreeslots++;
-			break;
-		}
-	}
+    int i, n;
+
+    Py_XDECREF(g->ob_callback);
+    g->ob_callback = NULL;
+    Py_XDECREF(g->ob_callback_arg);
+    g->ob_callback_arg = NULL;
+    if (allgenerics == NULL)
+        return; /* No objects known yet */
+    n = PyList_Size(allgenerics);
+    for (i = 0; i < n; i++) {
+        if (g == (genericobject *)PyList_GetItem(allgenerics, i)) {
+            PyList_SetItem(allgenerics, i, (PyObject *)NULL);
+            nfreeslots++;
+            break;
+        }
+    }
 }
 
 /* Called when a form is about to be freed --
@@ -119,27 +119,27 @@
 static void
 releaseobjects(FL_FORM *form)
 {
-	int i, n;
-	genericobject *g;
-	
-	if (allgenerics == NULL)
-		return; /* No objects known yet */
-	n = PyList_Size(allgenerics);
-	for (i = 0; i < n; i++) {
-		g = (genericobject *)PyList_GetItem(allgenerics, i);
-		if (g != NULL && g->ob_generic->form == form) {
-			fl_delete_object(g->ob_generic);
-			/* The object is now unreachable for
-			   do_forms and check_forms, so
-			   delete it from the list of known objects */
-			Py_XDECREF(g->ob_callback);
-			g->ob_callback = NULL;
-			Py_XDECREF(g->ob_callback_arg);
-			g->ob_callback_arg = NULL;
-			PyList_SetItem(allgenerics, i, (PyObject *)NULL);
-			nfreeslots++;
-		}
-	}
+    int i, n;
+    genericobject *g;
+
+    if (allgenerics == NULL)
+        return; /* No objects known yet */
+    n = PyList_Size(allgenerics);
+    for (i = 0; i < n; i++) {
+        g = (genericobject *)PyList_GetItem(allgenerics, i);
+        if (g != NULL && g->ob_generic->form == form) {
+            fl_delete_object(g->ob_generic);
+            /* The object is now unreachable for
+               do_forms and check_forms, so
+               delete it from the list of known objects */
+            Py_XDECREF(g->ob_callback);
+            g->ob_callback = NULL;
+            Py_XDECREF(g->ob_callback_arg);
+            g->ob_callback_arg = NULL;
+            PyList_SetItem(allgenerics, i, (PyObject *)NULL);
+            nfreeslots++;
+        }
+    }
 }
 
 
@@ -148,79 +148,79 @@
 static PyObject *
 generic_set_call_back(genericobject *g, PyObject *args)
 {
-	if (PyTuple_GET_SIZE(args) == 0) {
-		Py_XDECREF(g->ob_callback);
-		Py_XDECREF(g->ob_callback_arg);
-		g->ob_callback = NULL;
-		g->ob_callback_arg = NULL;
-	}
-	else {
-        PyObject *a, *b;
-        if (!PyArg_UnpackTuple(args, "set_call_back", 2, 2, &a, &b))
-            return NULL;
-		Py_XDECREF(g->ob_callback);
-		Py_XDECREF(g->ob_callback_arg);
-		g->ob_callback = a;
-		Py_INCREF(g->ob_callback);
-		g->ob_callback_arg = b;
-		Py_INCREF(g->ob_callback_arg);
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (PyTuple_GET_SIZE(args) == 0) {
+        Py_XDECREF(g->ob_callback);
+        Py_XDECREF(g->ob_callback_arg);
+        g->ob_callback = NULL;
+        g->ob_callback_arg = NULL;
+    }
+    else {
+    PyObject *a, *b;
+    if (!PyArg_UnpackTuple(args, "set_call_back", 2, 2, &a, &b))
+        return NULL;
+        Py_XDECREF(g->ob_callback);
+        Py_XDECREF(g->ob_callback_arg);
+        g->ob_callback = a;
+        Py_INCREF(g->ob_callback);
+        g->ob_callback_arg = b;
+        Py_INCREF(g->ob_callback_arg);
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 generic_call(genericobject *g, void (*func)(FL_OBJECT *))
 {
-	(*func)(g->ob_generic);
-	Py_INCREF(Py_None);
-	return Py_None;
+    (*func)(g->ob_generic);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 generic_delete_object(genericobject *g)
 {
-	PyObject *res;
-	res = generic_call(g, fl_delete_object);
-	if (res != NULL)
-		forgetgeneric(g);
-	return res;
+    PyObject *res;
+    res = generic_call(g, fl_delete_object);
+    if (res != NULL)
+        forgetgeneric(g);
+    return res;
 }
 
 static PyObject *
 generic_show_object(genericobject *g)
 {
-	return generic_call(g, fl_show_object);
+    return generic_call(g, fl_show_object);
 }
 
 static PyObject *
 generic_hide_object(genericobject *g)
 {
-	return generic_call(g, fl_hide_object);
+    return generic_call(g, fl_hide_object);
 }
 
 static PyObject *
 generic_redraw_object(genericobject *g)
 {
-	return generic_call(g, fl_redraw_object);
+    return generic_call(g, fl_redraw_object);
 }
 
 #ifdef OBSOLETE_FORMS_CALLS
- 
+
  /* (un)freeze_object() are obsolete in FORMS 2.2 and unsupported
     in 2.3.  Since there's no foolproof way to tell which version we're
     using, we omit them unconditionally. */
- 
+
 static PyObject *
 generic_freeze_object(genericobject *g)
 {
-	return generic_call(g, fl_freeze_object);
+    return generic_call(g, fl_freeze_object);
 }
 
 static PyObject *
 generic_unfreeze_object(genericobject *g)
 {
-	return generic_call(g, fl_unfreeze_object);
+    return generic_call(g, fl_unfreeze_object);
 }
 
 #endif /* OBSOLETE_FORMS_CALLS */
@@ -228,78 +228,78 @@
 static PyObject *
 generic_activate_object(genericobject *g)
 {
-	return generic_call(g, fl_activate_object);
+    return generic_call(g, fl_activate_object);
 }
 
 static PyObject *
 generic_deactivate_object(genericobject *g)
 {
-	return generic_call(g, fl_deactivate_object);
+    return generic_call(g, fl_deactivate_object);
 }
 
 static PyObject *
 generic_set_object_shortcut(genericobject *g, PyObject *args)
 {
-	char *str;
-	if (!PyArg_ParseTuple(args, "s:set_object_shortcut", &str))
-		return NULL;
-	fl_set_object_shortcut(g->ob_generic, str);
-	Py_INCREF(Py_None);
-	return Py_None;
+    char *str;
+    if (!PyArg_ParseTuple(args, "s:set_object_shortcut", &str))
+        return NULL;
+    fl_set_object_shortcut(g->ob_generic, str);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyMethodDef generic_methods[] = {
-	{"set_call_back",	(PyCFunction)generic_set_call_back, METH_VARARGS},
-	{"delete_object",	(PyCFunction)generic_delete_object, METH_NOARGS},
-	{"show_object",		(PyCFunction)generic_show_object, METH_NOARGS},
-	{"hide_object",		(PyCFunction)generic_hide_object, METH_NOARGS},
-	{"redraw_object",	(PyCFunction)generic_redraw_object, METH_NOARGS},
+    {"set_call_back",           (PyCFunction)generic_set_call_back, METH_VARARGS},
+    {"delete_object",           (PyCFunction)generic_delete_object, METH_NOARGS},
+    {"show_object",             (PyCFunction)generic_show_object, METH_NOARGS},
+    {"hide_object",             (PyCFunction)generic_hide_object, METH_NOARGS},
+    {"redraw_object",           (PyCFunction)generic_redraw_object, METH_NOARGS},
 #ifdef OBSOLETE_FORMS_CALLS
-	{"freeze_object",	(PyCFunction)generic_freeze_object, METH_NOARGS},
-	{"unfreeze_object",	(PyCFunction)generic_unfreeze_object, METH_NOARGS},
+    {"freeze_object",           (PyCFunction)generic_freeze_object, METH_NOARGS},
+    {"unfreeze_object",         (PyCFunction)generic_unfreeze_object, METH_NOARGS},
 #endif
-	{"activate_object",	(PyCFunction)generic_activate_object, METH_NOARGS},
-	{"deactivate_object",	(PyCFunction)generic_deactivate_object, METH_NOARGS},
-	{"set_object_shortcut",	(PyCFunction)generic_set_object_shortcut, METH_VARARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"activate_object",         (PyCFunction)generic_activate_object, METH_NOARGS},
+    {"deactivate_object",       (PyCFunction)generic_deactivate_object, METH_NOARGS},
+    {"set_object_shortcut",     (PyCFunction)generic_set_object_shortcut, METH_VARARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 static void
 generic_dealloc(genericobject *g)
 {
-	fl_free_object(g->ob_generic);
-	Py_XDECREF(g->ob_callback);
-	Py_XDECREF(g->ob_callback_arg);
-	PyObject_Del(g);
+    fl_free_object(g->ob_generic);
+    Py_XDECREF(g->ob_callback);
+    Py_XDECREF(g->ob_callback_arg);
+    PyObject_Del(g);
 }
 
 #define OFF(x) offsetof(FL_OBJECT, x)
 
 static struct memberlist generic_memberlist[] = {
-	{"objclass",	T_INT,		OFF(objclass),	RO},
-	{"type",	T_INT,		OFF(type),	RO},
-	{"boxtype",	T_INT,		OFF(boxtype)},
-	{"x",		T_FLOAT,	OFF(x)},
-	{"y",		T_FLOAT,	OFF(y)},
-	{"w",		T_FLOAT,	OFF(w)},
-	{"h",		T_FLOAT,	OFF(h)},
-	{"col1",	T_INT,		OFF(col1)},
-	{"col2",	T_INT,		OFF(col2)},
-	{"align",	T_INT,		OFF(align)},
-	{"lcol",	T_INT,		OFF(lcol)},
-	{"lsize",	T_FLOAT,	OFF(lsize)},
-	/* "label" is treated specially! */
-	{"lstyle",	T_INT,		OFF(lstyle)},
-	{"pushed",	T_INT,		OFF(pushed),	RO},
-	{"focus",	T_INT,		OFF(focus),	RO},
-	{"belowmouse",	T_INT,		OFF(belowmouse),RO},
-/*	{"frozen",	T_INT,		OFF(frozen),	RO},	*/
-	{"active",	T_INT,		OFF(active)},
-	{"input",	T_INT,		OFF(input)},
-	{"visible",	T_INT,		OFF(visible),	RO},
-	{"radio",	T_INT,		OFF(radio)},
-	{"automatic",	T_INT,		OFF(automatic)},
-	{NULL}	/* Sentinel */
+    {"objclass",        T_INT,          OFF(objclass),  RO},
+    {"type",            T_INT,          OFF(type),      RO},
+    {"boxtype",         T_INT,          OFF(boxtype)},
+    {"x",               T_FLOAT,        OFF(x)},
+    {"y",               T_FLOAT,        OFF(y)},
+    {"w",               T_FLOAT,        OFF(w)},
+    {"h",               T_FLOAT,        OFF(h)},
+    {"col1",            T_INT,          OFF(col1)},
+    {"col2",            T_INT,          OFF(col2)},
+    {"align",           T_INT,          OFF(align)},
+    {"lcol",            T_INT,          OFF(lcol)},
+    {"lsize",           T_FLOAT,        OFF(lsize)},
+    /* "label" is treated specially! */
+    {"lstyle",          T_INT,          OFF(lstyle)},
+    {"pushed",          T_INT,          OFF(pushed),    RO},
+    {"focus",           T_INT,          OFF(focus),     RO},
+    {"belowmouse",      T_INT,          OFF(belowmouse),RO},
+/*      {"frozen",      T_INT,          OFF(frozen),    RO},    */
+    {"active",          T_INT,          OFF(active)},
+    {"input",           T_INT,          OFF(input)},
+    {"visible",         T_INT,          OFF(visible),   RO},
+    {"radio",           T_INT,          OFF(radio)},
+    {"automatic",       T_INT,          OFF(automatic)},
+    {NULL}      /* Sentinel */
 };
 
 #undef OFF
@@ -307,99 +307,99 @@
 static PyObject *
 generic_getattr(genericobject *g, char *name)
 {
-	PyObject *meth;
+    PyObject *meth;
 
-	/* XXX Ought to special-case name "__methods__" */
-	if (g-> ob_methods) {
-		meth = Py_FindMethod(g->ob_methods, (PyObject *)g, name);
-		if (meth != NULL) return meth;
-		PyErr_Clear();
-	}
+    /* XXX Ought to special-case name "__methods__" */
+    if (g-> ob_methods) {
+        meth = Py_FindMethod(g->ob_methods, (PyObject *)g, name);
+        if (meth != NULL) return meth;
+        PyErr_Clear();
+    }
 
-	meth = Py_FindMethod(generic_methods, (PyObject *)g, name);
-	if (meth != NULL)
-		return meth;
-	PyErr_Clear();
+    meth = Py_FindMethod(generic_methods, (PyObject *)g, name);
+    if (meth != NULL)
+        return meth;
+    PyErr_Clear();
 
-	/* "label" is an exception, getmember only works for char pointers,
-	   not for char arrays */
-	if (strcmp(name, "label") == 0)
-		return PyString_FromString(g->ob_generic->label);
+    /* "label" is an exception, getmember only works for char pointers,
+       not for char arrays */
+    if (strcmp(name, "label") == 0)
+        return PyString_FromString(g->ob_generic->label);
 
-	return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
+    return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
 }
 
 static int
 generic_setattr(genericobject *g, char *name, PyObject *v)
 {
-	int ret;
+    int ret;
 
-	if (v == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-				"can't delete forms object attributes");
-		return -1;
-	}
+    if (v == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "can't delete forms object attributes");
+        return -1;
+    }
 
-	/* "label" is an exception: setmember doesn't set strings;
-	   and FORMS wants you to call a function to set the label */
-	if (strcmp(name, "label") == 0) {
-		if (!PyString_Check(v)) {
-			PyErr_SetString(PyExc_TypeError,
-					"label attr must be string");
-			return -1;
-		}
-		fl_set_object_label(g->ob_generic, PyString_AsString(v));
-		return 0;
-	}
+    /* "label" is an exception: setmember doesn't set strings;
+       and FORMS wants you to call a function to set the label */
+    if (strcmp(name, "label") == 0) {
+        if (!PyString_Check(v)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "label attr must be string");
+            return -1;
+        }
+        fl_set_object_label(g->ob_generic, PyString_AsString(v));
+        return 0;
+    }
 
-	ret = PyMember_Set((char *)g->ob_generic, generic_memberlist, name, v);
+    ret = PyMember_Set((char *)g->ob_generic, generic_memberlist, name, v);
 
-	/* Rather than calling all the various set_object_* functions,
-	   we call fl_redraw_object here.  This is sometimes redundant
-	   but I doubt that's a big problem */
-	if (ret == 0)
-		fl_redraw_object(g->ob_generic);
+    /* Rather than calling all the various set_object_* functions,
+       we call fl_redraw_object here.  This is sometimes redundant
+       but I doubt that's a big problem */
+    if (ret == 0)
+        fl_redraw_object(g->ob_generic);
 
-	return ret;
+    return ret;
 }
 
 static PyObject *
 generic_repr(genericobject *g)
 {
-	char buf[100];
-	PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",
-		      g, g->ob_generic->objclass);
-	return PyString_FromString(buf);
+    char buf[100];
+    PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",
+                  g, g->ob_generic->objclass);
+    return PyString_FromString(buf);
 }
 
 static PyTypeObject GenericObjecttype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/*ob_size*/
-	"fl.FORMS_object",		/*tp_name*/
-	sizeof(genericobject),		/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)generic_dealloc,	/*tp_dealloc*/
-	0,				/*tp_print*/
-	(getattrfunc)generic_getattr,	/*tp_getattr*/
-	(setattrfunc)generic_setattr,	/*tp_setattr*/
-	0,				/*tp_compare*/
-	(reprfunc)generic_repr,		/*tp_repr*/
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,                                  /*ob_size*/
+    "fl.FORMS_object",                  /*tp_name*/
+    sizeof(genericobject),              /*tp_size*/
+    0,                                  /*tp_itemsize*/
+    /* methods */
+    (destructor)generic_dealloc,        /*tp_dealloc*/
+    0,                                  /*tp_print*/
+    (getattrfunc)generic_getattr,       /*tp_getattr*/
+    (setattrfunc)generic_setattr,       /*tp_setattr*/
+    0,                                  /*tp_compare*/
+    (reprfunc)generic_repr,             /*tp_repr*/
 };
 
 static PyObject *
 newgenericobject(FL_OBJECT *generic, PyMethodDef *methods)
 {
-	genericobject *g;
-	g = PyObject_New(genericobject, &GenericObjecttype);
-	if (g == NULL)
-		return NULL;
-	g-> ob_generic = generic;
-	g->ob_methods = methods;
-	g->ob_callback = NULL;
-	g->ob_callback_arg = NULL;
-	knowgeneric(g);
-	return (PyObject *)g;
+    genericobject *g;
+    g = PyObject_New(genericobject, &GenericObjecttype);
+    if (g == NULL)
+        return NULL;
+    g-> ob_generic = generic;
+    g->ob_methods = methods;
+    g->ob_callback = NULL;
+    g->ob_callback_arg = NULL;
+    knowgeneric(g);
+    return (PyObject *)g;
 }
 
 /**********************************************************************/
@@ -409,70 +409,70 @@
 static PyObject *
 call_forms_INf (void (*func)(FL_OBJECT *, float), FL_OBJECT *obj, PyObject *args)
 {
-	float parameter;
+    float parameter;
 
-	if (!PyArg_Parse(args, "f", &parameter)) return NULL;
+    if (!PyArg_Parse(args, "f", &parameter)) return NULL;
 
-	(*func) (obj, parameter);
+    (*func) (obj, parameter);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /* void func (object, float) */
 static PyObject *
 call_forms_INfINf (void (*func)(FL_OBJECT *, float, float), FL_OBJECT *obj, PyObject *args)
 {
-	float par1, par2;
+    float par1, par2;
 
-	if (!PyArg_Parse(args, "(ff)", &par1, &par2)) return NULL;
+    if (!PyArg_Parse(args, "(ff)", &par1, &par2)) return NULL;
 
-	(*func) (obj, par1, par2);
+    (*func) (obj, par1, par2);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /* void func (object, int) */
 static PyObject *
 call_forms_INi (void (*func)(FL_OBJECT *, int), FL_OBJECT *obj, PyObject *args)
 {
-	int parameter;
+    int parameter;
 
-	if (!PyArg_Parse(args, "i", &parameter)) return NULL;
+    if (!PyArg_Parse(args, "i", &parameter)) return NULL;
 
-	(*func) (obj, parameter);
+    (*func) (obj, parameter);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /* void func (object, char) */
 static PyObject *
 call_forms_INc (void (*func)(FL_OBJECT *, int), FL_OBJECT *obj, PyObject *args)
 {
-	char *a;
+    char *a;
 
-	if (!PyArg_Parse(args, "s", &a)) return NULL;
+    if (!PyArg_Parse(args, "s", &a)) return NULL;
 
-	(*func) (obj, a[0]);
+    (*func) (obj, a[0]);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 /* void func (object, string) */
 static PyObject *
 call_forms_INstr (void (*func)(FL_OBJECT *, char *), FL_OBJECT *obj, PyObject *args)
 {
-	char *a;
+    char *a;
 
-	if (!PyArg_Parse(args, "s", &a)) return NULL;
+    if (!PyArg_Parse(args, "s", &a)) return NULL;
 
-	(*func) (obj, a);
+    (*func) (obj, a);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -480,15 +480,15 @@
 static PyObject *
 call_forms_INiINstr (void (*func)(FL_OBJECT *, int, char *), FL_OBJECT *obj, PyObject *args)
 {
-	char *b;
-	int a;
-	
-	if (!PyArg_Parse(args, "(is)", &a, &b)) return NULL;
-	
-	(*func) (obj, a, b);
-	
-	Py_INCREF(Py_None);
-	return Py_None;
+    char *b;
+    int a;
+
+    if (!PyArg_Parse(args, "(is)", &a, &b)) return NULL;
+
+    (*func) (obj, a, b);
+
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 #ifdef UNUSED
@@ -496,14 +496,14 @@
 static PyObject *
 call_forms_INiINi (void (*func)(FL_OBJECT *, int, int), FL_OBJECT *obj, PyObject *args)
 {
-	int par1, par2;
-	
-	if (!PyArg_Parse(args, "(ii)", &par1, &par2)) return NULL;
-	
-	(*func) (obj, par1, par2);
-	
-	Py_INCREF(Py_None);
-	return Py_None;
+    int par1, par2;
+
+    if (!PyArg_Parse(args, "(ii)", &par1, &par2)) return NULL;
+
+    (*func) (obj, par1, par2);
+
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif
 
@@ -511,58 +511,58 @@
 static PyObject *
 call_forms_Ri (int (*func)(FL_OBJECT *), FL_OBJECT *obj)
 {
-	int retval;
+    int retval;
 
-	retval = (*func) (obj);
+    retval = (*func) (obj);
 
-	return PyInt_FromLong ((long) retval);
+    return PyInt_FromLong ((long) retval);
 }
 
 /* char * func (object) */
 static PyObject *
 call_forms_Rstr (char * (*func)(FL_OBJECT *), FL_OBJECT *obj)
 {
-	char *str;
+    char *str;
 
-	str = (*func) (obj);
+    str = (*func) (obj);
 
-	if (str == NULL) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromString (str);
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromString (str);
 }
 
 /* int func (object) */
 static PyObject *
 call_forms_Rf (float (*func)(FL_OBJECT *), FL_OBJECT *obj)
 {
-	float retval;
+    float retval;
 
-	retval = (*func) (obj);
+    retval = (*func) (obj);
 
-	return PyFloat_FromDouble (retval);
+    return PyFloat_FromDouble (retval);
 }
 
 static PyObject *
 call_forms_OUTfOUTf (void (*func)(FL_OBJECT *, float *, float *), FL_OBJECT *obj)
 {
-	float f1, f2;
+    float f1, f2;
 
-	(*func) (obj, &f1, &f2);
+    (*func) (obj, &f1, &f2);
 
-	return Py_BuildValue("(ff)", f1, f2);
+    return Py_BuildValue("(ff)", f1, f2);
 }
 
 #ifdef UNUSED
 static PyObject *
 call_forms_OUTf (void (*func)(FL_OBJECT *, float *), FL_OBJECT *obj)
 {
-	float f;
+    float f;
 
-	(*func) (obj, &f);
+    (*func) (obj, &f);
 
-	return PyFloat_FromDouble (f);
+    return PyFloat_FromDouble (f);
 }
 #endif
 
@@ -572,172 +572,172 @@
 static PyObject *
 set_browser_topline(genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);
+    return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);
 }
 
 static PyObject *
 clear_browser(genericobject *g)
 {
-	return generic_call (g, fl_clear_browser);
+    return generic_call (g, fl_clear_browser);
 }
 
 static PyObject *
 add_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);
+    return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);
 }
 
 static PyObject *
 addto_browser (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);
+    return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);
 }
 
 static PyObject *
 insert_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INiINstr (fl_insert_browser_line,
-				    g-> ob_generic, args);
+    return call_forms_INiINstr (fl_insert_browser_line,
+                                g-> ob_generic, args);
 }
 
 static PyObject *
 delete_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);
+    return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);
 }
 
 static PyObject *
 replace_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INiINstr (fl_replace_browser_line,
-				    g-> ob_generic, args);
+    return call_forms_INiINstr (fl_replace_browser_line,
+                                g-> ob_generic, args);
 }
 
 static PyObject *
 get_browser_line(genericobject *g, PyObject *args)
 {
-	int i;
-	char *str;
+    int i;
+    char *str;
 
-	if (!PyArg_Parse(args, "i", &i))
-		return NULL;
+    if (!PyArg_Parse(args, "i", &i))
+        return NULL;
 
-	str = fl_get_browser_line (g->ob_generic, i);
+    str = fl_get_browser_line (g->ob_generic, i);
 
-	if (str == NULL) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromString (str);
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromString (str);
 }
 
 static PyObject *
 load_browser (genericobject *g, PyObject *args)
 {
-	/* XXX strictly speaking this is wrong since fl_load_browser
-	   XXX returns int, not void */
-	return call_forms_INstr (fl_load_browser, g-> ob_generic, args);
+    /* XXX strictly speaking this is wrong since fl_load_browser
+       XXX returns int, not void */
+    return call_forms_INstr (fl_load_browser, g-> ob_generic, args);
 }
 
 static PyObject *
 get_browser_maxline(genericobject *g)
 {
-	return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic);
+    return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic);
 }
 
 static PyObject *
 select_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);
+    return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);
 }
 
 static PyObject *
 deselect_browser_line (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);
+    return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);
 }
 
 static PyObject *
 deselect_browser (genericobject *g)
 {
-	return generic_call (g, fl_deselect_browser);
+    return generic_call (g, fl_deselect_browser);
 }
 
 static PyObject *
 isselected_browser_line (genericobject *g, PyObject *args)
 {
-	int i, j;
-	
-	if (!PyArg_Parse(args, "i", &i))
-		return NULL;
-	
-	j = fl_isselected_browser_line (g->ob_generic, i);
-	
-	return PyInt_FromLong (j);
+    int i, j;
+
+    if (!PyArg_Parse(args, "i", &i))
+        return NULL;
+
+    j = fl_isselected_browser_line (g->ob_generic, i);
+
+    return PyInt_FromLong (j);
 }
 
 static PyObject *
 get_browser (genericobject *g)
 {
-	return call_forms_Ri (fl_get_browser, g-> ob_generic);
+    return call_forms_Ri (fl_get_browser, g-> ob_generic);
 }
 
 static PyObject *
 set_browser_fontsize (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);
+    return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);
 }
 
 static PyObject *
 set_browser_fontstyle (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);
+    return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);
 }
 
 static PyObject *
 set_browser_specialkey (genericobject *g, PyObject *args)
 {
-	return call_forms_INc(fl_set_browser_specialkey, g-> ob_generic, args);
+    return call_forms_INc(fl_set_browser_specialkey, g-> ob_generic, args);
 }
 
 static PyMethodDef browser_methods[] = {
-	{"set_browser_topline",		(PyCFunction)set_browser_topline,
-	 METH_OLDARGS},
-	{"clear_browser",		(PyCFunction)clear_browser,
-	 METH_NOARGS},
-	{"add_browser_line",		(PyCFunction)add_browser_line,
-	 METH_OLDARGS},
-	{"addto_browser",		(PyCFunction)addto_browser,
-	 METH_OLDARGS},
-	{"insert_browser_line",		(PyCFunction)insert_browser_line,
-	 METH_OLDARGS},
-	{"delete_browser_line",		(PyCFunction)delete_browser_line,
-	 METH_OLDARGS},
-	{"replace_browser_line",	(PyCFunction)replace_browser_line,
-	 METH_OLDARGS},
-	{"get_browser_line",		(PyCFunction)get_browser_line,
-	 METH_OLDARGS},
-	{"load_browser",		(PyCFunction)load_browser,
-	 METH_OLDARGS},
-	{"get_browser_maxline",		(PyCFunction)get_browser_maxline,
-	 METH_NOARGS,}
-	{"select_browser_line",		(PyCFunction)select_browser_line,
-	 METH_OLDARGS},
-	{"deselect_browser_line",	(PyCFunction)deselect_browser_line,
-	 METH_OLDARGS},
-	{"deselect_browser",		(PyCFunction)deselect_browser,
-	 METH_NOARGS,}
-	{"isselected_browser_line",	(PyCFunction)isselected_browser_line,
-	 METH_OLDARGS},
-	{"get_browser",			(PyCFunction)get_browser,
-	 METH_NOARGS,}
-	{"set_browser_fontsize",	(PyCFunction)set_browser_fontsize,
-	 METH_OLDARGS},
-	{"set_browser_fontstyle",	(PyCFunction)set_browser_fontstyle,
-	 METH_OLDARGS},
-	{"set_browser_specialkey",	(PyCFunction)set_browser_specialkey,
-	 METH_OLDARGS},
-	{NULL,				NULL}		/* sentinel */
+    {"set_browser_topline",             (PyCFunction)set_browser_topline,
+     METH_OLDARGS},
+    {"clear_browser",                   (PyCFunction)clear_browser,
+     METH_NOARGS},
+    {"add_browser_line",                (PyCFunction)add_browser_line,
+     METH_OLDARGS},
+    {"addto_browser",                   (PyCFunction)addto_browser,
+     METH_OLDARGS},
+    {"insert_browser_line",             (PyCFunction)insert_browser_line,
+     METH_OLDARGS},
+    {"delete_browser_line",             (PyCFunction)delete_browser_line,
+     METH_OLDARGS},
+    {"replace_browser_line",            (PyCFunction)replace_browser_line,
+     METH_OLDARGS},
+    {"get_browser_line",                (PyCFunction)get_browser_line,
+     METH_OLDARGS},
+    {"load_browser",                    (PyCFunction)load_browser,
+     METH_OLDARGS},
+    {"get_browser_maxline",             (PyCFunction)get_browser_maxline,
+     METH_NOARGS,}
+    {"select_browser_line",             (PyCFunction)select_browser_line,
+     METH_OLDARGS},
+    {"deselect_browser_line",           (PyCFunction)deselect_browser_line,
+     METH_OLDARGS},
+    {"deselect_browser",                (PyCFunction)deselect_browser,
+     METH_NOARGS,}
+    {"isselected_browser_line",         (PyCFunction)isselected_browser_line,
+     METH_OLDARGS},
+    {"get_browser",                     (PyCFunction)get_browser,
+     METH_NOARGS,}
+    {"set_browser_fontsize",            (PyCFunction)set_browser_fontsize,
+     METH_OLDARGS},
+    {"set_browser_fontstyle",           (PyCFunction)set_browser_fontstyle,
+     METH_OLDARGS},
+    {"set_browser_specialkey",          (PyCFunction)set_browser_specialkey,
+     METH_OLDARGS},
+    {NULL,                              NULL}           /* sentinel */
 };
 
 /* Class: button */
@@ -745,33 +745,33 @@
 static PyObject *
 set_button(genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_button, g-> ob_generic, args);
+    return call_forms_INi (fl_set_button, g-> ob_generic, args);
 }
 
 static PyObject *
 get_button(genericobject *g)
 {
-	return call_forms_Ri (fl_get_button, g-> ob_generic);
+    return call_forms_Ri (fl_get_button, g-> ob_generic);
 }
 
 static PyObject *
 get_button_numb(genericobject *g)
 {
-	return call_forms_Ri (fl_get_button_numb, g-> ob_generic);
+    return call_forms_Ri (fl_get_button_numb, g-> ob_generic);
 }
 
 static PyObject *
 set_button_shortcut(genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_set_button_shortcut, g-> ob_generic, args);
+    return call_forms_INstr (fl_set_button_shortcut, g-> ob_generic, args);
 }
 
 static PyMethodDef button_methods[] = {
-	{"set_button",		(PyCFunction)set_button, METH_OLDARGS},
-	{"get_button",		(PyCFunction)get_button, METH_NOARGS},
-	{"get_button_numb",	(PyCFunction)get_button_numb, METH_NOARGS},
-	{"set_button_shortcut",	(PyCFunction)set_button_shortcut, METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_button",              (PyCFunction)set_button, METH_OLDARGS},
+    {"get_button",              (PyCFunction)get_button, METH_NOARGS},
+    {"get_button_numb",         (PyCFunction)get_button_numb, METH_NOARGS},
+    {"set_button_shortcut",     (PyCFunction)set_button_shortcut, METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* Class: choice */
@@ -779,68 +779,68 @@
 static PyObject *
 set_choice(genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_choice, g-> ob_generic, args);
+    return call_forms_INi (fl_set_choice, g-> ob_generic, args);
 }
 
 static PyObject *
 get_choice(genericobject *g)
 {
-	return call_forms_Ri (fl_get_choice, g-> ob_generic);
+    return call_forms_Ri (fl_get_choice, g-> ob_generic);
 }
 
 static PyObject *
 clear_choice (genericobject *g)
 {
-	return generic_call (g, fl_clear_choice);
+    return generic_call (g, fl_clear_choice);
 }
 
 static PyObject *
 addto_choice (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);
+    return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);
 }
 
 static PyObject *
 replace_choice (genericobject *g, PyObject *args)
 {
-	return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);
+    return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);
 }
 
 static PyObject *
 delete_choice (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_delete_choice, g-> ob_generic, args);
+    return call_forms_INi (fl_delete_choice, g-> ob_generic, args);
 }
 
 static PyObject *
 get_choice_text (genericobject *g)
 {
-	return call_forms_Rstr (fl_get_choice_text, g-> ob_generic);
+    return call_forms_Rstr (fl_get_choice_text, g-> ob_generic);
 }
 
 static PyObject *
 set_choice_fontsize (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);
+    return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);
 }
 
 static PyObject *
 set_choice_fontstyle (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);
+    return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);
 }
 
 static PyMethodDef choice_methods[] = {
-	{"set_choice",		(PyCFunction)set_choice,      METH_OLDARGS},
-	{"get_choice",		(PyCFunction)get_choice,      METH_NOARGS},
-	{"clear_choice",	(PyCFunction)clear_choice,    METH_NOARGS},
-	{"addto_choice",	(PyCFunction)addto_choice,    METH_OLDARGS},
-	{"replace_choice",	(PyCFunction)replace_choice,  METH_OLDARGS},
-	{"delete_choice",	(PyCFunction)delete_choice,   METH_OLDARGS},
-	{"get_choice_text",	(PyCFunction)get_choice_text, METH_NOARGS},
-	{"set_choice_fontsize", (PyCFunction)set_choice_fontsize, METH_OLDARGS},
-	{"set_choice_fontstyle",(PyCFunction)set_choice_fontstyle, METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_choice",              (PyCFunction)set_choice,      METH_OLDARGS},
+    {"get_choice",              (PyCFunction)get_choice,      METH_NOARGS},
+    {"clear_choice",            (PyCFunction)clear_choice,    METH_NOARGS},
+    {"addto_choice",            (PyCFunction)addto_choice,    METH_OLDARGS},
+    {"replace_choice",          (PyCFunction)replace_choice,  METH_OLDARGS},
+    {"delete_choice",           (PyCFunction)delete_choice,   METH_OLDARGS},
+    {"get_choice_text",         (PyCFunction)get_choice_text, METH_NOARGS},
+    {"set_choice_fontsize", (PyCFunction)set_choice_fontsize, METH_OLDARGS},
+    {"set_choice_fontstyle",(PyCFunction)set_choice_fontstyle, METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* Class : Clock */
@@ -848,16 +848,16 @@
 static PyObject *
 get_clock(genericobject *g)
 {
-	int i0, i1, i2;
+    int i0, i1, i2;
 
-	fl_get_clock (g->ob_generic, &i0, &i1, &i2);
+    fl_get_clock (g->ob_generic, &i0, &i1, &i2);
 
-	return Py_BuildValue("(iii)", i0, i1, i2);
+    return Py_BuildValue("(iii)", i0, i1, i2);
 }
 
 static PyMethodDef clock_methods[] = {
-	{"get_clock",		(PyCFunction)get_clock, METH_NOARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"get_clock",               (PyCFunction)get_clock, METH_NOARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* CLass : Counters */
@@ -865,53 +865,53 @@
 static PyObject *
 get_counter_value(genericobject *g)
 {
-	return call_forms_Rf (fl_get_counter_value, g-> ob_generic);
+    return call_forms_Rf (fl_get_counter_value, g-> ob_generic);
 }
 
 static PyObject *
 set_counter_value (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);
+    return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);
 }
 
 static PyObject *
 set_counter_precision (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);
+    return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);
 }
 
 static PyObject *
 set_counter_bounds (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);
 }
 
 static PyObject *
 set_counter_step (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);
 }
 
 static PyObject *
 set_counter_return (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);
+    return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);
 }
 
 static PyMethodDef counter_methods[] = {
-	{"set_counter_value",		(PyCFunction)set_counter_value,
-	 METH_OLDARGS},
-	{"get_counter_value",		(PyCFunction)get_counter_value,
-	 METH_NOARGS},
-	{"set_counter_bounds",		(PyCFunction)set_counter_bounds,
-	 METH_OLDARGS},
-	{"set_counter_step",		(PyCFunction)set_counter_step,
-	 METH_OLDARGS},
-	{"set_counter_precision",	(PyCFunction)set_counter_precision,
-	 METH_OLDARGS},
-	{"set_counter_return",		(PyCFunction)set_counter_return,
-	 METH_OLDARGS},
-	{NULL,				NULL}		/* sentinel */
+    {"set_counter_value",               (PyCFunction)set_counter_value,
+     METH_OLDARGS},
+    {"get_counter_value",               (PyCFunction)get_counter_value,
+     METH_NOARGS},
+    {"set_counter_bounds",              (PyCFunction)set_counter_bounds,
+     METH_OLDARGS},
+    {"set_counter_step",                (PyCFunction)set_counter_step,
+     METH_OLDARGS},
+    {"set_counter_precision",           (PyCFunction)set_counter_precision,
+     METH_OLDARGS},
+    {"set_counter_return",              (PyCFunction)set_counter_return,
+     METH_OLDARGS},
+    {NULL,                              NULL}           /* sentinel */
 };
 
 
@@ -920,40 +920,40 @@
 static PyObject *
 get_dial_value(genericobject *g)
 {
-	return call_forms_Rf (fl_get_dial_value, g-> ob_generic);
+    return call_forms_Rf (fl_get_dial_value, g-> ob_generic);
 }
 
 static PyObject *
 set_dial_value (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);
+    return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);
 }
 
 static PyObject *
 set_dial_bounds (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);
 }
 
 static PyObject *
 get_dial_bounds (genericobject *g)
 {
-	return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic);
+    return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic);
 }
 
 static PyObject *
 set_dial_step (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_dial_step, g-> ob_generic, args);
+    return call_forms_INf (fl_set_dial_step, g-> ob_generic, args);
 }
 
 static PyMethodDef dial_methods[] = {
-	{"set_dial_value",	(PyCFunction)set_dial_value,  METH_OLDARGS},
-	{"get_dial_value",	(PyCFunction)get_dial_value,  METH_NOARGS},
-	{"set_dial_bounds",	(PyCFunction)set_dial_bounds, METH_OLDARGS},
-	{"get_dial_bounds",	(PyCFunction)get_dial_bounds, METH_NOARGS},
-	{"set_dial_step",	(PyCFunction)set_dial_step,   METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_dial_value",          (PyCFunction)set_dial_value,  METH_OLDARGS},
+    {"get_dial_value",          (PyCFunction)get_dial_value,  METH_NOARGS},
+    {"set_dial_bounds",         (PyCFunction)set_dial_bounds, METH_OLDARGS},
+    {"get_dial_bounds",         (PyCFunction)get_dial_bounds, METH_NOARGS},
+    {"set_dial_step",           (PyCFunction)set_dial_step,   METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* Class : Input */
@@ -961,33 +961,33 @@
 static PyObject *
 set_input (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_set_input, g-> ob_generic, args);
+    return call_forms_INstr (fl_set_input, g-> ob_generic, args);
 }
 
 static PyObject *
 get_input (genericobject *g)
 {
-	return call_forms_Rstr (fl_get_input, g-> ob_generic);
+    return call_forms_Rstr (fl_get_input, g-> ob_generic);
 }
 
 static PyObject *
 set_input_color (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);
 }
 
 static PyObject *
 set_input_return (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_input_return, g-> ob_generic, args);
+    return call_forms_INi (fl_set_input_return, g-> ob_generic, args);
 }
 
 static PyMethodDef input_methods[] = {
-	{"set_input",		(PyCFunction)set_input,        METH_OLDARGS},
-	{"get_input",		(PyCFunction)get_input,        METH_NOARGS},
-	{"set_input_color",	(PyCFunction)set_input_color,  METH_OLDARGS},
-	{"set_input_return",	(PyCFunction)set_input_return, METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_input",               (PyCFunction)set_input,        METH_OLDARGS},
+    {"get_input",               (PyCFunction)get_input,        METH_NOARGS},
+    {"set_input_color",         (PyCFunction)set_input_color,  METH_OLDARGS},
+    {"set_input_return",        (PyCFunction)set_input_return, METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 
@@ -996,35 +996,35 @@
 static PyObject *
 set_menu (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_set_menu, g-> ob_generic, args);
+    return call_forms_INstr (fl_set_menu, g-> ob_generic, args);
 }
 
 static PyObject *
 get_menu (genericobject *g)
 {
-	/* XXX strictly speaking this is wrong since fl_get_menu
-	   XXX returns long, not int */
-	return call_forms_Ri (fl_get_menu, g-> ob_generic);
+    /* XXX strictly speaking this is wrong since fl_get_menu
+       XXX returns long, not int */
+    return call_forms_Ri (fl_get_menu, g-> ob_generic);
 }
 
 static PyObject *
 get_menu_text (genericobject *g)
 {
-	return call_forms_Rstr (fl_get_menu_text, g-> ob_generic);
+    return call_forms_Rstr (fl_get_menu_text, g-> ob_generic);
 }
 
 static PyObject *
 addto_menu (genericobject *g, PyObject *args)
 {
-	return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);
+    return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);
 }
 
 static PyMethodDef menu_methods[] = {
-	{"set_menu",		(PyCFunction)set_menu,      METH_OLDARGS},
-	{"get_menu",		(PyCFunction)get_menu,      METH_NOARGS},
-	{"get_menu_text",	(PyCFunction)get_menu_text, METH_NOARGS},
-	{"addto_menu",		(PyCFunction)addto_menu,    METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_menu",                (PyCFunction)set_menu,      METH_OLDARGS},
+    {"get_menu",                (PyCFunction)get_menu,      METH_NOARGS},
+    {"get_menu_text",           (PyCFunction)get_menu_text, METH_NOARGS},
+    {"addto_menu",              (PyCFunction)addto_menu,    METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 
@@ -1033,132 +1033,132 @@
 static PyObject *
 get_slider_value(genericobject *g)
 {
-	return call_forms_Rf (fl_get_slider_value, g-> ob_generic);
+    return call_forms_Rf (fl_get_slider_value, g-> ob_generic);
 }
 
 static PyObject *
 set_slider_value (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);
+    return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);
 }
 
 static PyObject *
 set_slider_bounds (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);
 }
 
 static PyObject *
 get_slider_bounds (genericobject *g)
 {
-	return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic);
+    return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic);
 }
 
 static PyObject *
 set_slider_return (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);
+    return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);
 }
 
 static PyObject *
 set_slider_size (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);
+    return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);
 }
 
 static PyObject *
 set_slider_precision (genericobject *g, PyObject *args)
 {
-	return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);
+    return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);
 }
 
 static PyObject *
 set_slider_step (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_slider_step, g-> ob_generic, args);
+    return call_forms_INf (fl_set_slider_step, g-> ob_generic, args);
 }
 
 
 static PyMethodDef slider_methods[] = {
-	{"set_slider_value",	(PyCFunction)set_slider_value,  METH_OLDARGS},
-	{"get_slider_value",	(PyCFunction)get_slider_value,  METH_NOARGS},
-	{"set_slider_bounds",	(PyCFunction)set_slider_bounds, METH_OLDARGS},
-	{"get_slider_bounds",	(PyCFunction)get_slider_bounds, METH_NOARGS},
-	{"set_slider_return",	(PyCFunction)set_slider_return, METH_OLDARGS},
-	{"set_slider_size",	(PyCFunction)set_slider_size,   METH_OLDARGS},
-	{"set_slider_precision",(PyCFunction)set_slider_precision, METH_OLDARGS},
-	{"set_slider_step",	(PyCFunction)set_slider_step,   METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_slider_value",        (PyCFunction)set_slider_value,  METH_OLDARGS},
+    {"get_slider_value",        (PyCFunction)get_slider_value,  METH_NOARGS},
+    {"set_slider_bounds",       (PyCFunction)set_slider_bounds, METH_OLDARGS},
+    {"get_slider_bounds",       (PyCFunction)get_slider_bounds, METH_NOARGS},
+    {"set_slider_return",       (PyCFunction)set_slider_return, METH_OLDARGS},
+    {"set_slider_size",         (PyCFunction)set_slider_size,   METH_OLDARGS},
+    {"set_slider_precision",(PyCFunction)set_slider_precision, METH_OLDARGS},
+    {"set_slider_step",         (PyCFunction)set_slider_step,   METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 static PyObject *
 set_positioner_xvalue (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);
+    return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);
 }
 
 static PyObject *
 set_positioner_xbounds (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_positioner_xbounds,
-				  g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_positioner_xbounds,
+                              g-> ob_generic, args);
 }
 
 static PyObject *
 set_positioner_yvalue (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);
+    return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);
 }
 
 static PyObject *
 set_positioner_ybounds (genericobject *g, PyObject *args)
 {
-	return call_forms_INfINf (fl_set_positioner_ybounds,
-				  g-> ob_generic, args);
+    return call_forms_INfINf (fl_set_positioner_ybounds,
+                              g-> ob_generic, args);
 }
 
 static PyObject *
 get_positioner_xvalue (genericobject *g)
 {
-	return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic);
+    return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic);
 }
 
 static PyObject *
 get_positioner_xbounds (genericobject *g)
 {
-	return call_forms_OUTfOUTf (fl_get_positioner_xbounds, g-> ob_generic);
+    return call_forms_OUTfOUTf (fl_get_positioner_xbounds, g-> ob_generic);
 }
 
 static PyObject *
 get_positioner_yvalue (genericobject *g)
 {
-	return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic);
+    return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic);
 }
 
 static PyObject *
 get_positioner_ybounds (genericobject *g)
 {
-	return call_forms_OUTfOUTf (fl_get_positioner_ybounds, g-> ob_generic);
+    return call_forms_OUTfOUTf (fl_get_positioner_ybounds, g-> ob_generic);
 }
 
 static PyMethodDef positioner_methods[] = {
-	{"set_positioner_xvalue",	(PyCFunction)set_positioner_xvalue,
-	 METH_OLDARGS},
-	{"set_positioner_yvalue",	(PyCFunction)set_positioner_yvalue,
-	 METH_OLDARGS},
-	{"set_positioner_xbounds",	(PyCFunction)set_positioner_xbounds,
-	 METH_OLDARGS},
-	{"set_positioner_ybounds",	(PyCFunction)set_positioner_ybounds,
-	 METH_OLDARGS},
-	{"get_positioner_xvalue",	(PyCFunction)get_positioner_xvalue,
-	 METH_NOARGS},
-	{"get_positioner_yvalue",	(PyCFunction)get_positioner_yvalue,
-	 METH_NOARGS},
-	{"get_positioner_xbounds",	(PyCFunction)get_positioner_xbounds,
-	 METH_NOARGS},
-	{"get_positioner_ybounds",	(PyCFunction)get_positioner_ybounds,
-	 METH_NOARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_positioner_xvalue",           (PyCFunction)set_positioner_xvalue,
+     METH_OLDARGS},
+    {"set_positioner_yvalue",           (PyCFunction)set_positioner_yvalue,
+     METH_OLDARGS},
+    {"set_positioner_xbounds",          (PyCFunction)set_positioner_xbounds,
+     METH_OLDARGS},
+    {"set_positioner_ybounds",          (PyCFunction)set_positioner_ybounds,
+     METH_OLDARGS},
+    {"get_positioner_xvalue",           (PyCFunction)get_positioner_xvalue,
+     METH_NOARGS},
+    {"get_positioner_yvalue",           (PyCFunction)get_positioner_yvalue,
+     METH_NOARGS},
+    {"get_positioner_xbounds",          (PyCFunction)get_positioner_xbounds,
+     METH_NOARGS},
+    {"get_positioner_ybounds",          (PyCFunction)get_positioner_ybounds,
+     METH_NOARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* Class timer */
@@ -1166,26 +1166,26 @@
 static PyObject *
 set_timer (genericobject *g, PyObject *args)
 {
-	return call_forms_INf (fl_set_timer, g-> ob_generic, args);
+    return call_forms_INf (fl_set_timer, g-> ob_generic, args);
 }
 
 static PyObject *
 get_timer (genericobject *g)
 {
-	return call_forms_Rf (fl_get_timer, g-> ob_generic);
+    return call_forms_Rf (fl_get_timer, g-> ob_generic);
 }
 
 static PyMethodDef timer_methods[] = {
-	{"set_timer",		(PyCFunction)set_timer, METH_OLDARGS},
-	{"get_timer",		(PyCFunction)get_timer, METH_NOARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"set_timer",               (PyCFunction)set_timer, METH_OLDARGS},
+    {"get_timer",               (PyCFunction)get_timer, METH_NOARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 /* Form objects */
 
 typedef struct {
-	PyObject_HEAD
-	FL_FORM *ob_form;
+    PyObject_HEAD
+    FL_FORM *ob_form;
 } formobject;
 
 static PyTypeObject Formtype;
@@ -1195,371 +1195,371 @@
 static PyObject *
 form_show_form(formobject *f, PyObject *args)
 {
-	int place, border;
-	char *name;
-	if (!PyArg_Parse(args, "(iis)", &place, &border, &name))
-		return NULL;
-	fl_show_form(f->ob_form, place, border, name);
-	Py_INCREF(Py_None);
-	return Py_None;
+    int place, border;
+    char *name;
+    if (!PyArg_Parse(args, "(iis)", &place, &border, &name))
+        return NULL;
+    fl_show_form(f->ob_form, place, border, name);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 form_call(void (*func)(FL_FORM *), FL_FORM *f)
 {
-	(*func)(f);
+    (*func)(f);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 form_call_INiINi(void (*func)(FL_FORM *, int, int), FL_FORM *f, PyObject *args)
 {
-	int a, b;
+    int a, b;
 
-	if (!PyArg_Parse(args, "(ii)", &a, &b)) return NULL;
+    if (!PyArg_Parse(args, "(ii)", &a, &b)) return NULL;
 
-	(*func)(f, a, b);
+    (*func)(f, a, b);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 form_call_INfINf(void (*func)(FL_FORM *, float, float), FL_FORM *f, PyObject *args)
 {
-	float a, b;
+    float a, b;
 
-	if (!PyArg_Parse(args, "(ff)", &a, &b)) return NULL;
+    if (!PyArg_Parse(args, "(ff)", &a, &b)) return NULL;
 
-	(*func)(f, a, b);
+    (*func)(f, a, b);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 form_hide_form(formobject *f)
 {
-	return form_call(fl_hide_form, f-> ob_form);
+    return form_call(fl_hide_form, f-> ob_form);
 }
 
 static PyObject *
 form_redraw_form(formobject *f)
 {
-	return form_call(fl_redraw_form, f-> ob_form);
+    return form_call(fl_redraw_form, f-> ob_form);
 }
 
 static PyObject *
 form_set_form_position(formobject *f, PyObject *args)
 {
-	return form_call_INiINi(fl_set_form_position, f-> ob_form, args);
+    return form_call_INiINi(fl_set_form_position, f-> ob_form, args);
 }
 
 static PyObject *
 form_set_form_size(formobject *f, PyObject *args)
 {
-	return form_call_INiINi(fl_set_form_size, f-> ob_form, args);
+    return form_call_INiINi(fl_set_form_size, f-> ob_form, args);
 }
 
 static PyObject *
 form_scale_form(formobject *f, PyObject *args)
 {
-	return form_call_INfINf(fl_scale_form, f-> ob_form, args);
+    return form_call_INfINf(fl_scale_form, f-> ob_form, args);
 }
 
 static PyObject *
 generic_add_object(formobject *f, PyObject *args, FL_OBJECT *(*func)(int, float, float, float, float, char*), PyMethodDef *internal_methods)
 {
-	int type;
-	float x, y, w, h;
-	char *name;
-	FL_OBJECT *obj;
+    int type;
+    float x, y, w, h;
+    char *name;
+    FL_OBJECT *obj;
 
-	if (!PyArg_Parse(args,"(iffffs)", &type,&x,&y,&w,&h,&name))
-		return NULL;
+    if (!PyArg_Parse(args,"(iffffs)", &type,&x,&y,&w,&h,&name))
+        return NULL;
 
-	fl_addto_form (f-> ob_form);
+    fl_addto_form (f-> ob_form);
 
-	obj = (*func) (type, x, y, w, h, name);
+    obj = (*func) (type, x, y, w, h, name);
 
-	fl_end_form();
+    fl_end_form();
 
-	if (obj == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
+    if (obj == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
 
-	return newgenericobject (obj, internal_methods);
+    return newgenericobject (obj, internal_methods);
 }
 
 static PyObject *
 form_add_button(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_button, button_methods);
+    return generic_add_object(f, args, fl_add_button, button_methods);
 }
 
 static PyObject *
 form_add_lightbutton(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_lightbutton, button_methods);
+    return generic_add_object(f, args, fl_add_lightbutton, button_methods);
 }
 
 static PyObject *
 form_add_roundbutton(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_roundbutton, button_methods);
+    return generic_add_object(f, args, fl_add_roundbutton, button_methods);
 }
 
 static PyObject *
 form_add_menu (formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_menu, menu_methods);
+    return generic_add_object(f, args, fl_add_menu, menu_methods);
 }
 
 static PyObject *
 form_add_slider(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_slider, slider_methods);
+    return generic_add_object(f, args, fl_add_slider, slider_methods);
 }
 
 static PyObject *
 form_add_valslider(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_valslider, slider_methods);
+    return generic_add_object(f, args, fl_add_valslider, slider_methods);
 }
 
 static PyObject *
 form_add_dial(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_dial, dial_methods);
+    return generic_add_object(f, args, fl_add_dial, dial_methods);
 }
 
 static PyObject *
 form_add_counter(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_counter, counter_methods);
+    return generic_add_object(f, args, fl_add_counter, counter_methods);
 }
 
 static PyObject *
 form_add_clock(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_clock, clock_methods);
+    return generic_add_object(f, args, fl_add_clock, clock_methods);
 }
 
 static PyObject *
 form_add_box(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_box,
-				  (PyMethodDef *)NULL);
+    return generic_add_object(f, args, fl_add_box,
+                              (PyMethodDef *)NULL);
 }
 
 static PyObject *
 form_add_choice(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_choice, choice_methods);
+    return generic_add_object(f, args, fl_add_choice, choice_methods);
 }
 
 static PyObject *
 form_add_browser(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_browser, browser_methods);
+    return generic_add_object(f, args, fl_add_browser, browser_methods);
 }
 
 static PyObject *
 form_add_positioner(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_positioner,
-				  positioner_methods);
+    return generic_add_object(f, args, fl_add_positioner,
+                              positioner_methods);
 }
 
 static PyObject *
 form_add_input(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_input, input_methods);
+    return generic_add_object(f, args, fl_add_input, input_methods);
 }
 
 static PyObject *
 form_add_text(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_text,
-				  (PyMethodDef *)NULL);
+    return generic_add_object(f, args, fl_add_text,
+                              (PyMethodDef *)NULL);
 }
 
 static PyObject *
 form_add_timer(formobject *f, PyObject *args)
 {
-	return generic_add_object(f, args, fl_add_timer, timer_methods);
+    return generic_add_object(f, args, fl_add_timer, timer_methods);
 }
 
 static PyObject *
 form_freeze_form(formobject *f)
 {
-	return form_call(fl_freeze_form, f-> ob_form);
+    return form_call(fl_freeze_form, f-> ob_form);
 }
 
 static PyObject *
 form_unfreeze_form(formobject *f)
 {
-	return form_call(fl_unfreeze_form, f-> ob_form);
+    return form_call(fl_unfreeze_form, f-> ob_form);
 }
 
 static PyObject *
 form_activate_form(formobject *f)
 {
-	return form_call(fl_activate_form, f-> ob_form);
+    return form_call(fl_activate_form, f-> ob_form);
 }
 
 static PyObject *
 form_deactivate_form(formobject *f)
 {
-	return form_call(fl_deactivate_form, f-> ob_form);
+    return form_call(fl_deactivate_form, f-> ob_form);
 }
 
 static PyObject *
 form_bgn_group(formobject *f, PyObject *args)
 {
-	FL_OBJECT *obj;
+    FL_OBJECT *obj;
 
-	fl_addto_form(f-> ob_form);
-	obj = fl_bgn_group();
-	fl_end_form();
+    fl_addto_form(f-> ob_form);
+    obj = fl_bgn_group();
+    fl_end_form();
 
-	if (obj == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
+    if (obj == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
 
-	return newgenericobject (obj, (PyMethodDef *) NULL);
+    return newgenericobject (obj, (PyMethodDef *) NULL);
 }
 
 static PyObject *
 form_end_group(formobject *f, PyObject *args)
 {
-	fl_addto_form(f-> ob_form);
-	fl_end_group();
-	fl_end_form();
-	Py_INCREF(Py_None);
-	return Py_None;
+    fl_addto_form(f-> ob_form);
+    fl_end_group();
+    fl_end_form();
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_find_first_or_last(FL_OBJECT *(*func)(FL_FORM *, int, float, float), formobject *f, PyObject *args)
 {
-	int type;
-	float mx, my;
-	FL_OBJECT *generic;
-	genericobject *g;
-	
-	if (!PyArg_Parse(args, "(iff)", &type, &mx, &my)) return NULL;
+    int type;
+    float mx, my;
+    FL_OBJECT *generic;
+    genericobject *g;
 
-	generic = (*func) (f-> ob_form, type, mx, my);
+    if (!PyArg_Parse(args, "(iff)", &type, &mx, &my)) return NULL;
 
-	if (generic == NULL)
-	{
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
+    generic = (*func) (f-> ob_form, type, mx, my);
 
-	g = findgeneric(generic);
-	if (g == NULL) {
-		PyErr_SetString(PyExc_RuntimeError,
-			   "forms_find_{first|last} returns unknown object");
-		return NULL;
-	}
-	Py_INCREF(g);
-	return (PyObject *) g;
+    if (generic == NULL)
+    {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    g = findgeneric(generic);
+    if (g == NULL) {
+        PyErr_SetString(PyExc_RuntimeError,
+                   "forms_find_{first|last} returns unknown object");
+        return NULL;
+    }
+    Py_INCREF(g);
+    return (PyObject *) g;
 }
 
 static PyObject *
 form_find_first(formobject *f, PyObject *args)
 {
-	return forms_find_first_or_last(fl_find_first, f, args);
+    return forms_find_first_or_last(fl_find_first, f, args);
 }
 
 static PyObject *
 form_find_last(formobject *f, PyObject *args)
 {
-	return forms_find_first_or_last(fl_find_last, f, args);
+    return forms_find_first_or_last(fl_find_last, f, args);
 }
 
 static PyObject *
 form_set_object_focus(formobject *f, PyObject *args)
 {
-	genericobject *g;
-	if (args == NULL || !is_genericobject(args)) {
-		PyErr_BadArgument();
-		return NULL;
-	}
-	g = (genericobject *)args;
-	fl_set_object_focus(f->ob_form, g->ob_generic);
-	Py_INCREF(Py_None);
-	return Py_None;
+    genericobject *g;
+    if (args == NULL || !is_genericobject(args)) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    g = (genericobject *)args;
+    fl_set_object_focus(f->ob_form, g->ob_generic);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyMethodDef form_methods[] = {
 /* adm */
-	{"show_form",		(PyCFunction)form_show_form,     METH_OLDARGS},
-	{"hide_form",		(PyCFunction)form_hide_form,     METH_NOARGS},
-	{"redraw_form",		(PyCFunction)form_redraw_form,   METH_NOARGS},
-	{"set_form_position",	(PyCFunction)form_set_form_position, METH_OLDARGS},
-	{"set_form_size",	(PyCFunction)form_set_form_size, METH_OLDARGS},
-	{"scale_form",		(PyCFunction)form_scale_form,    METH_OLDARGS},
-	{"freeze_form",		(PyCFunction)form_freeze_form,   METH_NOARGS},
-	{"unfreeze_form",	(PyCFunction)form_unfreeze_form, METH_NOARGS},
-	{"activate_form",	(PyCFunction)form_activate_form, METH_NOARGS},
-	{"deactivate_form",	(PyCFunction)form_deactivate_form, METH_NOARGS},
-	{"bgn_group",		(PyCFunction)form_bgn_group,  METH_OLDARGS},
-	{"end_group",		(PyCFunction)form_end_group,  METH_OLDARGS},
-	{"find_first",		(PyCFunction)form_find_first, METH_OLDARGS},
-	{"find_last",		(PyCFunction)form_find_last,  METH_OLDARGS},
-	{"set_object_focus",	(PyCFunction)form_set_object_focus, METH_OLDARGS},
+    {"show_form",               (PyCFunction)form_show_form,     METH_OLDARGS},
+    {"hide_form",               (PyCFunction)form_hide_form,     METH_NOARGS},
+    {"redraw_form",             (PyCFunction)form_redraw_form,   METH_NOARGS},
+    {"set_form_position",       (PyCFunction)form_set_form_position, METH_OLDARGS},
+    {"set_form_size",           (PyCFunction)form_set_form_size, METH_OLDARGS},
+    {"scale_form",              (PyCFunction)form_scale_form,    METH_OLDARGS},
+    {"freeze_form",             (PyCFunction)form_freeze_form,   METH_NOARGS},
+    {"unfreeze_form",           (PyCFunction)form_unfreeze_form, METH_NOARGS},
+    {"activate_form",           (PyCFunction)form_activate_form, METH_NOARGS},
+    {"deactivate_form",         (PyCFunction)form_deactivate_form, METH_NOARGS},
+    {"bgn_group",               (PyCFunction)form_bgn_group,  METH_OLDARGS},
+    {"end_group",               (PyCFunction)form_end_group,  METH_OLDARGS},
+    {"find_first",              (PyCFunction)form_find_first, METH_OLDARGS},
+    {"find_last",               (PyCFunction)form_find_last,  METH_OLDARGS},
+    {"set_object_focus",        (PyCFunction)form_set_object_focus, METH_OLDARGS},
 
 /* basic objects */
-	{"add_button",		(PyCFunction)form_add_button, METH_OLDARGS},
-/*	{"add_bitmap",		(method)form_add_bitmap, METH_OLDARGS}, */
-	{"add_lightbutton",	(PyCFunction)form_add_lightbutton, METH_OLDARGS},
-	{"add_roundbutton",	(PyCFunction)form_add_roundbutton, METH_OLDARGS},
-	{"add_menu",		(PyCFunction)form_add_menu,      METH_OLDARGS},
-	{"add_slider",		(PyCFunction)form_add_slider,    METH_OLDARGS},
-	{"add_positioner",	(PyCFunction)form_add_positioner, METH_OLDARGS},
-	{"add_valslider",	(PyCFunction)form_add_valslider, METH_OLDARGS},
-	{"add_dial",		(PyCFunction)form_add_dial,      METH_OLDARGS},
-	{"add_counter",		(PyCFunction)form_add_counter,   METH_OLDARGS},
-	{"add_box",		(PyCFunction)form_add_box,       METH_OLDARGS},
-	{"add_clock",		(PyCFunction)form_add_clock,     METH_OLDARGS},
-	{"add_choice",		(PyCFunction)form_add_choice,    METH_OLDARGS},
-	{"add_browser",		(PyCFunction)form_add_browser,   METH_OLDARGS},
-	{"add_input",		(PyCFunction)form_add_input,     METH_OLDARGS},
-	{"add_timer",		(PyCFunction)form_add_timer,     METH_OLDARGS},
-	{"add_text",		(PyCFunction)form_add_text,      METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"add_button",              (PyCFunction)form_add_button, METH_OLDARGS},
+/*      {"add_bitmap",          (method)form_add_bitmap, METH_OLDARGS}, */
+    {"add_lightbutton",         (PyCFunction)form_add_lightbutton, METH_OLDARGS},
+    {"add_roundbutton",         (PyCFunction)form_add_roundbutton, METH_OLDARGS},
+    {"add_menu",                (PyCFunction)form_add_menu,      METH_OLDARGS},
+    {"add_slider",              (PyCFunction)form_add_slider,    METH_OLDARGS},
+    {"add_positioner",          (PyCFunction)form_add_positioner, METH_OLDARGS},
+    {"add_valslider",           (PyCFunction)form_add_valslider, METH_OLDARGS},
+    {"add_dial",                (PyCFunction)form_add_dial,      METH_OLDARGS},
+    {"add_counter",             (PyCFunction)form_add_counter,   METH_OLDARGS},
+    {"add_box",                 (PyCFunction)form_add_box,       METH_OLDARGS},
+    {"add_clock",               (PyCFunction)form_add_clock,     METH_OLDARGS},
+    {"add_choice",              (PyCFunction)form_add_choice,    METH_OLDARGS},
+    {"add_browser",             (PyCFunction)form_add_browser,   METH_OLDARGS},
+    {"add_input",               (PyCFunction)form_add_input,     METH_OLDARGS},
+    {"add_timer",               (PyCFunction)form_add_timer,     METH_OLDARGS},
+    {"add_text",                (PyCFunction)form_add_text,      METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 static void
 form_dealloc(formobject *f)
 {
-	releaseobjects(f->ob_form);
-	if (f->ob_form->visible)
-		fl_hide_form(f->ob_form);
-	fl_free_form(f->ob_form);
-	PyObject_Del(f);
+    releaseobjects(f->ob_form);
+    if (f->ob_form->visible)
+        fl_hide_form(f->ob_form);
+    fl_free_form(f->ob_form);
+    PyObject_Del(f);
 }
 
 #define OFF(x) offsetof(FL_FORM, x)
 
 static struct memberlist form_memberlist[] = {
-	{"window",	T_LONG,		OFF(window),	RO},
-	{"w",		T_FLOAT,	OFF(w)},
-	{"h",		T_FLOAT,	OFF(h)},
-	{"x",		T_FLOAT,	OFF(x),		RO},
-	{"y",		T_FLOAT,	OFF(y),		RO},
-	{"deactivated",	T_INT,		OFF(deactivated)},
-	{"visible",	T_INT,		OFF(visible),	RO},
-	{"frozen",	T_INT,		OFF(frozen),	RO},
-	{"doublebuf",	T_INT,		OFF(doublebuf)},
-	{NULL}	/* Sentinel */
+    {"window",          T_LONG,         OFF(window),    RO},
+    {"w",               T_FLOAT,        OFF(w)},
+    {"h",               T_FLOAT,        OFF(h)},
+    {"x",               T_FLOAT,        OFF(x),         RO},
+    {"y",               T_FLOAT,        OFF(y),         RO},
+    {"deactivated",     T_INT,          OFF(deactivated)},
+    {"visible",         T_INT,          OFF(visible),   RO},
+    {"frozen",          T_INT,          OFF(frozen),    RO},
+    {"doublebuf",       T_INT,          OFF(doublebuf)},
+    {NULL}      /* Sentinel */
 };
 
 #undef OFF
@@ -1567,60 +1567,60 @@
 static PyObject *
 form_getattr(formobject *f, char *name)
 {
-	PyObject *meth;
+    PyObject *meth;
 
-	meth = Py_FindMethod(form_methods, (PyObject *)f, name);
-	if (meth != NULL)
-		return meth;
-	PyErr_Clear();
-	return PyMember_Get((char *)f->ob_form, form_memberlist, name);
+    meth = Py_FindMethod(form_methods, (PyObject *)f, name);
+    if (meth != NULL)
+        return meth;
+    PyErr_Clear();
+    return PyMember_Get((char *)f->ob_form, form_memberlist, name);
 }
 
 static int
 form_setattr(formobject *f, char *name, PyObject *v)
 {
-	if (v == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-				"can't delete form attributes");
-		return -1;
-	}
+    if (v == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "can't delete form attributes");
+        return -1;
+    }
 
-	return PyMember_Set((char *)f->ob_form, form_memberlist, name, v);
+    return PyMember_Set((char *)f->ob_form, form_memberlist, name, v);
 }
 
 static PyObject *
 form_repr(formobject *f)
 {
-	char buf[100];
-	PyOS_snprintf(buf, sizeof(buf), "<FORMS_form at %p, window=%ld>",
-		      f, f->ob_form->window);
-	return PyString_FromString(buf);
+    char buf[100];
+    PyOS_snprintf(buf, sizeof(buf), "<FORMS_form at %p, window=%ld>",
+                  f, f->ob_form->window);
+    return PyString_FromString(buf);
 }
 
 static PyTypeObject Formtype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/*ob_size*/
-	"fl.FORMS_form",		/*tp_name*/
-	sizeof(formobject),		/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)form_dealloc,	/*tp_dealloc*/
-	0,				/*tp_print*/
-	(getattrfunc)form_getattr,	/*tp_getattr*/
-	(setattrfunc)form_setattr,	/*tp_setattr*/
-	0,				/*tp_compare*/
-	(reprfunc)form_repr,		/*tp_repr*/
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,                                  /*ob_size*/
+    "fl.FORMS_form",                    /*tp_name*/
+    sizeof(formobject),                 /*tp_size*/
+    0,                                  /*tp_itemsize*/
+    /* methods */
+    (destructor)form_dealloc,           /*tp_dealloc*/
+    0,                                  /*tp_print*/
+    (getattrfunc)form_getattr,          /*tp_getattr*/
+    (setattrfunc)form_setattr,          /*tp_setattr*/
+    0,                                  /*tp_compare*/
+    (reprfunc)form_repr,                /*tp_repr*/
 };
 
 static PyObject *
 newformobject(FL_FORM *form)
 {
-	formobject *f;
-	f = PyObject_New(formobject, &Formtype);
-	if (f == NULL)
-		return NULL;
-	f->ob_form = form;
-	return (PyObject *)f;
+    formobject *f;
+    f = PyObject_New(formobject, &Formtype);
+    if (f == NULL)
+        return NULL;
+    f->ob_form = form;
+    return (PyObject *)f;
 }
 
 
@@ -1629,35 +1629,35 @@
 static PyObject *
 forms_make_form(PyObject *dummy, PyObject *args)
 {
-	int type;
-	float w, h;
-	FL_FORM *form;
-	if (!PyArg_Parse(args, "(iff)", &type, &w, &h))
-		return NULL;
-	form = fl_bgn_form(type, w, h);
-	if (form == NULL) {
-		/* XXX Actually, cannot happen! */
-		PyErr_NoMemory();
-		return NULL;
-	}
-	fl_end_form();
-	return newformobject(form);
+    int type;
+    float w, h;
+    FL_FORM *form;
+    if (!PyArg_Parse(args, "(iff)", &type, &w, &h))
+        return NULL;
+    form = fl_bgn_form(type, w, h);
+    if (form == NULL) {
+        /* XXX Actually, cannot happen! */
+        PyErr_NoMemory();
+        return NULL;
+    }
+    fl_end_form();
+    return newformobject(form);
 }
 
 static PyObject *
 forms_activate_all_forms(PyObject *f, PyObject *args)
 {
-	fl_activate_all_forms();
-	Py_INCREF(Py_None);
-	return Py_None;
+    fl_activate_all_forms();
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_deactivate_all_forms(PyObject *f, PyObject *args)
 {
-	fl_deactivate_all_forms();
-	Py_INCREF(Py_None);
-	return Py_None;
+    fl_deactivate_all_forms();
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *my_event_callback = NULL;
@@ -1665,479 +1665,479 @@
 static PyObject *
 forms_set_event_call_back(PyObject *dummy, PyObject *args)
 {
-	if (args == Py_None)
-		args = NULL;
-	my_event_callback = args;
-	Py_XINCREF(args);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (args == Py_None)
+        args = NULL;
+    my_event_callback = args;
+    Py_XINCREF(args);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_do_or_check_forms(PyObject *dummy, FL_OBJECT *(*func)(void))
 {
-	FL_OBJECT *generic;
-	genericobject *g;
-	PyObject *arg, *res;
+    FL_OBJECT *generic;
+    genericobject *g;
+    PyObject *arg, *res;
 
-	for (;;) {
-		Py_BEGIN_ALLOW_THREADS
-		generic = (*func)();
-		Py_END_ALLOW_THREADS
-		if (generic == NULL) {
-			Py_INCREF(Py_None);
-			return Py_None;
-		}
-		if (generic == FL_EVENT) {
-			int dev;
-			short val;
-			if (my_event_callback == NULL)
-				return PyInt_FromLong(-1L);
-			dev = fl_qread(&val);
-			arg = Py_BuildValue("(ih)", dev, val);
-			if (arg == NULL)
-				return NULL;
-			res = PyEval_CallObject(my_event_callback, arg);
-			Py_XDECREF(res);
-			Py_DECREF(arg);
-			if (res == NULL)
-				return NULL; /* Callback raised exception */
-			continue;
-		}
-		g = findgeneric(generic);
-		if (g == NULL) {
-			/* Object not known to us (some dialogs cause this) */
-			continue; /* Ignore it */
-		}
-		if (g->ob_callback == NULL) {
-			Py_INCREF(g);
-			return ((PyObject *) g);
-		}
-		arg = PyTuple_Pack(2, (PyObject *)g, g->ob_callback_arg);
-		if (arg == NULL)
-			return NULL;
-		res = PyEval_CallObject(g->ob_callback, arg);
-		Py_XDECREF(res);
-		Py_DECREF(arg);
-		if (res == NULL)
-			return NULL; /* Callback raised exception */
-	}
+    for (;;) {
+        Py_BEGIN_ALLOW_THREADS
+        generic = (*func)();
+        Py_END_ALLOW_THREADS
+        if (generic == NULL) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        if (generic == FL_EVENT) {
+            int dev;
+            short val;
+            if (my_event_callback == NULL)
+                return PyInt_FromLong(-1L);
+            dev = fl_qread(&val);
+            arg = Py_BuildValue("(ih)", dev, val);
+            if (arg == NULL)
+                return NULL;
+            res = PyEval_CallObject(my_event_callback, arg);
+            Py_XDECREF(res);
+            Py_DECREF(arg);
+            if (res == NULL)
+                return NULL; /* Callback raised exception */
+            continue;
+        }
+        g = findgeneric(generic);
+        if (g == NULL) {
+            /* Object not known to us (some dialogs cause this) */
+            continue; /* Ignore it */
+        }
+        if (g->ob_callback == NULL) {
+            Py_INCREF(g);
+            return ((PyObject *) g);
+        }
+        arg = PyTuple_Pack(2, (PyObject *)g, g->ob_callback_arg);
+        if (arg == NULL)
+            return NULL;
+        res = PyEval_CallObject(g->ob_callback, arg);
+        Py_XDECREF(res);
+        Py_DECREF(arg);
+        if (res == NULL)
+            return NULL; /* Callback raised exception */
+    }
 }
 
 static PyObject *
 forms_do_forms(PyObject *dummy)
 {
-	return forms_do_or_check_forms(dummy, fl_do_forms);
+    return forms_do_or_check_forms(dummy, fl_do_forms);
 }
 
 static PyObject *
 forms_check_forms(PyObject *dummy)
 {
-	return forms_do_or_check_forms(dummy, fl_check_forms);
+    return forms_do_or_check_forms(dummy, fl_check_forms);
 }
 
 static PyObject *
 forms_do_only_forms(PyObject *dummy)
 {
-	return forms_do_or_check_forms(dummy, fl_do_only_forms);
+    return forms_do_or_check_forms(dummy, fl_do_only_forms);
 }
 
 static PyObject *
 forms_check_only_forms(PyObject *dummy)
 {
-	return forms_do_or_check_forms(dummy, fl_check_only_forms);
+    return forms_do_or_check_forms(dummy, fl_check_only_forms);
 }
 
 #ifdef UNUSED
 static PyObject *
 fl_call(void (*func)(void))
 {
-	(*func)();
-	Py_INCREF(Py_None);
-	return Py_None;
+    (*func)();
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif
 
 static PyObject *
 forms_set_graphics_mode(PyObject *dummy, PyObject *args)
 {
-	int rgbmode, doublebuf;
+    int rgbmode, doublebuf;
 
-	if (!PyArg_Parse(args, "(ii)", &rgbmode, &doublebuf))
-		return NULL;
-	fl_set_graphics_mode(rgbmode,doublebuf);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_Parse(args, "(ii)", &rgbmode, &doublebuf))
+        return NULL;
+    fl_set_graphics_mode(rgbmode,doublebuf);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_get_rgbmode(PyObject *dummy, PyObject *args)
 {
-	extern int fl_rgbmode;
+    extern int fl_rgbmode;
 
-	if (args != NULL) {
-		PyErr_BadArgument();
-		return NULL;
-	}
-	return PyInt_FromLong((long)fl_rgbmode);
+    if (args != NULL) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    return PyInt_FromLong((long)fl_rgbmode);
 }
 
 static PyObject *
 forms_show_errors(PyObject *dummy, PyObject *args)
 {
-	int show;
-	if (!PyArg_Parse(args, "i", &show))
-		return NULL;
-	fl_show_errors(show);
-	Py_INCREF(Py_None);
-	return Py_None;
+    int show;
+    if (!PyArg_Parse(args, "i", &show))
+        return NULL;
+    fl_show_errors(show);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_set_font_name(PyObject *dummy, PyObject *args)
 {
-	int numb;
-	char *name;
-	if (!PyArg_Parse(args, "(is)", &numb, &name))
-		return NULL;
-	fl_set_font_name(numb, name);
-	Py_INCREF(Py_None);
-	return Py_None;
+    int numb;
+    char *name;
+    if (!PyArg_Parse(args, "(is)", &numb, &name))
+        return NULL;
+    fl_set_font_name(numb, name);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 static PyObject *
 forms_qdevice(PyObject *self, PyObject *args)
 {
-	short arg1;
-	if (!PyArg_Parse(args, "h", &arg1))
-		return NULL;
-	fl_qdevice(arg1);
-	Py_INCREF(Py_None);
-	return Py_None;
+    short arg1;
+    if (!PyArg_Parse(args, "h", &arg1))
+        return NULL;
+    fl_qdevice(arg1);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_unqdevice(PyObject *self, PyObject *args)
 {
-	short arg1;
-	if (!PyArg_Parse(args, "h", &arg1))
-		return NULL;
-	fl_unqdevice(arg1);
-	Py_INCREF(Py_None);
-	return Py_None;
+    short arg1;
+    if (!PyArg_Parse(args, "h", &arg1))
+        return NULL;
+    fl_unqdevice(arg1);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_isqueued(PyObject *self, PyObject *args)
 {
-	long retval;
-	short arg1;
-	if (!PyArg_Parse(args, "h", &arg1))
-		return NULL;
-	retval = fl_isqueued(arg1);
+    long retval;
+    short arg1;
+    if (!PyArg_Parse(args, "h", &arg1))
+        return NULL;
+    retval = fl_isqueued(arg1);
 
-	return PyInt_FromLong(retval);
+    return PyInt_FromLong(retval);
 }
 
 static PyObject *
 forms_qtest(PyObject *self, PyObject *args)
 {
-	long retval;
-	retval = fl_qtest();
-	return PyInt_FromLong(retval);
+    long retval;
+    retval = fl_qtest();
+    return PyInt_FromLong(retval);
 }
 
 
 static PyObject *
 forms_qread(PyObject *self, PyObject *args)
 {
-	int dev;
-	short val;
-	Py_BEGIN_ALLOW_THREADS
-	dev = fl_qread(&val);
-	Py_END_ALLOW_THREADS
-	return Py_BuildValue("(ih)", dev, val);
+    int dev;
+    short val;
+    Py_BEGIN_ALLOW_THREADS
+    dev = fl_qread(&val);
+    Py_END_ALLOW_THREADS
+    return Py_BuildValue("(ih)", dev, val);
 }
 
 static PyObject *
 forms_qreset(PyObject *self)
 {
-	fl_qreset();
-	Py_INCREF(Py_None);
-	return Py_None;
+    fl_qreset();
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_qenter(PyObject *self, PyObject *args)
 {
-	short arg1, arg2;
-	if (!PyArg_Parse(args, "(hh)", &arg1, &arg2))
-		return NULL;
-	fl_qenter(arg1, arg2);
-	Py_INCREF(Py_None);
-	return Py_None;
+    short arg1, arg2;
+    if (!PyArg_Parse(args, "(hh)", &arg1, &arg2))
+        return NULL;
+    fl_qenter(arg1, arg2);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_color(PyObject *self, PyObject *args)
 {
-	int arg;
+    int arg;
 
-	if (!PyArg_Parse(args, "i", &arg)) return NULL;
+    if (!PyArg_Parse(args, "i", &arg)) return NULL;
 
-	fl_color((short) arg);
+    fl_color((short) arg);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_mapcolor(PyObject *self, PyObject *args)
 {
-	int arg0, arg1, arg2, arg3;
+    int arg0, arg1, arg2, arg3;
 
-	if (!PyArg_Parse(args, "(iiii)", &arg0, &arg1, &arg2, &arg3))
-		return NULL;
+    if (!PyArg_Parse(args, "(iiii)", &arg0, &arg1, &arg2, &arg3))
+        return NULL;
 
-	fl_mapcolor(arg0, (short) arg1, (short) arg2, (short) arg3);
+    fl_mapcolor(arg0, (short) arg1, (short) arg2, (short) arg3);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_getmcolor(PyObject *self, PyObject *args)
 {
-	int arg;
-	short r, g, b;
+    int arg;
+    short r, g, b;
 
-	if (!PyArg_Parse(args, "i", &arg)) return NULL;
+    if (!PyArg_Parse(args, "i", &arg)) return NULL;
 
-	fl_getmcolor(arg, &r, &g, &b);
+    fl_getmcolor(arg, &r, &g, &b);
 
-	return Py_BuildValue("(hhh)", r, g, b);
+    return Py_BuildValue("(hhh)", r, g, b);
 }
 
 static PyObject *
 forms_get_mouse(PyObject *self)
 {
-	float x, y;
+    float x, y;
 
-	fl_get_mouse(&x, &y);
+    fl_get_mouse(&x, &y);
 
-	return Py_BuildValue("(ff)", x, y);
+    return Py_BuildValue("(ff)", x, y);
 }
 
 static PyObject *
 forms_tie(PyObject *self, PyObject *args)
 {
-	short arg1, arg2, arg3;
-	if (!PyArg_Parse(args, "(hhh)", &arg1, &arg2, &arg3))
-		return NULL;
-	fl_tie(arg1, arg2, arg3);
-	Py_INCREF(Py_None);
-	return Py_None;
+    short arg1, arg2, arg3;
+    if (!PyArg_Parse(args, "(hhh)", &arg1, &arg2, &arg3))
+        return NULL;
+    fl_tie(arg1, arg2, arg3);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_show_message(PyObject *f, PyObject *args)
 {
-	char *a, *b, *c;
+    char *a, *b, *c;
 
-	if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
+    if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	fl_show_message(a, b, c);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    fl_show_message(a, b, c);
+    Py_END_ALLOW_THREADS
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 forms_show_choice(PyObject *f, PyObject *args)
 {
-	char *m1, *m2, *m3, *b1, *b2, *b3;
-	int nb;
-	char *format;
-	long rv;
+    char *m1, *m2, *m3, *b1, *b2, *b3;
+    int nb;
+    char *format;
+    long rv;
 
-	if (args == NULL || !PyTuple_Check(args)) {
-		PyErr_BadArgument();
-		return NULL;
-	}
-	nb = PyTuple_Size(args) - 3;
-	if (nb <= 0) {
-		PyErr_SetString(PyExc_TypeError,
-				"need at least one button label");
-		return NULL;
-	}
-	if (PyInt_Check(PyTuple_GetItem(args, 3))) {
-		PyErr_SetString(PyExc_TypeError,
-			   "'number-of-buttons' argument not needed");
-		return NULL;
-	}
-	switch (nb) {
-	case 1: format = "(ssss)"; break;
-	case 2: format = "(sssss)"; break;
-	case 3: format = "(ssssss)"; break;
-	default:
-		PyErr_SetString(PyExc_TypeError, "too many button labels");
-		return NULL;
-	}
+    if (args == NULL || !PyTuple_Check(args)) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    nb = PyTuple_Size(args) - 3;
+    if (nb <= 0) {
+        PyErr_SetString(PyExc_TypeError,
+                        "need at least one button label");
+        return NULL;
+    }
+    if (PyInt_Check(PyTuple_GetItem(args, 3))) {
+        PyErr_SetString(PyExc_TypeError,
+                   "'number-of-buttons' argument not needed");
+        return NULL;
+    }
+    switch (nb) {
+    case 1: format = "(ssss)"; break;
+    case 2: format = "(sssss)"; break;
+    case 3: format = "(ssssss)"; break;
+    default:
+        PyErr_SetString(PyExc_TypeError, "too many button labels");
+        return NULL;
+    }
 
-	if (!PyArg_Parse(args, format, &m1, &m2, &m3, &b1, &b2, &b3))
-		return NULL;
+    if (!PyArg_Parse(args, format, &m1, &m2, &m3, &b1, &b2, &b3))
+        return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	rv = fl_show_choice(m1, m2, m3, nb, b1, b2, b3);
-	Py_END_ALLOW_THREADS
-	return PyInt_FromLong(rv);
+    Py_BEGIN_ALLOW_THREADS
+    rv = fl_show_choice(m1, m2, m3, nb, b1, b2, b3);
+    Py_END_ALLOW_THREADS
+    return PyInt_FromLong(rv);
 }
 
 static PyObject *
 forms_show_question(PyObject *f, PyObject *args)
 {
-	int ret;
-	char *a, *b, *c;
+    int ret;
+    char *a, *b, *c;
 
-	if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
+    if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	ret = fl_show_question(a, b, c);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    ret = fl_show_question(a, b, c);
+    Py_END_ALLOW_THREADS
 
-	return PyInt_FromLong((long) ret);
+    return PyInt_FromLong((long) ret);
 }
 
 static PyObject *
 forms_show_input(PyObject *f, PyObject *args)
 {
-	char *str;
-	char *a, *b;
+    char *str;
+    char *a, *b;
 
-	if (!PyArg_Parse(args, "(ss)", &a, &b)) return NULL;
+    if (!PyArg_Parse(args, "(ss)", &a, &b)) return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	str = fl_show_input(a, b);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    str = fl_show_input(a, b);
+    Py_END_ALLOW_THREADS
 
-	if (str == NULL) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromString(str);
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromString(str);
 }
 
 static PyObject *
 forms_file_selector(PyObject *f, PyObject *args)
 {
-	char *str;
-	char *a, *b, *c, *d;
+    char *str;
+    char *a, *b, *c, *d;
 
-	if (!PyArg_Parse(args, "(ssss)", &a, &b, &c, &d)) return NULL;
+    if (!PyArg_Parse(args, "(ssss)", &a, &b, &c, &d)) return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	str = fl_show_file_selector(a, b, c, d);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    str = fl_show_file_selector(a, b, c, d);
+    Py_END_ALLOW_THREADS
 
-	if (str == NULL) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromString(str);
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromString(str);
 }
 
 
 static PyObject *
 forms_file_selector_func(PyObject *args, char *(*func)(void))
 {
-	char *str;
+    char *str;
 
-	str = (*func) ();
+    str = (*func) ();
 
-	if (str == NULL) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromString(str);
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromString(str);
 }
 
 static PyObject *
 forms_get_directory(PyObject *f, PyObject *args)
 {
-	return forms_file_selector_func(args, fl_get_directory);
+    return forms_file_selector_func(args, fl_get_directory);
 }
 
 static PyObject *
 forms_get_pattern(PyObject *f, PyObject *args)
 {
-	return forms_file_selector_func(args, fl_get_pattern);
+    return forms_file_selector_func(args, fl_get_pattern);
 }
 
 static PyObject *
 forms_get_filename(PyObject *f, PyObject *args)
 {
-	return forms_file_selector_func(args, fl_get_filename);
+    return forms_file_selector_func(args, fl_get_filename);
 }
 
 static PyMethodDef forms_methods[] = {
 /* adm */
-	{"make_form",		forms_make_form, METH_OLDARGS},
-	{"activate_all_forms",	forms_activate_all_forms, METH_OLDARGS},
-	{"deactivate_all_forms",forms_deactivate_all_forms, METH_OLDARGS},
+    {"make_form",               forms_make_form, METH_OLDARGS},
+    {"activate_all_forms",      forms_activate_all_forms, METH_OLDARGS},
+    {"deactivate_all_forms",forms_deactivate_all_forms, METH_OLDARGS},
 /* gl support wrappers */
-	{"qdevice",		forms_qdevice, METH_OLDARGS},
-	{"unqdevice",		forms_unqdevice, METH_OLDARGS},
-	{"isqueued",		forms_isqueued, METH_OLDARGS},
-	{"qtest",		forms_qtest, METH_OLDARGS},
-	{"qread",		forms_qread, METH_OLDARGS},
-/*	{"blkqread",		forms_blkqread, METH_OLDARGS}, */
-	{"qreset",		forms_qreset, METH_NOARGS},
-	{"qenter",		forms_qenter, METH_OLDARGS},
-	{"get_mouse",		forms_get_mouse, METH_NOARGS},
-	{"tie",			forms_tie, METH_OLDARGS},
-/*	{"new_events",		forms_new_events, METH_OLDARGS}, */
-	{"color",		forms_color, METH_OLDARGS},
-	{"mapcolor",		forms_mapcolor, METH_OLDARGS},
-	{"getmcolor",		forms_getmcolor, METH_OLDARGS},
+    {"qdevice",                 forms_qdevice, METH_OLDARGS},
+    {"unqdevice",               forms_unqdevice, METH_OLDARGS},
+    {"isqueued",                forms_isqueued, METH_OLDARGS},
+    {"qtest",                   forms_qtest, METH_OLDARGS},
+    {"qread",                   forms_qread, METH_OLDARGS},
+/*      {"blkqread",            forms_blkqread, METH_OLDARGS}, */
+    {"qreset",                  forms_qreset, METH_NOARGS},
+    {"qenter",                  forms_qenter, METH_OLDARGS},
+    {"get_mouse",               forms_get_mouse, METH_NOARGS},
+    {"tie",                     forms_tie, METH_OLDARGS},
+/*      {"new_events",          forms_new_events, METH_OLDARGS}, */
+    {"color",                   forms_color, METH_OLDARGS},
+    {"mapcolor",                forms_mapcolor, METH_OLDARGS},
+    {"getmcolor",               forms_getmcolor, METH_OLDARGS},
 /* interaction */
-	{"do_forms",		forms_do_forms, METH_NOARGS},
-	{"do_only_forms",	forms_do_only_forms, METH_NOARGS},
-	{"check_forms",		forms_check_forms, METH_NOARGS},
-	{"check_only_forms",	forms_check_only_forms, METH_NOARGS},
-	{"set_event_call_back",	forms_set_event_call_back, METH_OLDARGS},
+    {"do_forms",                forms_do_forms, METH_NOARGS},
+    {"do_only_forms",           forms_do_only_forms, METH_NOARGS},
+    {"check_forms",             forms_check_forms, METH_NOARGS},
+    {"check_only_forms",        forms_check_only_forms, METH_NOARGS},
+    {"set_event_call_back",     forms_set_event_call_back, METH_OLDARGS},
 /* goodies */
-	{"show_message",	forms_show_message, METH_OLDARGS},
-	{"show_question",	forms_show_question, METH_OLDARGS},
-	{"show_choice",		forms_show_choice, METH_OLDARGS},
-	{"show_input",		forms_show_input, METH_OLDARGS},
-	{"show_file_selector",	forms_file_selector, METH_OLDARGS},
-	{"file_selector",	forms_file_selector, METH_OLDARGS}, /* BW compat */
-	{"get_directory",	forms_get_directory, METH_OLDARGS},
-	{"get_pattern",		forms_get_pattern, METH_OLDARGS},
-	{"get_filename",	forms_get_filename, METH_OLDARGS},
-	{"set_graphics_mode",	forms_set_graphics_mode, METH_OLDARGS},
-	{"get_rgbmode",		forms_get_rgbmode, METH_OLDARGS},
-	{"show_errors",		forms_show_errors, METH_OLDARGS},
-	{"set_font_name",	forms_set_font_name, METH_OLDARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"show_message",            forms_show_message, METH_OLDARGS},
+    {"show_question",           forms_show_question, METH_OLDARGS},
+    {"show_choice",             forms_show_choice, METH_OLDARGS},
+    {"show_input",              forms_show_input, METH_OLDARGS},
+    {"show_file_selector",      forms_file_selector, METH_OLDARGS},
+    {"file_selector",           forms_file_selector, METH_OLDARGS}, /* BW compat */
+    {"get_directory",           forms_get_directory, METH_OLDARGS},
+    {"get_pattern",             forms_get_pattern, METH_OLDARGS},
+    {"get_filename",            forms_get_filename, METH_OLDARGS},
+    {"set_graphics_mode",       forms_set_graphics_mode, METH_OLDARGS},
+    {"get_rgbmode",             forms_get_rgbmode, METH_OLDARGS},
+    {"show_errors",             forms_show_errors, METH_OLDARGS},
+    {"set_font_name",           forms_set_font_name, METH_OLDARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 PyMODINIT_FUNC
 initfl(void)
 {
-    
+
     if (PyErr_WarnPy3k("the fl module has been removed in "
                        "Python 3.0", 2) < 0)
+    return;
+
+    Py_InitModule("fl", forms_methods);
+    if (m == NULL)
         return;
-    
-	Py_InitModule("fl", forms_methods);
-	if (m == NULL)
-		return;
-	foreground();
-	fl_init();
+    foreground();
+    fl_init();
 }