Another round in the Great BPy Cleanup:

Run everything thru indent to cleanup spaces vs tabs.
Clean up some of the comments by hand.
BGL.c was not touched due to all that macro wackyness.

There are no functional changes to the code.
Pre-indent versions of source are tagged with
tag bpy-cleanup-20040925 , just in case.

1 files changed, 829 insertions, 712 deletions

diff --git a/source/blender/python/api2_2x/Metaball.c b/source/blender/python/api2_2x/Metaball.c
index 38daffcbb5f..6c55dddfc4d 100644
--- a/source/blender/python/api2_2x/Metaball.c
+++ b/source/blender/python/api2_2x/Metaball.c
@@ -32,265 +32,276 @@
 
 #include "Metaball.h"
 
-PyObject * Metaball_Init (void);
-PyObject * Metaball_CreatePyObject (MetaBall *metaball);
-MetaBall * Metaball_FromPyObject   (PyObject *py_obj);
-int        Metaball_CheckPyObject  (PyObject *py_obj);
+PyObject *Metaball_Init( void );
+PyObject *Metaball_CreatePyObject( MetaBall * metaball );
+MetaBall *Metaball_FromPyObject( PyObject * py_obj );
+int Metaball_CheckPyObject( PyObject * py_obj );
 
 /*****************************************************************************/
-/* Python Metaball_Type structure definition:                                  */
+/* Python Metaball_Type structure definition:                                */
 /*****************************************************************************/
-PyTypeObject Metaball_Type =
-	{
-		PyObject_HEAD_INIT(NULL)
-		0,                                      /* ob_size */
-		"Metaball",                               /* tp_name */
-		sizeof (BPy_Metaball),                      /* tp_basicsize */
-		0,                                      /* tp_itemsize */
-		/* methods */
-		(destructor)MetaballDeAlloc,              /* tp_dealloc */
-		0,                 /* tp_print */
-		(getattrfunc)MetaballGetAttr,             /* tp_getattr */
-		(setattrfunc)MetaballSetAttr,             /* tp_setattr */
-		0,                                      /* tp_compare */
-		(reprfunc)MetaballRepr,                   /* tp_repr */
-		0,                                      /* tp_as_number */
-		0,                                      /* tp_as_sequence */
-		0,                                      /* tp_as_mapping */
-		0,                                      /* tp_as_hash */
-		0,0,0,0,0,0,
-		0,                                      /* tp_doc */ 
-		0,0,0,0,0,0,
-		BPy_Metaball_methods,                       /* tp_methods */
-		0,                                      /* tp_members */
-	};
-
-
-PyTypeObject Metaelem_Type =
-	{
-		PyObject_HEAD_INIT(NULL)
-		0,                                      /* ob_size */
-		"Metaelem",                               /* tp_name */
-		sizeof (BPy_Metaelem),                      /* tp_basicsize */
-		0,                                      /* tp_itemsize */
-		/* methods */
-		(destructor)MetaelemDeAlloc,              /* tp_dealloc */
-		0,                 /* tp_print */
-		(getattrfunc)MetaelemGetAttr,             /* tp_getattr */
-		(setattrfunc)MetaelemSetAttr,             /* tp_setattr */
-		0,                                      /* tp_compare */
-		(reprfunc)MetaelemRepr,                   /* tp_repr */
-		0,                                      /* tp_as_number */
-		0,                                      /* tp_as_sequence */
-		0,                                      /* tp_as_mapping */
-		0,                                      /* tp_as_hash */
-		0,0,0,0,0,0,
-		0,                                      /* tp_doc */ 
-		0,0,0,0,0,0,
-		BPy_Metaelem_methods,                       /* tp_methods */
-		0,                                      /* tp_members */
-	};
+PyTypeObject Metaball_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,	/* ob_size */
+	"Metaball",		/* tp_name */
+	sizeof( BPy_Metaball ),	/* tp_basicsize */
+	0,			/* tp_itemsize */
+	/* methods */
+	( destructor ) MetaballDeAlloc,	/* tp_dealloc */
+	0,			/* tp_print */
+	( getattrfunc ) MetaballGetAttr,	/* tp_getattr */
+	( setattrfunc ) MetaballSetAttr,	/* tp_setattr */
+	0,			/* tp_compare */
+	( reprfunc ) MetaballRepr,	/* tp_repr */
+	0,			/* tp_as_number */
+	0,			/* tp_as_sequence */
+	0,			/* tp_as_mapping */
+	0,			/* tp_as_hash */
+	0, 0, 0, 0, 0, 0,
+	0,			/* tp_doc */
+	0, 0, 0, 0, 0, 0,
+	BPy_Metaball_methods,	/* tp_methods */
+	0,			/* tp_members */
+};
+
+
+PyTypeObject Metaelem_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,	/* ob_size */
+	"Metaelem",		/* tp_name */
+	sizeof( BPy_Metaelem ),	/* tp_basicsize */
+	0,			/* tp_itemsize */
+	/* methods */
+	( destructor ) MetaelemDeAlloc,	/* tp_dealloc */
+	0,			/* tp_print */
+	( getattrfunc ) MetaelemGetAttr,	/* tp_getattr */
+	( setattrfunc ) MetaelemSetAttr,	/* tp_setattr */
+	0,			/* tp_compare */
+	( reprfunc ) MetaelemRepr,	/* tp_repr */
+	0,			/* tp_as_number */
+	0,			/* tp_as_sequence */
+	0,			/* tp_as_mapping */
+	0,			/* tp_as_hash */
+	0, 0, 0, 0, 0, 0,
+	0,			/* tp_doc */
+	0, 0, 0, 0, 0, 0,
+	BPy_Metaelem_methods,	/* tp_methods */
+	0,			/* tp_members */
+};
 
 /*****************************************************************************/
 /* Function:              M_Metaball_New                                     */
 /* Python equivalent:     Blender.Metaball.New                               */
 /*****************************************************************************/
-static PyObject *M_Metaball_New(PyObject *self, PyObject *args)
-{
-  char*name = 0;
-  BPy_Metaball    *pymball; /* for Data object wrapper in Python */
-  MetaBall      *blmball; /* for actual Data we create in Blender */
-  char        buf[21];
-  if (!PyArg_ParseTuple(args, "|s", &name))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-				   "expected string argument (or nothing)"));
-
-  blmball = add_mball(); /* first create the MetaBall Data in Blender */
-
-  if (blmball){ 
-    /* return user count to zero since add_mball() incref'ed it */
-    blmball->id.us = 0; 
-    /* now create the wrapper obj in Python */
-    pymball = (BPy_Metaball *)PyObject_NEW(BPy_Metaball, &Metaball_Type);
-  }
-  else
-    return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-				   "couldn't create MetaBall Data in Blender"));
-
-  if (pymball == NULL)
-    return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-				   "couldn't create MetaBall Data object"));
-
-  pymball->metaball = blmball; 
-  /*link Python mballer wrapper to Blender MetaBall */
-  if(name) { /* user gave us a name for the metaball, use it */
-    PyOS_snprintf(buf, sizeof(buf), "%s", name);
-    rename_id(&blmball->id, buf); 
-  }
-  return (PyObject *)pymball;
+static PyObject *M_Metaball_New( PyObject * self, PyObject * args )
+{
+	char *name = 0;
+	BPy_Metaball *pymball;	/* for Data object wrapper in Python */
+	MetaBall *blmball;	/* for actual Data we create in Blender */
+	char buf[21];
+	if( !PyArg_ParseTuple( args, "|s", &name ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected string argument (or nothing)" ) );
+
+	blmball = add_mball(  );	/* first create the MetaBall Data in Blender */
+
+	if( blmball ) {
+		/* return user count to zero since add_mball() incref'ed it */
+		blmball->id.us = 0;
+		/* now create the wrapper obj in Python */
+		pymball =
+			( BPy_Metaball * ) PyObject_NEW( BPy_Metaball,
+							 &Metaball_Type );
+	} else
+		return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
+						"couldn't create MetaBall Data in Blender" ) );
+
+	if( pymball == NULL )
+		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
+						"couldn't create MetaBall Data object" ) );
+
+	pymball->metaball = blmball;
+	/*link Python mballer wrapper to Blender MetaBall */
+	if( name ) {		/* user gave us a name for the metaball, use it */
+		PyOS_snprintf( buf, sizeof( buf ), "%s", name );
+		rename_id( &blmball->id, buf );
+	}
+	return ( PyObject * ) pymball;
 }
 
 
 /*****************************************************************************/
-/* Function:              M_Metaball_Get                                     */
-/* Python equivalent:     Blender.Metaball.Get                               */
-/* Description:           Receives a string and returns the metaball data obj */
-/*                        whose name matches the string.  If no argument is  */
-/*                        passed in, a list of all metaball data names in the */
-/*                        current scene is returned.                         */
+/* Function:             M_Metaball_Get                                     */
+/* Python equivalent:    Blender.Metaball.Get                               */
+/* Description:          Receives a string and returns the metaball data obj */
+/*                       whose name matches the string.  If no argument is  */
+/*                       passed in, a list of all metaball data names in the */
+/*                       current scene is returned.                         */
 /*****************************************************************************/
-static PyObject *M_Metaball_Get(PyObject *self, PyObject *args)
+static PyObject *M_Metaball_Get( PyObject * self, PyObject * args )
 {
-      char error_msg[64];
-  char   *name = NULL;
-  MetaBall *mball_iter;
-
-  if (!PyArg_ParseTuple(args, "|s", &name))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-				   "expected string argument (or nothing)"));
-
-  mball_iter = G.main->mball.first;
-
-  if (name) { /* (name) - Search mball by name */
-
-    BPy_Metaball *wanted_mball = NULL;
-
-    while ((mball_iter) && (wanted_mball == NULL)) {
-      if (strcmp (name, mball_iter->id.name+2) == 0) {
-	wanted_mball=(BPy_Metaball*)PyObject_NEW(BPy_Metaball,&Metaball_Type);
-	if (wanted_mball) 
-	  wanted_mball->metaball = mball_iter;
-      }
-      mball_iter = mball_iter->id.next;
-    }
+	char error_msg[64];
+	char *name = NULL;
+	MetaBall *mball_iter;
+
+	if( !PyArg_ParseTuple( args, "|s", &name ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected string argument (or nothing)" ) );
+
+	mball_iter = G.main->mball.first;
+
+	if( name ) {		/* (name) - Search mball by name */
+
+		BPy_Metaball *wanted_mball = NULL;
+
+		while( ( mball_iter ) && ( wanted_mball == NULL ) ) {
+			if( strcmp( name, mball_iter->id.name + 2 ) == 0 ) {
+				wanted_mball =
+					( BPy_Metaball * )
+					PyObject_NEW( BPy_Metaball,
+						      &Metaball_Type );
+				if( wanted_mball )
+					wanted_mball->metaball = mball_iter;
+			}
+			mball_iter = mball_iter->id.next;
+		}
 
-    if (wanted_mball == NULL) { /* Requested mball doesn't exist */
-      PyOS_snprintf(error_msg, sizeof(error_msg),
-		    "MetaBall \"%s\" not found", name);
-      return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
-    }
+		if( wanted_mball == NULL ) {	/* Requested mball doesn't exist */
+			PyOS_snprintf( error_msg, sizeof( error_msg ),
+				       "MetaBall \"%s\" not found", name );
+			return ( EXPP_ReturnPyObjError
+				 ( PyExc_NameError, error_msg ) );
+		}
 
-    return (PyObject *)wanted_mball;
-  }
+		return ( PyObject * ) wanted_mball;
+	}
 
-  else { /* () - return a list of all mballs in the scene */
-    PyObject *mballlist;
+	else {			/* () - return a list of all mballs in the scene */
+		PyObject *mballlist;
 
-    mballlist = PyList_New (0);
+		mballlist = PyList_New( 0 );
 
-    if (mballlist == NULL)
-      return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-				       "couldn't create PyList"));
+		if( mballlist == NULL )
+			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
+							"couldn't create PyList" ) );
 
-    while (mball_iter) {
-			BPy_Metaball *found_mball=(BPy_Metaball*)PyObject_NEW(BPy_Metaball,&Metaball_Type);
+		while( mball_iter ) {
+			BPy_Metaball *found_mball =
+				( BPy_Metaball * ) PyObject_NEW( BPy_Metaball,
+								 &Metaball_Type );
 			found_mball->metaball = mball_iter;
-      PyList_Append (mballlist,   (PyObject *)found_mball);
-      mball_iter = mball_iter->id.next;
-    }
+			PyList_Append( mballlist, ( PyObject * ) found_mball );
+			mball_iter = mball_iter->id.next;
+		}
 
-    return (mballlist);
-  }
+		return ( mballlist );
+	}
 
 }
 
-/******************************************************************************/
-/* Function:              Metaball_Init                                       */
-/******************************************************************************/
-PyObject *Metaball_Init (void)
+/****************************************************************************/
+/* Function:            Metaball_Init                                       */
+/****************************************************************************/
+PyObject *Metaball_Init( void )
 {
-  PyObject  *submodule;
+	PyObject *submodule;
 
-  Metaball_Type.ob_type = &PyType_Type;
+	Metaball_Type.ob_type = &PyType_Type;
 
-  submodule = Py_InitModule3("Blender.Metaball",
-			     M_Metaball_methods, M_Metaball_doc);
+	submodule = Py_InitModule3( "Blender.Metaball",
+				    M_Metaball_methods, M_Metaball_doc );
 
-  return (submodule);
+	return ( submodule );
 }
 
-int
-Metaball_CheckPyObject (PyObject * pyobj)
+int Metaball_CheckPyObject( PyObject * pyobj )
 {
-  return (pyobj->ob_type == &Metaball_Type);
+	return ( pyobj->ob_type == &Metaball_Type );
 }
 
 
-MetaBall * Metaball_FromPyObject (PyObject * pyobj)
+MetaBall *Metaball_FromPyObject( PyObject * pyobj )
 {
-  return ((BPy_Metaball *) pyobj)->metaball;
+	return ( ( BPy_Metaball * ) pyobj )->metaball;
 }
 
-/*******************************************************************************/
-/* Python BPy_Metaball methods:                                                  */
-/*******************************************************************************/
-void*MEM_callocN(unsigned int,char*);
-void allqueue(unsigned short,short);
+/***************************************************************************/
+/* Python BPy_Metaball methods:                                            */
+/***************************************************************************/
+void *MEM_callocN( unsigned int, char * );
+void allqueue( unsigned short, short );
 
-static PyObject *Metaball_addMetaelem(BPy_Metaball *self,PyObject*args)
+static PyObject *Metaball_addMetaelem( BPy_Metaball * self, PyObject * args )
 {
 	MetaElem *ml;
-	PyObject *listargs=0;
-	int type,lay;
-	float x,y,z,rad,s,expx,expy,expz;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-
-
-	type = PyInt_AsLong( PyList_GetItem(listargs,0));
-	x = PyFloat_AsDouble(PyList_GetItem(listargs,1));
-	y = PyFloat_AsDouble(PyList_GetItem(listargs,2));
-	z = PyFloat_AsDouble(PyList_GetItem(listargs,3));
-	rad = PyFloat_AsDouble(PyList_GetItem(listargs,4));
-	lay = PyInt_AsLong(PyList_GetItem(listargs,5));
-	s = PyFloat_AsDouble(PyList_GetItem(listargs,6));
-	expx = PyFloat_AsDouble(PyList_GetItem(listargs,7));
-	expy = PyFloat_AsDouble(PyList_GetItem(listargs,8));
-	expz = PyFloat_AsDouble(PyList_GetItem(listargs,9));
-
-	ml= MEM_callocN(sizeof(MetaElem), "metaelem");
-	BLI_addhead(&(self->metaball->elems), ml);
-
-	ml->x= x;ml->y= y;ml->z= z;
-	ml->rad= rad;
-	ml->lay= lay;
-	ml->s= s;
-	ml->flag= SELECT; 
+	PyObject *listargs = 0;
+	int type, lay;
+	float x, y, z, rad, s, expx, expy, expz;
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+
+
+	type = PyInt_AsLong( PyList_GetItem( listargs, 0 ) );
+	x = PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
+	y = PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
+	z = PyFloat_AsDouble( PyList_GetItem( listargs, 3 ) );
+	rad = PyFloat_AsDouble( PyList_GetItem( listargs, 4 ) );
+	lay = PyInt_AsLong( PyList_GetItem( listargs, 5 ) );
+	s = PyFloat_AsDouble( PyList_GetItem( listargs, 6 ) );
+	expx = PyFloat_AsDouble( PyList_GetItem( listargs, 7 ) );
+	expy = PyFloat_AsDouble( PyList_GetItem( listargs, 8 ) );
+	expz = PyFloat_AsDouble( PyList_GetItem( listargs, 9 ) );
+
+	ml = MEM_callocN( sizeof( MetaElem ), "metaelem" );
+	BLI_addhead( &( self->metaball->elems ), ml );
+
+	ml->x = x;
+	ml->y = y;
+	ml->z = z;
+	ml->rad = rad;
+	ml->lay = lay;
+	ml->s = s;
+	ml->flag = SELECT;
 	ml->type = type;
-  ml->expx= expx;ml->expy= expy;ml->expz= expz;
+	ml->expx = expx;
+	ml->expy = expy;
+	ml->expz = expz;
 	ml->type = type;
-	allqueue(0X4013, 0);
-	Py_INCREF(Py_None);
+	allqueue( 0X4013, 0 );
+	Py_INCREF( Py_None );
 	return Py_None;
 }
 
-static PyObject *Metaball_getName(BPy_Metaball *self)
+static PyObject *Metaball_getName( BPy_Metaball * self )
 {
 
-  PyObject *attr = PyString_FromString(self->metaball->id.name+2);
+	PyObject *attr = PyString_FromString( self->metaball->id.name + 2 );
 
-  if (attr) return attr;
+	if( attr )
+		return attr;
 
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-				 "couldn't get Metaball.name attribute"));
+	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
+					"couldn't get Metaball.name attribute" ) );
 }
 
 
 
-static PyObject *Metaball_setName(BPy_Metaball *self,PyObject*args)
+static PyObject *Metaball_setName( BPy_Metaball * self, PyObject * args )
 {
-	char   *name = NULL;
+	char *name = NULL;
 	char buf[20];
 
 
-	if (!PyArg_ParseTuple(args, "s", &name))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-																	 "expected string argument"));
-	PyOS_snprintf(buf, sizeof(buf), "%s", name);
-	rename_id(&self->metaball->id, buf); 
-	Py_INCREF(Py_None);
+	if( !PyArg_ParseTuple( args, "s", &name ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected string argument" ) );
+	PyOS_snprintf( buf, sizeof( buf ), "%s", name );
+	rename_id( &self->metaball->id, buf );
+	Py_INCREF( Py_None );
 	return Py_None;
 }
 
@@ -298,437 +309,523 @@ static PyObject *Metaball_setName(BPy_Metaball *self,PyObject*args)
 
 
 
-static PyObject *Metaball_getBbox(BPy_Metaball *self)
+static PyObject *Metaball_getBbox( BPy_Metaball * self )
 {
-	int i,j;
-	PyObject* ll;
-  PyObject* l = PyList_New(0);
-	if (self->metaball->bb == NULL) {Py_INCREF(Py_None);return Py_None;}
-	for(i = 0;i<8;i++)
-		{
-			ll = PyList_New(0);
-			for(j = 0;j<3;j++)
-				PyList_Append( ll, PyFloat_FromDouble(self->metaball->bb->vec[i][j]));
-			PyList_Append( l, ll);
-		}
+	int i, j;
+	PyObject *ll;
+	PyObject *l = PyList_New( 0 );
+	if( self->metaball->bb == NULL ) {
+		Py_INCREF( Py_None );
+		return Py_None;
+	}
+	for( i = 0; i < 8; i++ ) {
+		ll = PyList_New( 0 );
+		for( j = 0; j < 3; j++ )
+			PyList_Append( ll,
+				       PyFloat_FromDouble( self->metaball->bb->
+							   vec[i][j] ) );
+		PyList_Append( l, ll );
+	}
 
-  return l;
+	return l;
 }
 
-static PyObject *Metaball_getNMetaElems(BPy_Metaball *self)
+static PyObject *Metaball_getNMetaElems( BPy_Metaball * self )
 {
-  int i = 0;
-  MetaElem*ptr = self->metaball->elems.first;
-  if(!ptr) return (PyInt_FromLong(0) );
-  while(ptr)
-    {
-      i++;
-      ptr = ptr->next;
-    }
-  return (PyInt_FromLong(i) );
+	int i = 0;
+	MetaElem *ptr = self->metaball->elems.first;
+	if( !ptr )
+		return ( PyInt_FromLong( 0 ) );
+	while( ptr ) {
+		i++;
+		ptr = ptr->next;
+	}
+	return ( PyInt_FromLong( i ) );
 }
 
 
 
 
-static PyObject *Metaball_getloc(BPy_Metaball *self)
+static PyObject *Metaball_getloc( BPy_Metaball * self )
 {
-  PyObject* l = PyList_New(0);
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[0]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[1]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[2]));
-  return l;
+	PyObject *l = PyList_New( 0 );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[0] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[1] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[2] ) );
+	return l;
 }
 
-static PyObject *Metaball_setloc(BPy_Metaball *self,PyObject*args)
-{	
-	PyObject *listargs=0;
+static PyObject *Metaball_setloc( BPy_Metaball * self, PyObject * args )
+{
+	PyObject *listargs = 0;
 	int i;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-  if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	for(i=0;i<3;i++){
-		PyObject * xx = PyList_GetItem(listargs,i);
-		self->metaball->loc[i] = PyFloat_AsDouble(xx);
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	for( i = 0; i < 3; i++ ) {
+		PyObject *xx = PyList_GetItem( listargs, i );
+		self->metaball->loc[i] = PyFloat_AsDouble( xx );
 	}
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-static PyObject *Metaball_getrot(BPy_Metaball *self)
+static PyObject *Metaball_getrot( BPy_Metaball * self )
 {
-  PyObject* l = PyList_New(0);
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[0]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[1]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[2]));
-  return l;
+	PyObject *l = PyList_New( 0 );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[0] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[1] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[2] ) );
+	return l;
 }
 
-static PyObject *Metaball_setrot(BPy_Metaball *self,PyObject*args)
-{	
-	PyObject *listargs=0;
+static PyObject *Metaball_setrot( BPy_Metaball * self, PyObject * args )
+{
+	PyObject *listargs = 0;
 	int i;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-  if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	for(i=0;i<3;i++){
-		PyObject * xx = PyList_GetItem(listargs,i);
-		self->metaball->rot[i] = PyFloat_AsDouble(xx);
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	for( i = 0; i < 3; i++ ) {
+		PyObject *xx = PyList_GetItem( listargs, i );
+		self->metaball->rot[i] = PyFloat_AsDouble( xx );
 	}
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-static PyObject *Metaball_getsize(BPy_Metaball *self)
+static PyObject *Metaball_getsize( BPy_Metaball * self )
 {
-  PyObject* l = PyList_New(0); 
+	PyObject *l = PyList_New( 0 );
 
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->size[0]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->size[1]));
-  PyList_Append( l, PyFloat_FromDouble(self->metaball->size[2]));
-  return l;
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->size[0] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->size[1] ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaball->size[2] ) );
+	return l;
 }
 
 
 
 
-static PyObject *Metaball_getMetaElemList(BPy_Metaball *self)
-{	
+static PyObject *Metaball_getMetaElemList( BPy_Metaball * self )
+{
 	MetaElem *ptr;
-  PyObject* l = PyList_New(0);
-  ptr = self->metaball->elems.first;
-  if(!ptr)  return l ;
-	while(ptr)
-		{	
-BPy_Metaelem *found_melem=(BPy_Metaelem*)PyObject_NEW(BPy_Metaelem,&Metaelem_Type);
-			found_melem->metaelem = ptr;
-      PyList_Append (l,   (PyObject *)found_melem);
-			ptr = ptr->next;
-		}
-  return l;
+	PyObject *l = PyList_New( 0 );
+	ptr = self->metaball->elems.first;
+	if( !ptr )
+		return l;
+	while( ptr ) {
+		BPy_Metaelem *found_melem =
+			( BPy_Metaelem * ) PyObject_NEW( BPy_Metaelem,
+							 &Metaelem_Type );
+		found_melem->metaelem = ptr;
+		PyList_Append( l, ( PyObject * ) found_melem );
+		ptr = ptr->next;
+	}
+	return l;
 }
 
 
-static PyObject *Metaball_setsize(BPy_Metaball *self,PyObject*args)
-{	
-	PyObject *listargs=0;
+static PyObject *Metaball_setsize( BPy_Metaball * self, PyObject * args )
+{
+	PyObject *listargs = 0;
 	int i;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-  if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	for(i=0;i<3;i++){
-		PyObject * xx = PyList_GetItem(listargs,i);
-		self->metaball->size[i] = PyFloat_AsDouble(xx);
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	for( i = 0; i < 3; i++ ) {
+		PyObject *xx = PyList_GetItem( listargs, i );
+		self->metaball->size[i] = PyFloat_AsDouble( xx );
 	}
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-static PyObject *Metaball_getWiresize(BPy_Metaball *self)
+static PyObject *Metaball_getWiresize( BPy_Metaball * self )
 {
-  return PyFloat_FromDouble(self->metaball->wiresize);
+	return PyFloat_FromDouble( self->metaball->wiresize );
 }
 
-static PyObject *Metaball_setWiresize(BPy_Metaball *self,PyObject*args)
-{	
-	
-  float val;
-  if (!PyArg_ParseTuple(args, "f", &val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args"));
- 
-  self->metaball->wiresize = val;
+static PyObject *Metaball_setWiresize( BPy_Metaball * self, PyObject * args )
+{
+
+	float val;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected float args" ) );
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	self->metaball->wiresize = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
 
 }
-static PyObject *Metaball_getRendersize(BPy_Metaball *self)
+static PyObject *Metaball_getRendersize( BPy_Metaball * self )
 {
-  return PyFloat_FromDouble(self->metaball->rendersize);
+	return PyFloat_FromDouble( self->metaball->rendersize );
 }
 
-static PyObject *Metaball_setRendersize(BPy_Metaball *self,PyObject*args)
-{	
-	
-  float val;
-  if (!PyArg_ParseTuple(args, "f", &val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args"));
- 
-  self->metaball->rendersize = val;
+static PyObject *Metaball_setRendersize( BPy_Metaball * self, PyObject * args )
+{
+
+	float val;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected float args" ) );
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	self->metaball->rendersize = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
 
 }
-static PyObject *Metaball_getThresh(BPy_Metaball *self)
+static PyObject *Metaball_getThresh( BPy_Metaball * self )
 {
-  return PyFloat_FromDouble(self->metaball->thresh);
+	return PyFloat_FromDouble( self->metaball->thresh );
 }
 
-static PyObject *Metaball_setThresh(BPy_Metaball *self,PyObject*args)
-{	
-	
-  float val;
-  if (!PyArg_ParseTuple(args, "f", &val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args"));
- 
-  self->metaball->thresh = val;
+static PyObject *Metaball_setThresh( BPy_Metaball * self, PyObject * args )
+{
+
+	float val;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected float args" ) );
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	self->metaball->thresh = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
 
 }
 
 
-/*******************************************************************************/
-/* get/set metaelems data,                                                     */
-/*******************************************************************************/
+/**************************************************************************/
+/* get/set metaelems data,                                                */
+/***************************************************************************/
 
-static PyObject *Metaball_getMetadata(BPy_Metaball *self,PyObject*args)
-{	
-  int num;
-  int i = 0;
-  char*name = NULL;
+static PyObject *Metaball_getMetadata( BPy_Metaball * self, PyObject * args )
+{
+	int num;
+	int i = 0;
+	char *name = NULL;
 	MetaElem *ptr;
 
-  if (!PyArg_ParseTuple(args, "si", &name,&num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, \
-				   "expected (string int) argument"));
-  /*jump to the num-th MetaElem*/
-  ptr = self->metaball->elems.first;
-  if(!ptr) 
-    return  (EXPP_ReturnPyObjError (PyExc_TypeError, "no metaelem found"));
-  for(i = 0;i<num;i++)
-    {
-      if(!ptr) 
-	return  (EXPP_ReturnPyObjError (PyExc_TypeError, "metaelem not found"));
-      ptr = ptr->next;
-    }
-  if(!strcmp(name,"type"))
-    return (PyInt_FromLong(ptr->type));
-  if(!strcmp(name,"x"))
-    return (PyFloat_FromDouble(ptr->x));
-  if(!strcmp(name,"y"))
-    return (PyFloat_FromDouble(ptr->y));
-  if(!strcmp(name,"z"))
-    return (PyFloat_FromDouble(ptr->z));
-  if(!strcmp(name,"expx"))
-    return (PyFloat_FromDouble(ptr->expx));
-  if(!strcmp(name,"expy"))
-    return (PyFloat_FromDouble(ptr->expy));
-  if(!strcmp(name,"expz"))
-    return (PyFloat_FromDouble(ptr->expz));
-  if(!strcmp(name,"rad"))
-    return (PyFloat_FromDouble(ptr->rad));
-  if(!strcmp(name,"rad2"))
-    return (PyFloat_FromDouble(ptr->rad2));
-  if(!strcmp(name,"s"))
-    return (PyFloat_FromDouble(ptr->s));
-  if(!strcmp(name,"len"))
-    return (PyFloat_FromDouble(ptr->len));
-
-  return (EXPP_ReturnPyObjError (PyExc_TypeError, "unknown name "));
-}
-
-
-
-static PyObject *Metaball_setMetadata(BPy_Metaball *self,PyObject*args)
-{	
-  int num;
-  int i = 0;
-  char*name = NULL;
-  int intval=-1;
-  float floatval=0;
+	if( !PyArg_ParseTuple( args, "si", &name, &num ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected (string int) argument" ) );
+	/*jump to the num-th MetaElem */
+	ptr = self->metaball->elems.first;
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "no metaelem found" ) );
+	for( i = 0; i < num; i++ ) {
+		if( !ptr )
+			return ( EXPP_ReturnPyObjError
+				 ( PyExc_TypeError, "metaelem not found" ) );
+		ptr = ptr->next;
+	}
+	if( !strcmp( name, "type" ) )
+		return ( PyInt_FromLong( ptr->type ) );
+	if( !strcmp( name, "x" ) )
+		return ( PyFloat_FromDouble( ptr->x ) );
+	if( !strcmp( name, "y" ) )
+		return ( PyFloat_FromDouble( ptr->y ) );
+	if( !strcmp( name, "z" ) )
+		return ( PyFloat_FromDouble( ptr->z ) );
+	if( !strcmp( name, "expx" ) )
+		return ( PyFloat_FromDouble( ptr->expx ) );
+	if( !strcmp( name, "expy" ) )
+		return ( PyFloat_FromDouble( ptr->expy ) );
+	if( !strcmp( name, "expz" ) )
+		return ( PyFloat_FromDouble( ptr->expz ) );
+	if( !strcmp( name, "rad" ) )
+		return ( PyFloat_FromDouble( ptr->rad ) );
+	if( !strcmp( name, "rad2" ) )
+		return ( PyFloat_FromDouble( ptr->rad2 ) );
+	if( !strcmp( name, "s" ) )
+		return ( PyFloat_FromDouble( ptr->s ) );
+	if( !strcmp( name, "len" ) )
+		return ( PyFloat_FromDouble( ptr->len ) );
+
+	return ( EXPP_ReturnPyObjError( PyExc_TypeError, "unknown name " ) );
+}
+
+
+
+static PyObject *Metaball_setMetadata( BPy_Metaball * self, PyObject * args )
+{
+	int num;
+	int i = 0;
+	char *name = NULL;
+	int intval = -1;
+	float floatval = 0;
 	MetaElem *ptr;
 
-  if (!PyArg_ParseTuple(args, "sif", &name,&num,&floatval))
-return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected string, int, float arguments"));
-	intval = (int)floatval;
-	printf("%f %d %s %d\n",floatval,intval,name,num);
-  /*jump to the num-th MetaElem*/
-  ptr = self->metaball->elems.first;
-  if(!ptr) 
-    return  (EXPP_ReturnPyObjError (PyExc_TypeError, "metaelem not found"));
-  for(i = 0;i<num;i++)
-    {
-      if(!ptr) 
-	return  (EXPP_ReturnPyObjError (PyExc_TypeError, "metaelem not found"));
-      ptr = ptr->next;
-    }
-  if(!strcmp(name,"type"))
-    {ptr->type=intval;return (PyInt_FromLong(intval));}
-  if(!strcmp(name,"x"))
-    {ptr->x=floatval;printf("%p %f\n",ptr,floatval);return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"y"))
-    {ptr->y=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"z"))
-    {ptr->z=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"expx"))
-    {ptr->expx=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"expy"))
-    {ptr->expy=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"expz"))
-    {ptr->expz=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"rad"))
-    {ptr->rad=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"rad2"))
-    {ptr->rad2=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"s"))
-    {ptr->s=floatval;return (PyFloat_FromDouble(floatval));}
-  if(!strcmp(name,"len"))
-    {ptr->len=floatval;return (PyFloat_FromDouble(floatval));}
-
-  return (EXPP_ReturnPyObjError (PyExc_TypeError, "unknown field "));
-}
-
-static PyObject *Metaball_getMetatype(BPy_Metaball *self,PyObject*args)
-{	
-  int num;
-  int i = 0;
-  MetaElem*ptr = self->metaball->elems.first;
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, \
-				   "expected int argument"));
-  if(!ptr) return (PyInt_FromLong(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyInt_FromLong(ptr->type));
-}
-
-
-
-static PyObject *Metaball_setMetatype(BPy_Metaball *self,PyObject*args)
-{	
-  int num,val, i = 0;
-  MetaElem*ptr = self->metaball->elems.first;
-  if (!PyArg_ParseTuple(args, "ii", &num,&val))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int int arguments"));
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->type = val;
-
-  Py_INCREF(Py_None);
-  return Py_None;
-
-}
-
-
-static PyObject *Metaball_getMetax(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num;
-  int i = 0;
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"));
-  if(!ptr) return (PyFloat_FromDouble(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyFloat_FromDouble(ptr->x));
-}
-
-
-
-static PyObject *Metaball_setMetax(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num, i = 0;
-  float val;
-  if (!PyArg_ParseTuple(args, "if", &num,&val))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int float args"));
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->x = val;
-
-  Py_INCREF(Py_None);
-  return Py_None;
-
-}
-static PyObject *Metaball_getMetay(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num;
-  int i = 0;
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"));
-  if(!ptr) return (PyFloat_FromDouble(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyFloat_FromDouble(ptr->y));
+	if( !PyArg_ParseTuple( args, "sif", &name, &num, &floatval ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected string, int, float arguments" ) );
+	intval = ( int ) floatval;
+	printf( "%f %d %s %d\n", floatval, intval, name, num );
+	/*jump to the num-th MetaElem */
+	ptr = self->metaball->elems.first;
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "metaelem not found" ) );
+	for( i = 0; i < num; i++ ) {
+		if( !ptr )
+			return ( EXPP_ReturnPyObjError
+				 ( PyExc_TypeError, "metaelem not found" ) );
+		ptr = ptr->next;
+	}
+	if( !strcmp( name, "type" ) ) {
+		ptr->type = intval;
+		return ( PyInt_FromLong( intval ) );
+	}
+	if( !strcmp( name, "x" ) ) {
+		ptr->x = floatval;
+		printf( "%p %f\n", ptr, floatval );
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "y" ) ) {
+		ptr->y = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "z" ) ) {
+		ptr->z = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "expx" ) ) {
+		ptr->expx = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "expy" ) ) {
+		ptr->expy = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "expz" ) ) {
+		ptr->expz = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "rad" ) ) {
+		ptr->rad = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "rad2" ) ) {
+		ptr->rad2 = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "s" ) ) {
+		ptr->s = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+	if( !strcmp( name, "len" ) ) {
+		ptr->len = floatval;
+		return ( PyFloat_FromDouble( floatval ) );
+	}
+
+	return ( EXPP_ReturnPyObjError( PyExc_TypeError, "unknown field " ) );
+}
+
+static PyObject *Metaball_getMetatype( BPy_Metaball * self, PyObject * args )
+{
+	int num;
+	int i = 0;
+	MetaElem *ptr = self->metaball->elems.first;
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected int argument" ) );
+	if( !ptr )
+		return ( PyInt_FromLong( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyInt_FromLong( ptr->type ) );
+}
+
+
+
+static PyObject *Metaball_setMetatype( BPy_Metaball * self, PyObject * args )
+{
+	int num, val, i = 0;
+	MetaElem *ptr = self->metaball->elems.first;
+	if( !PyArg_ParseTuple( args, "ii", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int int arguments" ) );
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->type = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
+
 }
 
 
+static PyObject *Metaball_getMetax( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num;
+	int i = 0;
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int argument" ) );
+	if( !ptr )
+		return ( PyFloat_FromDouble( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyFloat_FromDouble( ptr->x ) );
+}
 
-static PyObject *Metaball_setMetay(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num, i = 0;
-  float val;
-  if (!PyArg_ParseTuple(args, "if", &num,&val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args"));
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->y = val;
 
-  Py_INCREF(Py_None);
-  return Py_None;
 
+static PyObject *Metaball_setMetax( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num, i = 0;
+	float val;
+	if( !PyArg_ParseTuple( args, "if", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int float args" ) );
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->x = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
+
+}
+static PyObject *Metaball_getMetay( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num;
+	int i = 0;
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int argument" ) );
+	if( !ptr )
+		return ( PyFloat_FromDouble( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyFloat_FromDouble( ptr->y ) );
 }
 
 
-static PyObject *Metaball_getMetaz(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num;
-  int i = 0;
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"));
-  if(!ptr) return (PyFloat_FromDouble(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyFloat_FromDouble(ptr->z));
+
+static PyObject *Metaball_setMetay( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num, i = 0;
+	float val;
+	if( !PyArg_ParseTuple( args, "if", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int float args" ) );
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->y = val;
+
+	Py_INCREF( Py_None );
+	return Py_None;
+
+}
+
+
+static PyObject *Metaball_getMetaz( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num;
+	int i = 0;
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int argument" ) );
+	if( !ptr )
+		return ( PyFloat_FromDouble( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyFloat_FromDouble( ptr->z ) );
 }
 
-static PyObject *Metaball_setMetaz(BPy_Metaball *self,PyObject*args)
-{	
-  int num, i = 0;
-  MetaElem*ptr = self->metaball->elems.first;
-  float val;
-  if (!PyArg_ParseTuple(args, "if", &num,&val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args"));
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->z = val;
+static PyObject *Metaball_setMetaz( BPy_Metaball * self, PyObject * args )
+{
+	int num, i = 0;
+	MetaElem *ptr = self->metaball->elems.first;
+	float val;
+	if( !PyArg_ParseTuple( args, "if", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int float args" ) );
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->z = val;
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 
 }
 
 
-static PyObject *Metaball_getMetas(BPy_Metaball *self,PyObject*args)
-{	
-  MetaElem*ptr = self->metaball->elems.first;
-  int num;
-  int i = 0;
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"));
-  if(!ptr) return (PyFloat_FromDouble(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyFloat_FromDouble(ptr->s));
+static PyObject *Metaball_getMetas( BPy_Metaball * self, PyObject * args )
+{
+	MetaElem *ptr = self->metaball->elems.first;
+	int num;
+	int i = 0;
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int argument" ) );
+	if( !ptr )
+		return ( PyFloat_FromDouble( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyFloat_FromDouble( ptr->s ) );
 }
 
-static PyObject *Metaball_setMetas(BPy_Metaball *self,PyObject*args)
-{	
-  int num, i = 0;
-  MetaElem*ptr = self->metaball->elems.first;
-  float val;
-  if (!PyArg_ParseTuple(args, "if", &num,&val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args"));
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->s = val;
+static PyObject *Metaball_setMetas( BPy_Metaball * self, PyObject * args )
+{
+	int num, i = 0;
+	MetaElem *ptr = self->metaball->elems.first;
+	float val;
+	if( !PyArg_ParseTuple( args, "if", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int float args" ) );
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->s = val;
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 
 }
 
@@ -737,58 +834,67 @@ static PyObject *Metaball_setMetas(BPy_Metaball *self,PyObject*args)
 
 
 
-static PyObject *Metaball_getMetalen(BPy_Metaball *self,PyObject*args)
-{	
-  int num;
-  int i = 0;
+static PyObject *Metaball_getMetalen( BPy_Metaball * self, PyObject * args )
+{
+	int num;
+	int i = 0;
 	MetaElem *ptr;
 
-  if (!PyArg_ParseTuple(args, "i", &num))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"));
-  ptr = self->metaball->elems.first;
-  if(!ptr) return (PyFloat_FromDouble(0));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  return (PyFloat_FromDouble(ptr->len));
+	if( !PyArg_ParseTuple( args, "i", &num ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int argument" ) );
+	ptr = self->metaball->elems.first;
+	if( !ptr )
+		return ( PyFloat_FromDouble( 0 ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	return ( PyFloat_FromDouble( ptr->len ) );
 }
 
-static PyObject *Metaball_setMetalen(BPy_Metaball *self,PyObject*args)
-{	
-  int num, i = 0;
-  float val;
+static PyObject *Metaball_setMetalen( BPy_Metaball * self, PyObject * args )
+{
+	int num, i = 0;
+	float val;
 	MetaElem *ptr;
 
-  if (!PyArg_ParseTuple(args, "if", &num,&val))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args"));
-  ptr = self->metaball->elems.first;
-  if(!ptr)  return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem"));
-  for(i = 0;i<num;i++){ptr = ptr->next;}
-  ptr->len = val;
+	if( !PyArg_ParseTuple( args, "if", &num, &val ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected int float args" ) );
+	ptr = self->metaball->elems.first;
+	if( !ptr )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "No MetaElem" ) );
+	for( i = 0; i < num; i++ ) {
+		ptr = ptr->next;
+	}
+	ptr->len = val;
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
 
 
 /*****************************************************************************/
 /* Function:    MetaballDeAlloc                                              */
-/* Description: This is a callback function for the BPy_Metaball type. It is   */
+/* Description: This is a callback function for the BPy_Metaball type. It is */
 /*              the destructor function.                                     */
 /*****************************************************************************/
-static void MetaballDeAlloc (BPy_Metaball *self)
+static void MetaballDeAlloc( BPy_Metaball * self )
 {
-  PyObject_DEL (self);
+	PyObject_DEL( self );
 }
 
 
 /*****************************************************************************/
 /* Function:    MetaelemDeAlloc                                              */
-/* Description: This is a callback function for the BPy_Metaelem type. It is   */
+/* Description: This is a callback function for the BPy_Metaelem type. It is */
 /*              the destructor function.                                     */
 /*****************************************************************************/
-static void MetaelemDeAlloc (BPy_Metaelem *self)
+static void MetaelemDeAlloc( BPy_Metaelem * self )
 {
-  PyObject_DEL (self);
+	PyObject_DEL( self );
 }
 
 
@@ -796,58 +902,60 @@ static void MetaelemDeAlloc (BPy_Metaelem *self)
 
 /*****************************************************************************/
 /* Function:    MetaballGetAttr                                              */
-/* Description: This is a callback function for the BPy_Metaball type. It is   */
-/*              the function that accesses BPy_Metaball "member variables" and */
-/*              methods.                                                     */
+/* Description: This is a callback function for the BPy_Metaball type. It is */
+/*              the function that accesses BPy_Metaball "member variables" */
+/*              and   methods.                                               */
 /*****************************************************************************/
-static PyObject *MetaballGetAttr (BPy_Metaball *self, char *name)
+static PyObject *MetaballGetAttr( BPy_Metaball * self, char *name )
 {
 
-if (strcmp (name, "name") == 0)return  Metaball_getName (self);
-if (strcmp (name, "rot") == 0)return  Metaball_getrot (self);
-if (strcmp (name, "loc") == 0)return  Metaball_getloc (self);
-if (strcmp (name, "size") == 0)return  Metaball_getsize (self);
-  return Py_FindMethod(BPy_Metaball_methods, (PyObject *)self, name);
+	if( strcmp( name, "name" ) == 0 )
+		return Metaball_getName( self );
+	if( strcmp( name, "rot" ) == 0 )
+		return Metaball_getrot( self );
+	if( strcmp( name, "loc" ) == 0 )
+		return Metaball_getloc( self );
+	if( strcmp( name, "size" ) == 0 )
+		return Metaball_getsize( self );
+	return Py_FindMethod( BPy_Metaball_methods, ( PyObject * ) self,
+			      name );
 }
 
 
 
-/*******************************************************************************/
-/* Function:    MetaballSetAttr                                                */
-/* Description: This is a callback function for the BPy_Metaball type. It is the */
-/*              function that sets Metaball Data attributes (member variables).*/
-/*******************************************************************************/
-static int MetaballSetAttr (BPy_Metaball *self, char *name, PyObject *value)
+/****************************************************************************/
+/* Function:    MetaballSetAttr                                             */
+/* Description: This is a callback function for the BPy_Metaball type.      */
+/*              It sets Metaball Data attributes       (member variables).*/
+/****************************************************************************/
+static int MetaballSetAttr( BPy_Metaball * self, char *name, PyObject * value )
 {
-  PyObject *valtuple  = Py_BuildValue("(O)", value);
+	PyObject *valtuple = Py_BuildValue( "(O)", value );
 
-  if (!valtuple) 
-    return EXPP_ReturnIntError(PyExc_MemoryError,
-															 "MetaballSetAttr: couldn't create PyTuple");
+	if( !valtuple )
+		return EXPP_ReturnIntError( PyExc_MemoryError,
+					    "MetaballSetAttr: couldn't create PyTuple" );
 
-  if (strcmp (name, "name") == 0) 
-		{
-			Metaball_setName (self, valtuple);
-			return 0;
-		}
+	if( strcmp( name, "name" ) == 0 ) {
+		Metaball_setName( self, valtuple );
+		return 0;
+	}
 
-  if (strcmp (name, "rot") == 0)
-		{
-			Metaball_setrot (self, valtuple);
-			return 0;
-		}
-  if (strcmp (name, "loc") == 0)
-		{
-			Metaball_setloc (self, valtuple);
-			return 0;
-		}
- 
-  if (strcmp (name, "size") == 0)
-		{
-			Metaball_setsize (self, valtuple);
-			return 0;
-		}
-  return (EXPP_ReturnIntError (PyExc_KeyError,"attribute not found"));
+	if( strcmp( name, "rot" ) == 0 ) {
+		Metaball_setrot( self, valtuple );
+		return 0;
+	}
+	if( strcmp( name, "loc" ) == 0 ) {
+		Metaball_setloc( self, valtuple );
+		return 0;
+	}
+
+	if( strcmp( name, "size" ) == 0 ) {
+		Metaball_setsize( self, valtuple );
+		return 0;
+	}
+	return ( EXPP_ReturnIntError
+		 ( PyExc_KeyError, "attribute not found" ) );
 }
 
 
@@ -857,133 +965,142 @@ static int MetaballSetAttr (BPy_Metaball *self, char *name, PyObject *value)
 
 
 
-static PyObject *Metaelem_getdims(BPy_Metaelem *self)
+static PyObject *Metaelem_getdims( BPy_Metaelem * self )
 {
-  PyObject* l = PyList_New(0);
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->expx));
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->expy));
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->expz));
-  return l;
+	PyObject *l = PyList_New( 0 );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->expx ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->expy ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->expz ) );
+	return l;
 }
 
 
-static PyObject *Metaelem_setdims(BPy_Metaelem *self,PyObject*args)
+static PyObject *Metaelem_setdims( BPy_Metaelem * self, PyObject * args )
 {
 
-	PyObject *listargs=0;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-  if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	self->metaelem->expx = PyFloat_AsDouble(PyList_GetItem(listargs,0));
-	self->metaelem->expy = PyFloat_AsDouble(PyList_GetItem(listargs,1));
-	self->metaelem->expz = PyFloat_AsDouble(PyList_GetItem(listargs,2));
-  Py_INCREF(Py_None);
-  return Py_None;
+	PyObject *listargs = 0;
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	self->metaelem->expx =
+		PyFloat_AsDouble( PyList_GetItem( listargs, 0 ) );
+	self->metaelem->expy =
+		PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
+	self->metaelem->expz =
+		PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
 
 
-static PyObject *Metaelem_getcoords(BPy_Metaelem *self)
+static PyObject *Metaelem_getcoords( BPy_Metaelem * self )
 {
-  PyObject* l = PyList_New(0);
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->x));
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->y));
-  PyList_Append( l, PyFloat_FromDouble(self->metaelem->z));
-  return l;
+	PyObject *l = PyList_New( 0 );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->x ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->y ) );
+	PyList_Append( l, PyFloat_FromDouble( self->metaelem->z ) );
+	return l;
 }
 
 
-static PyObject *Metaelem_setcoords(BPy_Metaelem *self,PyObject*args)
+static PyObject *Metaelem_setcoords( BPy_Metaelem * self, PyObject * args )
 {
 
-	PyObject *listargs=0;
-  if (!PyArg_ParseTuple(args, "O", &listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-  if (!PyList_Check(listargs))
-    return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected a list"));
-	self->metaelem->x = PyFloat_AsDouble(PyList_GetItem(listargs,0));
-	self->metaelem->y = PyFloat_AsDouble(PyList_GetItem(listargs,1));
-	self->metaelem->z = PyFloat_AsDouble(PyList_GetItem(listargs,2));
-  Py_INCREF(Py_None);
-  return Py_None;
+	PyObject *listargs = 0;
+	if( !PyArg_ParseTuple( args, "O", &listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	if( !PyList_Check( listargs ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected a list" ) );
+	self->metaelem->x = PyFloat_AsDouble( PyList_GetItem( listargs, 0 ) );
+	self->metaelem->y = PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
+	self->metaelem->z = PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
 
+/***************************************************************************/
+/* Function:    MetaelemGetAttr                                          */
+/* Description: This is a callback function for the BPy_Metaelem type.   */
+/*              It  accesses BPy_Metaelem "member variables".            */
 /*****************************************************************************/
-/* Function:    MetaelemGetAttr                                              */
-/* Description: This is a callback function for the BPy_Metaelem type. It is   */
-/*              the function that accesses BPy_Metaelem "member variables" and */
-/*              methods.                                                     */
-/*****************************************************************************/
-static PyObject *MetaelemGetAttr (BPy_Metaelem *self, char *name)
+static PyObject *MetaelemGetAttr( BPy_Metaelem * self, char *name )
 {
 
-if (!strcmp (name, "dims") )return  Metaelem_getdims (self);
-if (!strcmp (name, "coords") )return  Metaelem_getcoords (self);
-if (!strcmp (name, "rad") )return  PyFloat_FromDouble(self->metaelem->rad);
-if (!strcmp (name, "stif") )return  PyFloat_FromDouble(self->metaelem->s);
-  return Py_FindMethod(BPy_Metaelem_methods, (PyObject *)self, name);
+	if( !strcmp( name, "dims" ) )
+		return Metaelem_getdims( self );
+	if( !strcmp( name, "coords" ) )
+		return Metaelem_getcoords( self );
+	if( !strcmp( name, "rad" ) )
+		return PyFloat_FromDouble( self->metaelem->rad );
+	if( !strcmp( name, "stif" ) )
+		return PyFloat_FromDouble( self->metaelem->s );
+	return Py_FindMethod( BPy_Metaelem_methods, ( PyObject * ) self,
+			      name );
 }
 
 
 
-/*******************************************************************************/
-/* Function:    MetaelemSetAttr                                                */
-/* Description: This is a callback function for the BPy_Metaelem type. It is the */
-/*              function that sets Metaelem Data attributes (member variables).*/
-/*******************************************************************************/
-static int MetaelemSetAttr (BPy_Metaelem *self, char *name, PyObject *value)
+/*****************************************************************************/
+/* Function:    MetaelemSetAttr                                            */
+/* Description: This is a callback function for the BPy_Metaelem type.   */
+/*               It sets Metaelem Data attributes (member variables).      */
+/****************************************************************************/
+static int MetaelemSetAttr( BPy_Metaelem * self, char *name, PyObject * value )
 {
- 
-  if (!strcmp (name, "coords")) 
-		{ 
-PyObject *valtuple  = Py_BuildValue("(O)", value);
-  if (!valtuple) 
-		return EXPP_ReturnIntError(PyExc_MemoryError,"MetaelemSetAttr: couldn't create PyTuple");
-			Metaelem_setcoords (self, valtuple);
-			return 0;
-		}
-  if (!strcmp (name, "dims")) 
-		{ 
-PyObject *valtuple  = Py_BuildValue("(O)", value);
-  if (!valtuple) 
-		return EXPP_ReturnIntError(PyExc_MemoryError,"MetaelemSetAttr: couldn't create PyTuple");
-			Metaelem_setdims (self, valtuple);
-			return 0;
-		}
-  if (!strcmp (name, "rad")) 
-		{
-			self->metaelem->rad = PyFloat_AsDouble(value);
-			return 0;
-		}
-  if (!strcmp (name, "stif")) 
-		{
-			self->metaelem->s = PyFloat_AsDouble(value);
-			return 0;
-		}
-  return (EXPP_ReturnIntError (PyExc_KeyError,"attribute not found"));
+
+	if( !strcmp( name, "coords" ) ) {
+		PyObject *valtuple = Py_BuildValue( "(O)", value );
+		if( !valtuple )
+			return EXPP_ReturnIntError( PyExc_MemoryError,
+						    "MetaelemSetAttr: couldn't create PyTuple" );
+		Metaelem_setcoords( self, valtuple );
+		return 0;
+	}
+	if( !strcmp( name, "dims" ) ) {
+		PyObject *valtuple = Py_BuildValue( "(O)", value );
+		if( !valtuple )
+			return EXPP_ReturnIntError( PyExc_MemoryError,
+						    "MetaelemSetAttr: couldn't create PyTuple" );
+		Metaelem_setdims( self, valtuple );
+		return 0;
+	}
+	if( !strcmp( name, "rad" ) ) {
+		self->metaelem->rad = PyFloat_AsDouble( value );
+		return 0;
+	}
+	if( !strcmp( name, "stif" ) ) {
+		self->metaelem->s = PyFloat_AsDouble( value );
+		return 0;
+	}
+	return ( EXPP_ReturnIntError
+		 ( PyExc_KeyError, "attribute not found" ) );
 }
 
-/*****************************************************************************/
-/* Function:    MetaballRepr                                                  */
-/* Description: This is a callback function for the BPy_Metaball type. It       */
-/*              builds a meaninful string to represent metaball objects.      */
-/*****************************************************************************/
-static PyObject *MetaballRepr (BPy_Metaball *self)
+/****************************************************************************/
+/* Function:    MetaballRepr                                                */
+/* Description: This is a callback function for the BPy_Metaball type. It   */
+/*              builds a meaninful string to represent metaball objects.    */
+/****************************************************************************/
+static PyObject *MetaballRepr( BPy_Metaball * self )
 {
-  return PyString_FromFormat("[Metaball \"%s\"]", self->metaball->id.name+2);
+	return PyString_FromFormat( "[Metaball \"%s\"]",
+				    self->metaball->id.name + 2 );
 }
 
 
+/****************************************************************************/
+/* Function:    MetaelemRepr                                               */
+/* Description: This is a callback function for the BPy_Metaelem type. It   */
+/*              builds a meaninful string to represent metaelem objects.    */
 /*****************************************************************************/
-/* Function:    MetaelemRepr                                                  */
-/* Description: This is a callback function for the BPy_Metaelem type. It       */
-/*              builds a meaninful string to represent metaelem objects.      */
-/*****************************************************************************/
-static PyObject *MetaelemRepr (BPy_Metaelem *self)
+static PyObject *MetaelemRepr( BPy_Metaelem * self )
 {
-  return PyString_FromString("Metaelem");
+	return PyString_FromString( "Metaelem" );
 }
-
-