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, 374 insertions, 351 deletions

diff --git a/source/blender/python/api2_2x/Wave.c b/source/blender/python/api2_2x/Wave.c
index 22a88e14bf0..2b73c025251 100644
--- a/source/blender/python/api2_2x/Wave.c
+++ b/source/blender/python/api2_2x/Wave.c
@@ -35,56 +35,56 @@
 
 
 /*****************************************************************************/
-/* Python BPy_Wave methods table:                                              */
+/* Python BPy_Wave methods table:                                            */
 /*****************************************************************************/
 static PyMethodDef BPy_Wave_methods[] = {
-	{"getType", (PyCFunction)Effect_getType,
-	 METH_NOARGS,"() - Return Effect type"},
-  {"setType", (PyCFunction)Effect_setType, 
-   METH_VARARGS,"() - Set Effect type"},
-  {"getFlag", (PyCFunction)Effect_getFlag, 
-   METH_NOARGS,"() - Return Effect flag"},
-  {"setFlag", (PyCFunction)Effect_setFlag, 
-   METH_VARARGS,"() - Set Effect flag"},
-  {"getStartx",(PyCFunction)Wave_getStartx,
-	 METH_NOARGS,"()-Return Wave startx"},
-  {"setStartx",(PyCFunction)Wave_setStartx, METH_VARARGS,
+	{"getType", ( PyCFunction ) Effect_getType,
+	 METH_NOARGS, "() - Return Effect type"},
+	{"setType", ( PyCFunction ) Effect_setType,
+	 METH_VARARGS, "() - Set Effect type"},
+	{"getFlag", ( PyCFunction ) Effect_getFlag,
+	 METH_NOARGS, "() - Return Effect flag"},
+	{"setFlag", ( PyCFunction ) Effect_setFlag,
+	 METH_VARARGS, "() - Set Effect flag"},
+	{"getStartx", ( PyCFunction ) Wave_getStartx,
+	 METH_NOARGS, "()-Return Wave startx"},
+	{"setStartx", ( PyCFunction ) Wave_setStartx, METH_VARARGS,
 	 "()- Sets Wave startx"},
-  {"getStarty",(PyCFunction)Wave_getStarty,
-	 METH_NOARGS,"()-Return Wave starty"},
-  {"setStarty",(PyCFunction)Wave_setStarty, METH_VARARGS,
+	{"getStarty", ( PyCFunction ) Wave_getStarty,
+	 METH_NOARGS, "()-Return Wave starty"},
+	{"setStarty", ( PyCFunction ) Wave_setStarty, METH_VARARGS,
 	 "()- Sets Wave starty"},
-  {"getHeight",(PyCFunction)Wave_getHeight,
-	 METH_NOARGS,"()-Return Wave height"},
-  {"setHeight",(PyCFunction)Wave_setHeight, METH_VARARGS,
+	{"getHeight", ( PyCFunction ) Wave_getHeight,
+	 METH_NOARGS, "()-Return Wave height"},
+	{"setHeight", ( PyCFunction ) Wave_setHeight, METH_VARARGS,
 	 "()- Sets Wave height"},
-  {"getWidth",(PyCFunction)Wave_getWidth,
-	 METH_NOARGS,"()-Return Wave width"},
-  {"setWidth",(PyCFunction)Wave_setWidth, METH_VARARGS,
+	{"getWidth", ( PyCFunction ) Wave_getWidth,
+	 METH_NOARGS, "()-Return Wave width"},
+	{"setWidth", ( PyCFunction ) Wave_setWidth, METH_VARARGS,
 	 "()- Sets Wave width"},
-  {"getNarrow",(PyCFunction)Wave_getNarrow,
-	 METH_NOARGS,"()-Return Wave narrow"},
-  {"setNarrow",(PyCFunction)Wave_setNarrow, METH_VARARGS,
+	{"getNarrow", ( PyCFunction ) Wave_getNarrow,
+	 METH_NOARGS, "()-Return Wave narrow"},
+	{"setNarrow", ( PyCFunction ) Wave_setNarrow, METH_VARARGS,
 	 "()- Sets Wave narrow"},
-  {"getSpeed",(PyCFunction)Wave_getSpeed,
-	 METH_NOARGS,"()-Return Wave speed"},
-  {"setSpeed",(PyCFunction)Wave_setSpeed, METH_VARARGS,
+	{"getSpeed", ( PyCFunction ) Wave_getSpeed,
+	 METH_NOARGS, "()-Return Wave speed"},
+	{"setSpeed", ( PyCFunction ) Wave_setSpeed, METH_VARARGS,
 	 "()- Sets Wave speed"},
-  {"getMinfac",(PyCFunction)Wave_getMinfac,
-	 METH_NOARGS,"()-Return Wave minfac"},
-  {"setMinfac",(PyCFunction)Wave_setMinfac, METH_VARARGS,
+	{"getMinfac", ( PyCFunction ) Wave_getMinfac,
+	 METH_NOARGS, "()-Return Wave minfac"},
+	{"setMinfac", ( PyCFunction ) Wave_setMinfac, METH_VARARGS,
 	 "()- Sets Wave minfac"},
-  {"getDamp",(PyCFunction)Wave_getDamp,
-	 METH_NOARGS,"()-Return Wave damp"},
-  {"setDamp",(PyCFunction)Wave_setDamp, METH_VARARGS,
+	{"getDamp", ( PyCFunction ) Wave_getDamp,
+	 METH_NOARGS, "()-Return Wave damp"},
+	{"setDamp", ( PyCFunction ) Wave_setDamp, METH_VARARGS,
 	 "()- Sets Wave damp"},
-  {"getTimeoffs",(PyCFunction)Wave_getTimeoffs,
-	 METH_NOARGS,"()-Return Wave timeoffs"},
-  {"setTimeoffs",(PyCFunction)Wave_setTimeoffs, METH_VARARGS,
+	{"getTimeoffs", ( PyCFunction ) Wave_getTimeoffs,
+	 METH_NOARGS, "()-Return Wave timeoffs"},
+	{"setTimeoffs", ( PyCFunction ) Wave_setTimeoffs, METH_VARARGS,
 	 "()- Sets Wave timeoffs"},
-  {"getLifetime",(PyCFunction)Wave_getLifetime,
-	 METH_NOARGS,"()-Return Wave lifetime"},
-  {"setLifetime",(PyCFunction)Wave_setLifetime, METH_VARARGS,
+	{"getLifetime", ( PyCFunction ) Wave_getLifetime,
+	 METH_NOARGS, "()-Return Wave lifetime"},
+	{"setLifetime", ( PyCFunction ) Wave_setLifetime, METH_VARARGS,
 	 "()- Sets Wave lifetime"},
 	{NULL, NULL, 0, NULL}
 };
@@ -95,29 +95,28 @@ static PyMethodDef BPy_Wave_methods[] = {
 /*****************************************************************************/
 /* Python Wave_Type structure definition:                                    */
 /*****************************************************************************/
-PyTypeObject Wave_Type =
-{
-  PyObject_HEAD_INIT(NULL)
-  0,                                     
-  "Wave",                              
-  sizeof (BPy_Wave),                   
-  0,                                    
-  /* methods */
-  (destructor)WaveDeAlloc,              /* tp_dealloc */
-  (printfunc)WavePrint,                 /* tp_print */
-  (getattrfunc)WaveGetAttr,             /* tp_getattr */
-  (setattrfunc)WaveSetAttr,             /* tp_setattr */
-  0,                                      /* tp_compare */
-  (reprfunc)WaveRepr,                   /* 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_Wave_methods,                       /* tp_methods */
-  0,                                      /* tp_members */
+PyTypeObject Wave_Type = {
+	PyObject_HEAD_INIT( NULL )
+	0,
+	"Wave",
+	sizeof( BPy_Wave ),
+	0,
+	/* methods */
+	( destructor ) WaveDeAlloc,	/* tp_dealloc */
+	( printfunc ) WavePrint,	/* tp_print */
+	( getattrfunc ) WaveGetAttr,	/* tp_getattr */
+	( setattrfunc ) WaveSetAttr,	/* tp_setattr */
+	0,			/* tp_compare */
+	( reprfunc ) WaveRepr,	/* 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_Wave_methods,	/* tp_methods */
+	0,			/* tp_members */
 };
 
 
@@ -132,16 +131,16 @@ Functions :\n\
 	New(opt name) : creates a new wave object with the given name (optional)\n\
 	Get(name) : retreives a wave  with the given name (mandatory)\n\
 	get(name) : same as Get. Kept for compatibility reasons";
-static char M_Wave_New_doc[] ="";
-static char M_Wave_Get_doc[] ="xxx";
+static char M_Wave_New_doc[] = "";
+static char M_Wave_Get_doc[] = "xxx";
 /*****************************************************************************/
 /* Python method structure definition for Blender.Wave module:               */
 /*****************************************************************************/
 struct PyMethodDef M_Wave_methods[] = {
-  {"New",(PyCFunction)M_Wave_New, METH_VARARGS,M_Wave_New_doc},
-  {"Get",         M_Wave_Get,         METH_VARARGS, M_Wave_Get_doc},
-  {"get",         M_Wave_Get,         METH_VARARGS, M_Wave_Get_doc},
-  {NULL, NULL, 0, NULL}
+	{"New", ( PyCFunction ) M_Wave_New, METH_VARARGS, M_Wave_New_doc},
+	{"Get", M_Wave_Get, METH_VARARGS, M_Wave_Get_doc},
+	{"get", M_Wave_Get, METH_VARARGS, M_Wave_Get_doc},
+	{NULL, NULL, 0, NULL}
 };
 
 
@@ -161,416 +160,440 @@ struct PyMethodDef M_Wave_methods[] = {
 /* Function:              M_Wave_New                                         */
 /* Python equivalent:     Blender.Effect.Wave.New                            */
 /*****************************************************************************/
-PyObject *M_Wave_New(PyObject *self, PyObject *args)
+PyObject *M_Wave_New( PyObject * self, PyObject * args )
 {
-int type =   EFF_WAVE;
-  BPy_Effect    *pyeffect;
-  Effect      *bleffect = 0; 
-  
-  bleffect = add_effect(type); 
-  if (bleffect == NULL) 
-    return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-	     "couldn't create Effect Data in Blender"));
+	int type = EFF_WAVE;
+	BPy_Effect *pyeffect;
+	Effect *bleffect = 0;
+
+	bleffect = add_effect( type );
+	if( bleffect == NULL )
+		return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
+						"couldn't create Effect Data in Blender" ) );
+
+	pyeffect = ( BPy_Effect * ) PyObject_NEW( BPy_Effect, &Effect_Type );
 
-  pyeffect = (BPy_Effect *)PyObject_NEW(BPy_Effect, &Effect_Type);
 
-     
-  if (pyeffect == NULL) return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-		     "couldn't create Effect Data object"));
+	if( pyeffect == NULL )
+		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
+						"couldn't create Effect Data object" ) );
 
-  pyeffect->effect = bleffect; 
+	pyeffect->effect = bleffect;
 
-  return (PyObject *)pyeffect;
-  return 0;
+	return ( PyObject * ) pyeffect;
+	return 0;
 }
 
 /*****************************************************************************/
 /* Function:              M_Wave_Get                                         */
 /* Python equivalent:     Blender.Effect.Wave.Get                            */
 /*****************************************************************************/
-PyObject *M_Wave_Get(PyObject *self, PyObject *args)
+PyObject *M_Wave_Get( PyObject * self, PyObject * args )
 {
-  /*arguments : string object name
-    int : position of effect in the obj's effect list  */
-  char     *name = 0;
-  Object   *object_iter;
-  Effect *eff;
-  BPy_Wave *wanted_eff;
-  int num,i;
-
-  if (!PyArg_ParseTuple(args, "si", &name, &num ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected string int argument"));
-
-  object_iter = G.main->object.first;
-  if (!object_iter)return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-						"Scene contains no object"));
-
-  while (object_iter)
-    {
-      if (strcmp(name,object_iter->id.name+2))
-	{
-	  object_iter = object_iter->id.next;
-	  continue;
+	/*arguments : string object name
+	   int : position of effect in the obj's effect list  */
+	char *name = 0;
+	Object *object_iter;
+	Effect *eff;
+	BPy_Wave *wanted_eff;
+	int num, i;
+
+	if( !PyArg_ParseTuple( args, "si", &name, &num ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected string int argument" ) );
+
+	object_iter = G.main->object.first;
+	if( !object_iter )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"Scene contains no object" ) );
+
+	while( object_iter ) {
+		if( strcmp( name, object_iter->id.name + 2 ) ) {
+			object_iter = object_iter->id.next;
+			continue;
+		}
+
+
+		if( object_iter->effect.first != NULL ) {
+			eff = object_iter->effect.first;
+			for( i = 0; i < num; i++ ) {
+				if( eff->type != EFF_WAVE )
+					continue;
+				eff = eff->next;
+				if( !eff )
+					return ( EXPP_ReturnPyObjError
+						 ( PyExc_AttributeError,
+						   "bject" ) );
+			}
+			wanted_eff =
+				( BPy_Wave * ) PyObject_NEW( BPy_Wave,
+							     &Wave_Type );
+			wanted_eff->wave = eff;
+			return ( PyObject * ) wanted_eff;
+		}
+		object_iter = object_iter->id.next;
 	}
-
-      
-      if (object_iter->effect.first != NULL)
-	{
-	  eff = object_iter->effect.first;
-	  for(i = 0;i<num;i++)
-	    {
-	      if (eff->type != EFF_WAVE)continue;
-	      eff = eff->next;
-	      if (!eff)
-		return(EXPP_ReturnPyObjError(PyExc_AttributeError,"bject"));
-	    }
-	  wanted_eff = (BPy_Wave *)PyObject_NEW(BPy_Wave, &Wave_Type);
-	  wanted_eff->wave = eff;
-	  return (PyObject*)wanted_eff;  
-	}
-      object_iter = object_iter->id.next;
-    }
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
 /*****************************************************************************/
 /* Function:              Wave_Init                                          */
 /*****************************************************************************/
-PyObject *Wave_Init (void)
+PyObject *Wave_Init( void )
 {
-  PyObject  *submodule;
+	PyObject *submodule;
 
-  Wave_Type.ob_type = &PyType_Type;
-  submodule = Py_InitModule3("Blender.Wave",M_Wave_methods, M_Wave_doc);
-  return (submodule);
+	Wave_Type.ob_type = &PyType_Type;
+	submodule =
+		Py_InitModule3( "Blender.Wave", M_Wave_methods, M_Wave_doc );
+	return ( submodule );
 }
 
 /*****************************************************************************/
-/* Python BPy_Wave methods:                                                    */
+/* Python BPy_Wave methods:                                                  */
 /*****************************************************************************/
 
-PyObject *Wave_getStartx(BPy_Wave *self)
+PyObject *Wave_getStartx( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->startx);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->startx );
 }
 
-PyObject *Wave_setStartx(BPy_Wave *self,PyObject *args)
-{ 
-  WaveEff*ptr = (WaveEff*)self->wave;
-  float val = 0;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr->startx = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setStartx( BPy_Wave * self, PyObject * args )
+{
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	float val = 0;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr->startx = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getStarty(BPy_Wave *self)
+PyObject *Wave_getStarty( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->starty);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->starty );
 }
 
-PyObject *Wave_setStarty(BPy_Wave *self,PyObject *args)
-{ 
-  WaveEff*ptr = (WaveEff*)self->wave;
-  float val = 0;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr->starty = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setStarty( BPy_Wave * self, PyObject * args )
+{
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	float val = 0;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr->starty = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getHeight(BPy_Wave *self)
+PyObject *Wave_getHeight( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->height);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->height );
 }
 
-PyObject *Wave_setHeight(BPy_Wave *self,PyObject *args)
-{ 
-  WaveEff*ptr = (WaveEff*)self->wave;
-  float val = 0;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr->height = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setHeight( BPy_Wave * self, PyObject * args )
+{
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	float val = 0;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr->height = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getWidth(BPy_Wave *self)
+PyObject *Wave_getWidth( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->width);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->width );
 }
 
-PyObject *Wave_setWidth(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->width = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setWidth( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->width = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getNarrow(BPy_Wave *self)
+PyObject *Wave_getNarrow( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->narrow);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->narrow );
 }
 
-PyObject *Wave_setNarrow(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->narrow = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setNarrow( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->narrow = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getSpeed(BPy_Wave *self)
+PyObject *Wave_getSpeed( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->speed);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->speed );
 }
 
-PyObject *Wave_setSpeed(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->speed = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setSpeed( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->speed = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getMinfac(BPy_Wave *self)
+PyObject *Wave_getMinfac( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->minfac);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->minfac );
 }
 
-PyObject *Wave_setMinfac(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->minfac = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setMinfac( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->minfac = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
 
 
-PyObject *Wave_getDamp(BPy_Wave *self)
+PyObject *Wave_getDamp( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->damp);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->damp );
 }
 
-PyObject *Wave_setDamp(BPy_Wave *self,PyObject *args)
-{ 
-  WaveEff*ptr;
-  float val = 0;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->damp = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setDamp( BPy_Wave * self, PyObject * args )
+{
+	WaveEff *ptr;
+	float val = 0;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->damp = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getTimeoffs(BPy_Wave *self)
+PyObject *Wave_getTimeoffs( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->timeoffs);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->timeoffs );
 }
 
-PyObject *Wave_setTimeoffs(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->timeoffs = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setTimeoffs( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->timeoffs = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
 
-PyObject *Wave_getLifetime(BPy_Wave *self)
+PyObject *Wave_getLifetime( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  return PyFloat_FromDouble(ptr->lifetime);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	return PyFloat_FromDouble( ptr->lifetime );
 }
 
-PyObject *Wave_setLifetime(BPy_Wave *self,PyObject *args)
-{ 
-  float val = 0;
-  WaveEff*ptr;
-if (!PyArg_ParseTuple(args, "f", &val ))
-    return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
-				 "expected float argument"));
-  ptr = (WaveEff*)self->wave;
-  ptr->lifetime = val;
-  Py_INCREF(Py_None);
-  return Py_None;
+PyObject *Wave_setLifetime( BPy_Wave * self, PyObject * args )
+{
+	float val = 0;
+	WaveEff *ptr;
+	if( !PyArg_ParseTuple( args, "f", &val ) )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"expected float argument" ) );
+	ptr = ( WaveEff * ) self->wave;
+	ptr->lifetime = val;
+	Py_INCREF( Py_None );
+	return Py_None;
 }
+
 /*****************************************************************************/
 /* Function:    WaveDeAlloc                                                  */
-/* Description: This is a callback function for the BPy_Wave type. It is       */
+/* Description: This is a callback function for the BPy_Wave type. It is     */
 /*              the destructor function.                                     */
 /*****************************************************************************/
-void WaveDeAlloc (BPy_Wave *self)
+void WaveDeAlloc( BPy_Wave * self )
 {
-  WaveEff*ptr = (WaveEff*)self->wave;
-  PyObject_DEL (ptr);
+	WaveEff *ptr = ( WaveEff * ) self->wave;
+	PyObject_DEL( ptr );
 }
 
 /*****************************************************************************/
 /* Function:    WaveGetAttr                                                  */
-/* Description: This is a callback function for the BPy_Wave type. It is       */
-/*              the function that accesses BPy_Wave "member variables" and     */
+/* Description: This is a callback function for the BPy_Wave type. It is     */
+/*              the function that accesses BPy_Wave "member variables" and   */
 /*              methods.                                                     */
 /*****************************************************************************/
 
-PyObject *WaveGetAttr (BPy_Wave *self, char *name)
+PyObject *WaveGetAttr( BPy_Wave * self, char *name )
 {
-	if (!strcmp(name,"lifetime"))return Wave_getLifetime( self);
-	else if (!strcmp(name,"timeoffs"))return Wave_getTimeoffs( self);
-	else if (!strcmp(name,"damp"))return Wave_getDamp( self);
-	else if (!strcmp(name,"minfac"))return Wave_getMinfac( self);
-	else if (!strcmp(name,"speed"))return Wave_getSpeed( self);
-	else if (!strcmp(name,"narrow"))return Wave_getNarrow( self);
-	else if (!strcmp(name,"width"))return Wave_getWidth( self);
-	else if (!strcmp(name,"height"))return Wave_getHeight( self);
-	else if (!strcmp(name,"startx"))return Wave_getStartx( self);
-	else if (!strcmp(name,"starty"))return Wave_getStarty( self);
-  return Py_FindMethod(BPy_Wave_methods, (PyObject *)self, name);
+	if( !strcmp( name, "lifetime" ) )
+		return Wave_getLifetime( self );
+	else if( !strcmp( name, "timeoffs" ) )
+		return Wave_getTimeoffs( self );
+	else if( !strcmp( name, "damp" ) )
+		return Wave_getDamp( self );
+	else if( !strcmp( name, "minfac" ) )
+		return Wave_getMinfac( self );
+	else if( !strcmp( name, "speed" ) )
+		return Wave_getSpeed( self );
+	else if( !strcmp( name, "narrow" ) )
+		return Wave_getNarrow( self );
+	else if( !strcmp( name, "width" ) )
+		return Wave_getWidth( self );
+	else if( !strcmp( name, "height" ) )
+		return Wave_getHeight( self );
+	else if( !strcmp( name, "startx" ) )
+		return Wave_getStartx( self );
+	else if( !strcmp( name, "starty" ) )
+		return Wave_getStarty( self );
+	return Py_FindMethod( BPy_Wave_methods, ( PyObject * ) self, name );
 }
 
 /*****************************************************************************/
 /* Function:    WaveSetAttr                                                  */
-/* Description: This is a callback function for the BPy_Wave type. It is the   */
+/* Description: This is a callback function for the BPy_Wave type. It is the */
 /*              function that sets Wave Data attributes (member variables).  */
 /*****************************************************************************/
-int WaveSetAttr (BPy_Wave *self, char *name, PyObject *value)
+int WaveSetAttr( BPy_Wave * self, char *name, PyObject * value )
 {
-  PyObject *valtuple; 
-  PyObject *error = NULL;
-
-  valtuple = Py_BuildValue("(N)", value);
-
-  if (!valtuple)
-    return EXPP_ReturnIntError(PyExc_MemoryError,
-															 "ParticleSetAttr: couldn't create PyTuple");
-
-	if (!strcmp(name,"lifetime"))error = Wave_setLifetime( self,valtuple);
-	else if (!strcmp(name,"timeoffs"))error = Wave_setTimeoffs( self,valtuple);
-	else if (!strcmp(name,"damp"))    error = Wave_setDamp( self,valtuple);
-	else if (!strcmp(name,"minfac"))  error = Wave_setMinfac( self,valtuple);
-	else if (!strcmp(name,"speed"))   error = Wave_setSpeed( self,valtuple);
-	else if (!strcmp(name,"narrow"))  error = Wave_setNarrow( self,valtuple);
-	else if (!strcmp(name,"width"))   error = Wave_setWidth( self,valtuple);
-	else if (!strcmp(name,"height"))  error = Wave_setHeight( self,valtuple);
-	else if (!strcmp(name,"startx"))  error = Wave_setStartx( self,valtuple);
-	else if (!strcmp(name,"starty"))  error = Wave_setStarty( self,valtuple);
-
-
-  else { 
-    Py_DECREF(valtuple);
-
-    if ((strcmp (name, "Types") == 0) ||
-        (strcmp (name, "Modes") == 0))  
-      return (EXPP_ReturnIntError (PyExc_AttributeError,
-																	 "constant dictionary -- cannot be changed"));
-
-    else 
-      return (EXPP_ReturnIntError (PyExc_KeyError,
-																	 "attribute not found"));
-  }
+	PyObject *valtuple;
+	PyObject *error = NULL;
+
+	valtuple = Py_BuildValue( "(N)", value );
+
+	if( !valtuple )
+		return EXPP_ReturnIntError( PyExc_MemoryError,
+					    "ParticleSetAttr: couldn't create PyTuple" );
+
+	if( !strcmp( name, "lifetime" ) )
+		error = Wave_setLifetime( self, valtuple );
+	else if( !strcmp( name, "timeoffs" ) )
+		error = Wave_setTimeoffs( self, valtuple );
+	else if( !strcmp( name, "damp" ) )
+		error = Wave_setDamp( self, valtuple );
+	else if( !strcmp( name, "minfac" ) )
+		error = Wave_setMinfac( self, valtuple );
+	else if( !strcmp( name, "speed" ) )
+		error = Wave_setSpeed( self, valtuple );
+	else if( !strcmp( name, "narrow" ) )
+		error = Wave_setNarrow( self, valtuple );
+	else if( !strcmp( name, "width" ) )
+		error = Wave_setWidth( self, valtuple );
+	else if( !strcmp( name, "height" ) )
+		error = Wave_setHeight( self, valtuple );
+	else if( !strcmp( name, "startx" ) )
+		error = Wave_setStartx( self, valtuple );
+	else if( !strcmp( name, "starty" ) )
+		error = Wave_setStarty( self, valtuple );
+
+
+	else {
+		Py_DECREF( valtuple );
+
+		if( ( strcmp( name, "Types" ) == 0 ) ||
+		    ( strcmp( name, "Modes" ) == 0 ) )
+			return ( EXPP_ReturnIntError( PyExc_AttributeError,
+						      "constant dictionary -- cannot be changed" ) );
+
+		else
+			return ( EXPP_ReturnIntError( PyExc_KeyError,
+						      "attribute not found" ) );
+	}
 
-  /*Py_DECREF(valtuple);*/
+	/*Py_DECREF(valtuple); */
 
-  if (error != Py_None) return -1;
+	if( error != Py_None )
+		return -1;
 
-  Py_DECREF(Py_None);
-  return 0; 
+	Py_DECREF( Py_None );
+	return 0;
 }
 
 /*****************************************************************************/
 /* Function:    WavePrint                                                    */
-/* Description: This is a callback function for the BPy_Wave type. It          */
+/* Description: This is a callback function for the BPy_Wave type. It        */
 /*              builds a meaninful string to 'print' wave objects.           */
 /*****************************************************************************/
-int WavePrint(BPy_Wave *self, FILE *fp, int flags)
-{ 
+int WavePrint( BPy_Wave * self, FILE * fp, int flags )
+{
 
-  printf("I'm a wave...Cool, no?");	
-  return 0;
+	printf( "I'm a wave...Cool, no?" );
+	return 0;
 }
 
 /*****************************************************************************/
 /* Function:    WaveRepr                                                     */
-/* Description: This is a callback function for the BPy_Wave type. It          */
+/* Description: This is a callback function for the BPy_Wave type. It        */
 /*              builds a meaninful string to represent wave objects.         */
 /*****************************************************************************/
-PyObject *WaveRepr (BPy_Wave *self) 
+PyObject *WaveRepr( BPy_Wave * self )
 {
-  return 0;
+	return 0;
 }
 
-PyObject* WaveCreatePyObject (struct Effect *wave)
+PyObject *WaveCreatePyObject( struct Effect * wave )
 {
- BPy_Wave    * blen_object;
+	BPy_Wave *blen_object;
 
 
-    blen_object = (BPy_Wave*)PyObject_NEW (BPy_Wave, &Wave_Type);
+	blen_object = ( BPy_Wave * ) PyObject_NEW( BPy_Wave, &Wave_Type );
 
-    if (blen_object == NULL)
-    {
-        return (NULL);
-    }
-    blen_object->wave = wave;
-    return ((PyObject*)blen_object);
+	if( blen_object == NULL ) {
+		return ( NULL );
+	}
+	blen_object->wave = wave;
+	return ( ( PyObject * ) blen_object );
 
 }
 
-int WaveCheckPyObject (PyObject *py_obj)
+int WaveCheckPyObject( PyObject * py_obj )
 {
-return (py_obj->ob_type == &Wave_Type);
+	return ( py_obj->ob_type == &Wave_Type );
 }
 
 
-struct Wave* WaveFromPyObject (PyObject *py_obj)
+struct Wave *WaveFromPyObject( PyObject * py_obj )
 {
- BPy_Wave    * blen_obj;
+	BPy_Wave *blen_obj;
 
-    blen_obj = (BPy_Wave*)py_obj;
-    return ((struct Wave*)blen_obj->wave);
+	blen_obj = ( BPy_Wave * ) py_obj;
+	return ( ( struct Wave * ) blen_obj->wave );
 
 }
-