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, 670 deletions

diff --git a/source/blender/python/api2_2x/Mathutils.c b/source/blender/python/api2_2x/Mathutils.c
index b7e0796759f..5f5664bf706 100644
--- a/source/blender/python/api2_2x/Mathutils.c
+++ b/source/blender/python/api2_2x/Mathutils.c
@@ -33,9 +33,9 @@
 #include "Mathutils.h"
 
 //***************************************************************************
-// Function:					M_Mathutils_Rand															
+// Function:             M_Mathutils_Rand            
 //***************************************************************************
-static PyObject *M_Mathutils_Rand(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Rand( PyObject * self, PyObject * args )
 {
 
 	float high, low, range;
@@ -43,285 +43,298 @@ static PyObject *M_Mathutils_Rand(PyObject *self, PyObject *args)
 	high = 1.0;
 	low = 0.0;
 
-	if (!PyArg_ParseTuple(args, "|ff", &low, &high))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected optional float & float\n"));
+	if( !PyArg_ParseTuple( args, "|ff", &low, &high ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected optional float & float\n" ) );
 
-	if ( (high < low) ||(high < 0 && low > 0))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"high value should be larger than low value\n"));
+	if( ( high < low ) || ( high < 0 && low > 0 ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"high value should be larger than low value\n" ) );
 
 	//seed the generator
-	BLI_srand((unsigned int) (PIL_check_seconds_timer()*0x7FFFFFFF));
+	BLI_srand( ( unsigned int ) ( PIL_check_seconds_timer(  ) *
+				      0x7FFFFFFF ) );
 
 	//get the random number 0 - 1
-	rand = BLI_drand();
+	rand = BLI_drand(  );
 
 	//set it to range
 	range = high - low;
 	rand = rand * range;
 	rand = rand + low;
 
-	return PyFloat_FromDouble((double)rand);
+	return PyFloat_FromDouble( ( double ) rand );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_Vector																				
-// Python equivalent:			Blender.Mathutils.Vector	
+// Function:             M_Mathutils_Vector               
+// Python equivalent:     Blender.Mathutils.Vector        
 // Supports 2D, 3D, and 4D vector objects both int and float values
-// accepted. Mixed float and int values accepted. Ints are parsed to float																	
+// accepted. Mixed float and int values accepted. Ints are parsed to float  
 //***************************************************************************
-static PyObject *M_Mathutils_Vector(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Vector( PyObject * self, PyObject * args )
 {
 	PyObject *listObject = NULL;
 	PyObject *checkOb = NULL;
 	int x;
 	float *vec;
 
-	if (!PyArg_ParseTuple(args, "|O!", &PyList_Type, &listObject))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"0 or 1 list expected"));
+	if( !PyArg_ParseTuple( args, "|O!", &PyList_Type, &listObject ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"0 or 1 list expected" ) );
 
-	if(!listObject)	return (PyObject *)newVectorObject(NULL, 3);
+	if( !listObject )
+		return ( PyObject * ) newVectorObject( NULL, 3 );
 
 	//2D 3D 4D supported
-	if(PyList_Size(listObject) != 2 && PyList_Size(listObject) != 3 
-			&& PyList_Size(listObject) != 4)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,	
-			"2D, 3D and 4D vectors supported\n"));
-
-	for (x = 0; x < PyList_Size(listObject); x++) {
-		checkOb = PyList_GetItem(listObject, x);
-		if(!PyInt_Check(checkOb) && !PyFloat_Check(checkOb))
-			return (EXPP_ReturnPyObjError (PyExc_TypeError,
-							"expected list of numbers\n"));
+	if( PyList_Size( listObject ) != 2 && PyList_Size( listObject ) != 3
+	    && PyList_Size( listObject ) != 4 )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"2D, 3D and 4D vectors supported\n" ) );
+
+	for( x = 0; x < PyList_Size( listObject ); x++ ) {
+		checkOb = PyList_GetItem( listObject, x );
+		if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
+			return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+							"expected list of numbers\n" ) );
 	}
 
 	//allocate memory
-	vec = PyMem_Malloc (PyList_Size(listObject)*sizeof (float));
+	vec = PyMem_Malloc( PyList_Size( listObject ) * sizeof( float ) );
 
 	//parse it all as floats
-	for (x = 0; x < PyList_Size(listObject); x++) {
-		if (!PyArg_Parse(PyList_GetItem(listObject, x), "f", &vec[x])){
-			return EXPP_ReturnPyObjError (PyExc_TypeError, 
-				"python list not parseable\n");
+	for( x = 0; x < PyList_Size( listObject ); x++ ) {
+		if( !PyArg_Parse
+		    ( PyList_GetItem( listObject, x ), "f", &vec[x] ) ) {
+			return EXPP_ReturnPyObjError( PyExc_TypeError,
+						      "python list not parseable\n" );
 		}
 	}
-	return (PyObject *)newVectorObject(vec, PyList_Size(listObject));
+	return ( PyObject * ) newVectorObject( vec,
+					       PyList_Size( listObject ) );
 }
 
 //***************************************************************************
 //Begin Vector Utils
 
-static PyObject *M_Mathutils_CopyVec(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CopyVec( PyObject * self, PyObject * args )
 {
-	VectorObject * vector;
+	VectorObject *vector;
 	float *vec;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "O!", &vector_Type, &vector))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected vector type\n"));
+	if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vector ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected vector type\n" ) );
 
-	vec = PyMem_Malloc(vector->size * sizeof(float));
-	for(x = 0; x < vector->size; x++){
+	vec = PyMem_Malloc( vector->size * sizeof( float ) );
+	for( x = 0; x < vector->size; x++ ) {
 		vec[x] = vector->vec[x];
 	}
 
-	return (PyObject *)newVectorObject(vec, vector->size);
+	return ( PyObject * ) newVectorObject( vec, vector->size );
 }
 
 //finds perpendicular vector - only 3D is supported
-static PyObject *M_Mathutils_CrossVecs(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CrossVecs( PyObject * self, PyObject * args )
 {
-	PyObject * vecCross;
-	VectorObject * vec1;
-	VectorObject * vec2;
+	PyObject *vecCross;
+	VectorObject *vec1;
+	VectorObject *vec2;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected 2 vector types\n"));
-	if(vec1->size != 3 || vec2->size != 3)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"only 3D vectors are supported\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected 2 vector types\n" ) );
+	if( vec1->size != 3 || vec2->size != 3 )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"only 3D vectors are supported\n" ) );
 
-	vecCross = newVectorObject(PyMem_Malloc (3*sizeof (float)), 3);
-	Crossf(((VectorObject*)vecCross)->vec, vec1->vec, vec2->vec);
+	vecCross = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
+	Crossf( ( ( VectorObject * ) vecCross )->vec, vec1->vec, vec2->vec );
 
 	return vecCross;
 }
 
-static PyObject *M_Mathutils_DotVecs(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_DotVecs( PyObject * self, PyObject * args )
 {
-	VectorObject * vec1;
-	VectorObject * vec2;
+	VectorObject *vec1;
+	VectorObject *vec2;
 	float dot;
 	int x;
 
 	dot = 0;
-	if (!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected vector types\n"));
-	if(vec1->size != vec2->size)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-		  "vectors must be of the same size\n"));
-
-	for(x = 0; x < vec1->size; x++){
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected vector types\n" ) );
+	if( vec1->size != vec2->size )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"vectors must be of the same size\n" ) );
+
+	for( x = 0; x < vec1->size; x++ ) {
 		dot += vec1->vec[x] * vec2->vec[x];
 	}
 
-	return PyFloat_FromDouble((double)dot);
+	return PyFloat_FromDouble( ( double ) dot );
 }
 
-static PyObject *M_Mathutils_AngleBetweenVecs(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_AngleBetweenVecs( PyObject * self,
+					       PyObject * args )
 {
-	VectorObject * vec1;
-	VectorObject * vec2;
+	VectorObject *vec1;
+	VectorObject *vec2;
 	float dot, angleRads, norm;
 	int x;
 
 	dot = 0;
-	if (!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected 2 vector types\n"));
-	if(vec1->size != vec2->size)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"vectors must be of the same size\n"));
-	if(vec1->size > 3 || vec2->size > 3)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"only 2D,3D vectors are supported\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected 2 vector types\n" ) );
+	if( vec1->size != vec2->size )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"vectors must be of the same size\n" ) );
+	if( vec1->size > 3 || vec2->size > 3 )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"only 2D,3D vectors are supported\n" ) );
 
 	//normalize vec1
 	norm = 0.0f;
-	for(x = 0; x < vec1->size; x++){
+	for( x = 0; x < vec1->size; x++ ) {
 		norm += vec1->vec[x] * vec1->vec[x];
 	}
-	norm = (float)sqrt(norm);
-	for(x = 0; x < vec1->size; x++){
+	norm = ( float ) sqrt( norm );
+	for( x = 0; x < vec1->size; x++ ) {
 		vec1->vec[x] /= norm;
 	}
 
 	//normalize vec2
 	norm = 0.0f;
-	for(x = 0; x < vec2->size; x++){
+	for( x = 0; x < vec2->size; x++ ) {
 		norm += vec2->vec[x] * vec2->vec[x];
 	}
-	norm = (float)sqrt(norm);
-	for(x = 0; x < vec2->size; x++){
+	norm = ( float ) sqrt( norm );
+	for( x = 0; x < vec2->size; x++ ) {
 		vec2->vec[x] /= norm;
 	}
 
 	//dot product
-	for(x = 0; x < vec1->size; x++){
+	for( x = 0; x < vec1->size; x++ ) {
 		dot += vec1->vec[x] * vec2->vec[x];
 	}
 
 	//I believe saacos checks to see if the vectors are normalized
-	angleRads = saacos(dot);
+	angleRads = saacos( dot );
 
-	return PyFloat_FromDouble((double)(angleRads*(180/Py_PI)));
+	return PyFloat_FromDouble( ( double )
+				   ( angleRads * ( 180 / Py_PI ) ) );
 }
 
-static PyObject *M_Mathutils_MidpointVecs(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_MidpointVecs( PyObject * self, PyObject * args )
 {
-	
-	VectorObject * vec1;
-	VectorObject * vec2;
-	float * vec;
+
+	VectorObject *vec1;
+	VectorObject *vec2;
+	float *vec;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected vector types\n"));
-	if(vec1->size != vec2->size)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"vectors must be of the same size\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected vector types\n" ) );
+	if( vec1->size != vec2->size )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"vectors must be of the same size\n" ) );
 
-	vec = PyMem_Malloc (vec1->size*sizeof (float));
+	vec = PyMem_Malloc( vec1->size * sizeof( float ) );
 
-	for(x = 0; x < vec1->size; x++){
-		vec[x]= 0.5f*(vec1->vec[x] + vec2->vec[x]);
+	for( x = 0; x < vec1->size; x++ ) {
+		vec[x] = 0.5f * ( vec1->vec[x] + vec2->vec[x] );
 	}
-	return (PyObject *)newVectorObject(vec, vec1->size);
+	return ( PyObject * ) newVectorObject( vec, vec1->size );
 }
 
 //row vector multiplication
-static PyObject *M_Mathutils_VecMultMat(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_VecMultMat( PyObject * self, PyObject * args )
 {
-	PyObject * ob1 = NULL;
-	PyObject * ob2 = NULL;
-	MatrixObject * mat;
-	VectorObject * vec;
-	float * vecNew;
+	PyObject *ob1 = NULL;
+	PyObject *ob2 = NULL;
+	MatrixObject *mat;
+	VectorObject *vec;
+	float *vecNew;
 	int x, y;
 	int z = 0;
 	float dot = 0.0f;
 
 	//get pyObjects
-	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &ob1, &matrix_Type, &ob2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,	
-				"vector and matrix object expected - in that order\n"));
-
-	mat = (MatrixObject*)ob2; 
-	vec = (VectorObject*)ob1;
-	if(mat->colSize != vec->size)
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,	
-				"matrix col size and vector size must be the same\n"));
-
-	vecNew = PyMem_Malloc (vec->size*sizeof (float));
-	
-	for(x = 0; x < mat->colSize; x++){
-		for(y = 0; y < mat->rowSize; y++){
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &ob1, &matrix_Type, &ob2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "vector and matrix object expected - in that order\n" ) );
+
+	mat = ( MatrixObject * ) ob2;
+	vec = ( VectorObject * ) ob1;
+	if( mat->colSize != vec->size )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"matrix col size and vector size must be the same\n" ) );
+
+	vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
+
+	for( x = 0; x < mat->colSize; x++ ) {
+		for( y = 0; y < mat->rowSize; y++ ) {
 			dot += mat->matrix[y][x] * vec->vec[y];
 		}
-		vecNew[z] = dot; 
-		z++; dot = 0;
+		vecNew[z] = dot;
+		z++;
+		dot = 0;
 	}
 
-	return (PyObject *)newVectorObject(vecNew, vec->size);
+	return ( PyObject * ) newVectorObject( vecNew, vec->size );
 }
 
-static PyObject *M_Mathutils_ProjectVecs(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_ProjectVecs( PyObject * self, PyObject * args )
 {
-	VectorObject * vec1;
-	VectorObject * vec2;
+	VectorObject *vec1;
+	VectorObject *vec2;
 	float *vec;
 	float dot = 0.0f;
 	float dot2 = 0.0f;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected vector types\n"));
-	if(vec1->size != vec2->size)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"vectors must be of the same size\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError, "expected vector types\n" ) );
+	if( vec1->size != vec2->size )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"vectors must be of the same size\n" ) );
 
-	vec = PyMem_Malloc (vec1->size * sizeof (float));
+	vec = PyMem_Malloc( vec1->size * sizeof( float ) );
 
 	//dot of vec1 & vec2
-	for(x = 0; x < vec1->size; x++){
-		dot +=  vec1->vec[x] * vec2->vec[x];
+	for( x = 0; x < vec1->size; x++ ) {
+		dot += vec1->vec[x] * vec2->vec[x];
 	}
 	//dot of vec2 & vec2
-	for(x = 0; x < vec2->size; x++){
-		dot2 +=  vec2->vec[x] * vec2->vec[x];
+	for( x = 0; x < vec2->size; x++ ) {
+		dot2 += vec2->vec[x] * vec2->vec[x];
 	}
-	dot /= dot2; 
-	for(x = 0; x < vec1->size; x++){
+	dot /= dot2;
+	for( x = 0; x < vec1->size; x++ ) {
 		vec[x] = dot * vec2->vec[x];
 	}
-	return (PyObject *)newVectorObject(vec, vec1->size);
+	return ( PyObject * ) newVectorObject( vec, vec1->size );
 }
 
 //End Vector Utils
 
 //***************************************************************************
-// Function:					M_Mathutils_Matrix																				
-// Python equivalent:			Blender.Mathutils.Matrix																		
+// Function:      M_Mathutils_Matrix                                           // Python equivalent:      Blender.Mathutils.Matrix                          
 //***************************************************************************
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_Matrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Matrix( PyObject * self, PyObject * args )
 {
 
 	PyObject *rowA = NULL;
@@ -330,277 +343,307 @@ static PyObject *M_Mathutils_Matrix(PyObject *self, PyObject *args)
 	PyObject *rowD = NULL;
 	PyObject *checkOb = NULL;
 	int x, rowSize, colSize;
-	float * mat;
+	float *mat;
 	int OK;
 
-	if (!PyArg_ParseTuple(args, "|O!O!O!O!", &PyList_Type, &rowA,
-		                                     &PyList_Type, &rowB,
-											 &PyList_Type, &rowC,
-											 &PyList_Type, &rowD)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected 0, 2,3 or 4 lists\n"));
+	if( !PyArg_ParseTuple( args, "|O!O!O!O!", &PyList_Type, &rowA,
+			       &PyList_Type, &rowB,
+			       &PyList_Type, &rowC, &PyList_Type, &rowD ) ) {
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected 0, 2,3 or 4 lists\n" ) );
 	}
 
-	if(!rowA)
-		return newMatrixObject (NULL, 4, 4);
-	
-	if(!rowB)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected 0, 2,3 or 4 lists\n"));
+	if( !rowA )
+		return newMatrixObject( NULL, 4, 4 );
+
+	if( !rowB )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected 0, 2,3 or 4 lists\n" ) );
 
 	//get rowSize
-	if(rowC){
-		if(rowD){
+	if( rowC ) {
+		if( rowD ) {
 			rowSize = 4;
-		}else{
+		} else {
 			rowSize = 3;
 		}
-	}else{
+	} else {
 		rowSize = 2;
 	}
 
 	//check size and get colSize
 	OK = 0;
-	if((PyList_Size(rowA) == PyList_Size(rowB))){
-		if(rowC){
-			if((PyList_Size(rowA) == PyList_Size(rowC))){
-				if(rowD){
-					if((PyList_Size(rowA) == PyList_Size(rowD))){
+	if( ( PyList_Size( rowA ) == PyList_Size( rowB ) ) ) {
+		if( rowC ) {
+			if( ( PyList_Size( rowA ) == PyList_Size( rowC ) ) ) {
+				if( rowD ) {
+					if( ( PyList_Size( rowA ) ==
+					      PyList_Size( rowD ) ) ) {
 						OK = 1;
 					}
-				} OK = 1;
+				}
+				OK = 1;
 			}
-		}else OK = 1;
+		} else
+			OK = 1;
 	}
 
-	if(!OK)	return EXPP_ReturnPyObjError (PyExc_AttributeError,
-			"each row of vector must contain the same number of parameters\n");			
-	colSize = PyList_Size(rowA);
+	if( !OK )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "each row of vector must contain the same number of parameters\n" );
+	colSize = PyList_Size( rowA );
 
 	//check for numeric types
-	for (x = 0; x < colSize; x++) {
-		checkOb = PyList_GetItem(rowA, x);
-		if(!PyInt_Check(checkOb) && !PyFloat_Check(checkOb))
-			return (EXPP_ReturnPyObjError (PyExc_TypeError,
-							"1st list - expected list of numbers\n"));
-		checkOb = PyList_GetItem(rowB, x);
-		if(!PyInt_Check(checkOb) && !PyFloat_Check(checkOb))
-			return (EXPP_ReturnPyObjError (PyExc_TypeError,
-							"2nd list - expected list of numbers\n"));
-		if(rowC){
-			checkOb = PyList_GetItem(rowC, x);
-			if(!PyInt_Check(checkOb) && !PyFloat_Check(checkOb))
-				return (EXPP_ReturnPyObjError (PyExc_TypeError,
-								"3rd list - expected list of numbers\n"));
+	for( x = 0; x < colSize; x++ ) {
+		checkOb = PyList_GetItem( rowA, x );
+		if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
+			return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+							"1st list - expected list of numbers\n" ) );
+		checkOb = PyList_GetItem( rowB, x );
+		if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
+			return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+							"2nd list - expected list of numbers\n" ) );
+		if( rowC ) {
+			checkOb = PyList_GetItem( rowC, x );
+			if( !PyInt_Check( checkOb )
+			    && !PyFloat_Check( checkOb ) )
+				return ( EXPP_ReturnPyObjError
+					 ( PyExc_TypeError,
+					   "3rd list - expected list of numbers\n" ) );
 		}
-		if(rowD){
-			checkOb = PyList_GetItem(rowD, x);
-			if(!PyInt_Check(checkOb) && !PyFloat_Check(checkOb))
-				return (EXPP_ReturnPyObjError (PyExc_TypeError,
-								"4th list - expected list of numbers\n"));
+		if( rowD ) {
+			checkOb = PyList_GetItem( rowD, x );
+			if( !PyInt_Check( checkOb )
+			    && !PyFloat_Check( checkOb ) )
+				return ( EXPP_ReturnPyObjError
+					 ( PyExc_TypeError,
+					   "4th list - expected list of numbers\n" ) );
 		}
 	}
 
 	//allocate space for 1D array
-	mat = PyMem_Malloc (rowSize * colSize * sizeof (float));
+	mat = PyMem_Malloc( rowSize * colSize * sizeof( float ) );
 
 	//parse rows
-	for (x = 0; x < colSize; x++) {
-		if (!PyArg_Parse(PyList_GetItem(rowA, x), "f", &mat[x]))
-			return EXPP_ReturnPyObjError (PyExc_TypeError,	
-			"rowA - python list not parseable\n");
+	for( x = 0; x < colSize; x++ ) {
+		if( !PyArg_Parse( PyList_GetItem( rowA, x ), "f", &mat[x] ) )
+			return EXPP_ReturnPyObjError( PyExc_TypeError,
+						      "rowA - python list not parseable\n" );
 	}
-	for (x = 0; x < colSize; x++) {
-		if (!PyArg_Parse(PyList_GetItem(rowB, x), "f", &mat[(colSize + x)]))
-			return EXPP_ReturnPyObjError (PyExc_TypeError,	
-			"rowB - python list not parseable\n");
+	for( x = 0; x < colSize; x++ ) {
+		if( !PyArg_Parse
+		    ( PyList_GetItem( rowB, x ), "f", &mat[( colSize + x )] ) )
+			return EXPP_ReturnPyObjError( PyExc_TypeError,
+						      "rowB - python list not parseable\n" );
 	}
-	if(rowC){
-		for (x = 0; x < colSize; x++) {
-			if (!PyArg_Parse(PyList_GetItem(rowC, x), "f", &mat[((2*colSize) + x)]))
-				return EXPP_ReturnPyObjError (PyExc_TypeError,	
-				"rowC - python list not parseable\n");
+	if( rowC ) {
+		for( x = 0; x < colSize; x++ ) {
+			if( !PyArg_Parse
+			    ( PyList_GetItem( rowC, x ), "f",
+			      &mat[( ( 2 * colSize ) + x )] ) )
+				return EXPP_ReturnPyObjError( PyExc_TypeError,
+							      "rowC - python list not parseable\n" );
 		}
 	}
-	if(rowD){
-		for (x = 0; x < colSize; x++) {
-			if (!PyArg_Parse(PyList_GetItem(rowD, x), "f", &mat[((3*colSize) + x)]))
-				return EXPP_ReturnPyObjError (PyExc_TypeError,	
-				"rowD - python list not parseable\n");
+	if( rowD ) {
+		for( x = 0; x < colSize; x++ ) {
+			if( !PyArg_Parse
+			    ( PyList_GetItem( rowD, x ), "f",
+			      &mat[( ( 3 * colSize ) + x )] ) )
+				return EXPP_ReturnPyObjError( PyExc_TypeError,
+							      "rowD - python list not parseable\n" );
 		}
 	}
-
 	//pass to matrix creation
-	return newMatrixObject (mat, rowSize, colSize);
+	return newMatrixObject( mat, rowSize, colSize );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_RotationMatrix																				
-// Python equivalent:			Blender.Mathutils.RotationMatrix																		
+// Function:      M_Mathutils_RotationMatrix                                  
+// Python equivalent:    Blender.Mathutils.RotationMatrix  
 //***************************************************************************
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_RotationMatrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_RotationMatrix( PyObject * self, PyObject * args )
 {
 
 	float *mat;
 	float angle = 0.0f;
 	char *axis = NULL;
-	VectorObject * vec = NULL;
+	VectorObject *vec = NULL;
 	int matSize;
 	float norm = 0.0f;
 	float cosAngle = 0.0f;
 	float sinAngle = 0.0f;
 
-	if (!PyArg_ParseTuple(args, "fi|sO!",  &angle, &matSize, &axis, &vector_Type, &vec)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected float int and optional string and vector\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "fi|sO!", &angle, &matSize, &axis, &vector_Type, &vec ) ) {
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected float int and optional string and vector\n" ) );
 	}
-	if(angle < -360.0f || angle > 360.0f)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"angle size not appropriate\n");
-	if(matSize != 2 && matSize != 3 && matSize != 4)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"can only return a 2x2 3x3 or 4x4 matrix\n");
-	if(matSize == 2 && (axis != NULL || vec != NULL))
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"cannot create a 2x2 rotation matrix around arbitrary axis\n");
-	if((matSize == 3 || matSize == 4) && axis == NULL)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"please choose an axis of rotation\n");
-	if(axis){
-		if(((strcmp (axis, "r") == 0) ||
-			(strcmp (axis, "R") == 0)) && vec == NULL)
-	   		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"please define the arbitrary axis of rotation\n");
+	if( angle < -360.0f || angle > 360.0f )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "angle size not appropriate\n" );
+	if( matSize != 2 && matSize != 3 && matSize != 4 )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
+	if( matSize == 2 && ( axis != NULL || vec != NULL ) )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "cannot create a 2x2 rotation matrix around arbitrary axis\n" );
+	if( ( matSize == 3 || matSize == 4 ) && axis == NULL )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "please choose an axis of rotation\n" );
+	if( axis ) {
+		if( ( ( strcmp( axis, "r" ) == 0 ) ||
+		      ( strcmp( axis, "R" ) == 0 ) ) && vec == NULL )
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "please define the arbitrary axis of rotation\n" );
 	}
-	if(vec){
-		if(vec->size != 3)
-	   		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"the arbitrary axis must be a 3D vector\n");
+	if( vec ) {
+		if( vec->size != 3 )
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "the arbitrary axis must be a 3D vector\n" );
 	}
 
-	mat = PyMem_Malloc(matSize * matSize * sizeof(float));
+	mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
 
 	//convert to radians
-	angle = angle * (float)(Py_PI/180);
+	angle = angle * ( float ) ( Py_PI / 180 );
 
-	if(axis == NULL && matSize == 2){
+	if( axis == NULL && matSize == 2 ) {
 		//2D rotation matrix
-		mat[0] = ((float)cos((double)(angle)));
-		mat[1] = ((float)sin((double)(angle)));
-		mat[2] = (-((float)sin((double)(angle))));
-		mat[3] = ((float)cos((double)(angle)));
-	}else if((strcmp(axis,"x") == 0) ||
-		(strcmp(axis,"X") == 0)){
+		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
+		mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
+		mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
+		mat[3] = ( ( float ) cos( ( double ) ( angle ) ) );
+	} else if( ( strcmp( axis, "x" ) == 0 ) ||
+		   ( strcmp( axis, "X" ) == 0 ) ) {
 		//rotation around X
-		mat[0] = 1.0f; mat[1] = 0.0f; mat[2] = 0.0f; mat[3] = 0.0f;
-		mat[4] = ((float)cos((double)(angle)));
-		mat[5] = ((float)sin((double)(angle)));
+		mat[0] = 1.0f;
+		mat[1] = 0.0f;
+		mat[2] = 0.0f;
+		mat[3] = 0.0f;
+		mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
+		mat[5] = ( ( float ) sin( ( double ) ( angle ) ) );
 		mat[6] = 0.0f;
-		mat[7] = (-((float)sin((double)(angle))));
-		mat[8] = ((float)cos((double)(angle)));
-	}else if ((strcmp(axis,"y") == 0) ||
-		      (strcmp(axis,"Y") == 0)){
+		mat[7] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
+		mat[8] = ( ( float ) cos( ( double ) ( angle ) ) );
+	} else if( ( strcmp( axis, "y" ) == 0 ) ||
+		   ( strcmp( axis, "Y" ) == 0 ) ) {
 		//rotation around Y
-		mat[0] = ((float)cos((double)(angle)));
+		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
 		mat[1] = 0.0f;
-		mat[2] = (-((float)sin((double)(angle))));
-		mat[3] = 0.0f;	mat[4] = 1.0f;	mat[5] = 0.0f;
-		mat[6] = ((float)sin((double)(angle)));
+		mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
+		mat[3] = 0.0f;
+		mat[4] = 1.0f;
+		mat[5] = 0.0f;
+		mat[6] = ( ( float ) sin( ( double ) ( angle ) ) );
 		mat[7] = 0.0f;
-		mat[8] = ((float)cos((double)(angle)));
-	}else if ((strcmp(axis,"z") == 0) ||
-		      (strcmp(axis,"Z") == 0)){
+		mat[8] = ( ( float ) cos( ( double ) ( angle ) ) );
+	} else if( ( strcmp( axis, "z" ) == 0 ) ||
+		   ( strcmp( axis, "Z" ) == 0 ) ) {
 		//rotation around Z
-		mat[0] = ((float)cos((double)(angle)));
-		mat[1] = ((float)sin((double)(angle)));
+		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
+		mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
 		mat[2] = 0.0f;
-		mat[3] = (-((float)sin((double)(angle))));
-		mat[4] = ((float)cos((double)(angle)));
-		mat[5] = 0.0f; mat[6] = 0.0f; mat[7] = 0.0f; mat[8] = 1.0f;
-	}else if ((strcmp(axis,"r") == 0) ||
-		      (strcmp(axis,"R") == 0)){
+		mat[3] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
+		mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
+		mat[5] = 0.0f;
+		mat[6] = 0.0f;
+		mat[7] = 0.0f;
+		mat[8] = 1.0f;
+	} else if( ( strcmp( axis, "r" ) == 0 ) ||
+		   ( strcmp( axis, "R" ) == 0 ) ) {
 		//arbitrary rotation
 		//normalize arbitrary axis
-		norm = (float)sqrt(vec->vec[0] * vec->vec[0] +  vec->vec[1] * vec->vec[1] +
-						   vec->vec[2] * vec->vec[2]);
-		vec->vec[0] /= norm; vec->vec[1] /= norm; vec->vec[2] /= norm;
+		norm = ( float ) sqrt( vec->vec[0] * vec->vec[0] +
+				       vec->vec[1] * vec->vec[1] +
+				       vec->vec[2] * vec->vec[2] );
+		vec->vec[0] /= norm;
+		vec->vec[1] /= norm;
+		vec->vec[2] /= norm;
 
 		//create matrix
-		cosAngle = ((float)cos((double)(angle)));
-		sinAngle = ((float)sin((double)(angle)));
-		mat[0] = ((vec->vec[0] * vec->vec[0]) * (1 - cosAngle)) +
-				 cosAngle;
-		mat[1] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) +
-				 (vec->vec[2] * sinAngle);
-		mat[2] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) -
-				 (vec->vec[1] * sinAngle);
-		mat[3] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) -
-				 (vec->vec[2] * sinAngle);
-		mat[4] = ((vec->vec[1] * vec->vec[1]) * (1 - cosAngle)) +
-				 cosAngle;
-		mat[5] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) +
-				 (vec->vec[0] * sinAngle);
-		mat[6] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) +
-				 (vec->vec[1] * sinAngle);
-		mat[7] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) -
-				 (vec->vec[0] * sinAngle);
-		mat[8] = ((vec->vec[2] * vec->vec[2]) * (1 - cosAngle)) +
-				 cosAngle;
-	}else{
-	   	return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"unrecognizable axis of rotation type - expected x,y,z or r\n");
+		cosAngle = ( ( float ) cos( ( double ) ( angle ) ) );
+		sinAngle = ( ( float ) sin( ( double ) ( angle ) ) );
+		mat[0] = ( ( vec->vec[0] * vec->vec[0] ) * ( 1 - cosAngle ) ) +
+			cosAngle;
+		mat[1] = ( ( vec->vec[0] * vec->vec[1] ) * ( 1 - cosAngle ) ) +
+			( vec->vec[2] * sinAngle );
+		mat[2] = ( ( vec->vec[0] * vec->vec[2] ) * ( 1 - cosAngle ) ) -
+			( vec->vec[1] * sinAngle );
+		mat[3] = ( ( vec->vec[0] * vec->vec[1] ) * ( 1 - cosAngle ) ) -
+			( vec->vec[2] * sinAngle );
+		mat[4] = ( ( vec->vec[1] * vec->vec[1] ) * ( 1 - cosAngle ) ) +
+			cosAngle;
+		mat[5] = ( ( vec->vec[1] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
+			( vec->vec[0] * sinAngle );
+		mat[6] = ( ( vec->vec[0] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
+			( vec->vec[1] * sinAngle );
+		mat[7] = ( ( vec->vec[1] * vec->vec[2] ) * ( 1 - cosAngle ) ) -
+			( vec->vec[0] * sinAngle );
+		mat[8] = ( ( vec->vec[2] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
+			cosAngle;
+	} else {
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "unrecognizable axis of rotation type - expected x,y,z or r\n" );
 	}
-	if(matSize == 4){
+	if( matSize == 4 ) {
 		//resize matrix
-		mat[15] = 1.0f;	mat[14] = 0.0f;
-		mat[13] = 0.0f;	mat[12] = 0.0f;
-		mat[11] = 0.0f;	mat[10] = mat[8];
-		mat[9] = mat[7]; mat[8] = mat[6];
-		mat[7] = 0.0f;	mat[6] = mat[5];
-		mat[5] = mat[4];mat[4] = mat[3];
+		mat[15] = 1.0f;
+		mat[14] = 0.0f;
+		mat[13] = 0.0f;
+		mat[12] = 0.0f;
+		mat[11] = 0.0f;
+		mat[10] = mat[8];
+		mat[9] = mat[7];
+		mat[8] = mat[6];
+		mat[7] = 0.0f;
+		mat[6] = mat[5];
+		mat[5] = mat[4];
+		mat[4] = mat[3];
 		mat[3] = 0.0f;
 	}
-
 	//pass to matrix creation
-	return newMatrixObject (mat, matSize, matSize);
+	return newMatrixObject( mat, matSize, matSize );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_TranslationMatrix																				
-// Python equivalent:			Blender.Mathutils.TranslationMatrix																		
+// Function:      M_Mathutils_TranslationMatrix 
+// Python equivalent:       Blender.Mathutils.TranslationMatrix 
 //***************************************************************************
-static PyObject *M_Mathutils_TranslationMatrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_TranslationMatrix( PyObject * self,
+						PyObject * args )
 {
 	VectorObject *vec;
 	float *mat;
 
-    if (!PyArg_ParseTuple(args, "O!",  &vector_Type, &vec)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected vector\n"));
+	if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vec ) ) {
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected vector\n" ) );
 	}
-	if(vec->size != 3 && vec->size != 4){
-		return EXPP_ReturnPyObjError(PyExc_TypeError,
-			"vector must be 3D or 4D\n");
+	if( vec->size != 3 && vec->size != 4 ) {
+		return EXPP_ReturnPyObjError( PyExc_TypeError,
+					      "vector must be 3D or 4D\n" );
 	}
 
-	mat = PyMem_Malloc(4*4*sizeof(float));
-	Mat4One((float(*)[4])mat);
+	mat = PyMem_Malloc( 4 * 4 * sizeof( float ) );
+	Mat4One( ( float ( * )[4] ) mat );
 
 	mat[12] = vec->vec[0];
 	mat[13] = vec->vec[1];
 	mat[14] = vec->vec[2];
 
-	return newMatrixObject(mat, 4,4);
+	return newMatrixObject( mat, 4, 4 );
 }
 
 
 //***************************************************************************
-// Function:					M_Mathutils_ScaleMatrix																				
-// Python equivalent:			Blender.Mathutils.ScaleMatrix																		
+// Function:   M_Mathutils_ScaleMatrix  
+// Python equivalent:       Blender.Mathutils.ScaleMatrix 
 //***************************************************************************
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_ScaleMatrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args )
 {
 	float factor;
 	int matSize;
@@ -609,79 +652,111 @@ static PyObject *M_Mathutils_ScaleMatrix(PyObject *self, PyObject *args)
 	float norm = 0.0f;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "fi|O!",  &factor, &matSize, &vector_Type, &vec)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected float int and optional vector\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "fi|O!", &factor, &matSize, &vector_Type, &vec ) ) {
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected float int and optional vector\n" ) );
 	}
-	if(matSize != 2 && matSize != 3 && matSize != 4)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"can only return a 2x2 3x3 or 4x4 matrix\n");
-	if(vec){
-		if(vec->size > 2 && matSize == 2)
-			return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"please use 2D vectors when scaling in 2D\n");
+	if( matSize != 2 && matSize != 3 && matSize != 4 )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
+	if( vec ) {
+		if( vec->size > 2 && matSize == 2 )
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "please use 2D vectors when scaling in 2D\n" );
 	}
-	mat = PyMem_Malloc(matSize * matSize * sizeof(float));
+	mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
 
-	if(vec == NULL){ //scaling along axis
-		if(matSize == 2){
+	if( vec == NULL ) {	//scaling along axis
+		if( matSize == 2 ) {
 			mat[0] = factor;
-			mat[1] = 0.0f;	mat[2] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
 			mat[3] = factor;
-		}else {
+		} else {
 			mat[0] = factor;
-			mat[1] = 0.0f; mat[2] = 0.0f; mat[3] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
+			mat[3] = 0.0f;
 			mat[4] = factor;
-			mat[5] = 0.0f; mat[6] = 0.0f; mat[7] = 0.0f;
+			mat[5] = 0.0f;
+			mat[6] = 0.0f;
+			mat[7] = 0.0f;
 			mat[8] = factor;
 		}
-	}else{ //scaling in arbitrary direction
+	} else {		//scaling in arbitrary direction
 
 		//normalize arbitrary axis
-		for(x = 0; x < vec->size; x++){
+		for( x = 0; x < vec->size; x++ ) {
 			norm += vec->vec[x] * vec->vec[x];
 		}
-		norm = (float)sqrt(norm);
-		for(x = 0; x < vec->size; x++){
+		norm = ( float ) sqrt( norm );
+		for( x = 0; x < vec->size; x++ ) {
 			vec->vec[x] /= norm;
 		}
-		if(matSize ==2){
-			mat[0] = 1 + ((factor - 1) * (vec->vec[0] * vec->vec[0]));
-			mat[1] = ((factor - 1) * (vec->vec[0] * vec->vec[1]));
-			mat[2] = ((factor - 1) * (vec->vec[0] * vec->vec[1]));
-			mat[3] = 1 + ((factor - 1) * (vec->vec[1] * vec->vec[1]));
-		}else{
-			mat[0] = 1 + ((factor - 1) * (vec->vec[0] * vec->vec[0]));
-			mat[1] = ((factor - 1) * (vec->vec[0] * vec->vec[1]));
-			mat[2] = ((factor - 1) * (vec->vec[0] * vec->vec[2]));
-			mat[3] = ((factor - 1) * (vec->vec[0] * vec->vec[1]));
-			mat[4] = 1 + ((factor - 1) * (vec->vec[1] * vec->vec[1]));
-			mat[5] = ((factor - 1) * (vec->vec[1] * vec->vec[2]));
-			mat[6] = ((factor - 1) * (vec->vec[0] * vec->vec[2]));
-			mat[7] = ((factor - 1) * (vec->vec[1] * vec->vec[2]));
-			mat[8] = 1 + ((factor - 1) * (vec->vec[2] * vec->vec[2]));
+		if( matSize == 2 ) {
+			mat[0] = 1 +
+				( ( factor -
+				    1 ) * ( vec->vec[0] * vec->vec[0] ) );
+			mat[1] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
+			mat[2] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
+			mat[3] = 1 +
+				( ( factor -
+				    1 ) * ( vec->vec[1] * vec->vec[1] ) );
+		} else {
+			mat[0] = 1 +
+				( ( factor -
+				    1 ) * ( vec->vec[0] * vec->vec[0] ) );
+			mat[1] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
+			mat[2] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[2] ) );
+			mat[3] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
+			mat[4] = 1 +
+				( ( factor -
+				    1 ) * ( vec->vec[1] * vec->vec[1] ) );
+			mat[5] = ( ( factor -
+				     1 ) * ( vec->vec[1] * vec->vec[2] ) );
+			mat[6] = ( ( factor -
+				     1 ) * ( vec->vec[0] * vec->vec[2] ) );
+			mat[7] = ( ( factor -
+				     1 ) * ( vec->vec[1] * vec->vec[2] ) );
+			mat[8] = 1 +
+				( ( factor -
+				    1 ) * ( vec->vec[2] * vec->vec[2] ) );
 		}
 	}
-	if(matSize == 4){
+	if( matSize == 4 ) {
 		//resize matrix
-		mat[15] = 1.0f;	mat[14] = 0.0f;	mat[13] = 0.0f;
-		mat[12] = 0.0f;	mat[11] = 0.0f;
-		mat[10] = mat[8]; mat[9] = mat[7];
-		mat[8] = mat[6]; mat[7] = 0.0f;
-		mat[6] = mat[5]; mat[5] = mat[4];
-		mat[4] = mat[3]; mat[3] = 0.0f;
+		mat[15] = 1.0f;
+		mat[14] = 0.0f;
+		mat[13] = 0.0f;
+		mat[12] = 0.0f;
+		mat[11] = 0.0f;
+		mat[10] = mat[8];
+		mat[9] = mat[7];
+		mat[8] = mat[6];
+		mat[7] = 0.0f;
+		mat[6] = mat[5];
+		mat[5] = mat[4];
+		mat[4] = mat[3];
+		mat[3] = 0.0f;
 	}
-
 	//pass to matrix creation
-	return newMatrixObject (mat, matSize, matSize);
+	return newMatrixObject( mat, matSize, matSize );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_OrthoProjectionMatrix																				
-// Python equivalent:			Blender.Mathutils.OrthoProjectionMatrix																		
+// Function:     M_Mathutils_OrthoProjectionMatrix  
+// Python equivalent:        Blender.Mathutils.OrthoProjectionMatrix 
 //***************************************************************************
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
+						    PyObject * args )
 {
 	char *plane;
 	int matSize;
@@ -690,227 +765,295 @@ static PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject *self, PyObject *arg
 	float norm = 0.0f;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "si|O!",  &plane, &matSize, &vector_Type, &vec)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected string and int and optional vector\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "si|O!", &plane, &matSize, &vector_Type, &vec ) ) {
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected string and int and optional vector\n" ) );
 	}
-	if(matSize != 2 && matSize != 3 && matSize != 4)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"can only return a 2x2 3x3 or 4x4 matrix\n");
-	if(vec){
-		if(vec->size > 2 && matSize == 2)
-			return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"please use 2D vectors when scaling in 2D\n");
+	if( matSize != 2 && matSize != 3 && matSize != 4 )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
+	if( vec ) {
+		if( vec->size > 2 && matSize == 2 )
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "please use 2D vectors when scaling in 2D\n" );
 	}
-	if(vec == NULL){ //ortho projection onto cardinal plane
-		if (((strcmp(plane, "x") == 0) || (strcmp(plane, "X") == 0)) &&
-			matSize == 2){
-			mat = PyMem_Malloc(matSize * matSize * sizeof(float));
+	if( vec == NULL ) {	//ortho projection onto cardinal plane
+		if( ( ( strcmp( plane, "x" ) == 0 )
+		      || ( strcmp( plane, "X" ) == 0 ) ) && matSize == 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;	mat[2] = 0.0f;	mat[3] = 0.0f;
-		}else if(((strcmp(plane, "y") == 0) || (strcmp(plane, "Y") == 0)) &&
-			matSize == 2){
-			mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-			mat[0] = 0.0f;	mat[1] = 0.0f;	mat[2] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
+			mat[3] = 0.0f;
+		} else if( ( ( strcmp( plane, "y" ) == 0 )
+			     || ( strcmp( plane, "Y" ) == 0 ) )
+			   && matSize == 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
+			mat[0] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
 			mat[3] = 1.0f;
-		}else if(((strcmp(plane, "xy") == 0) || (strcmp(plane, "XY") == 0)) &&
-			matSize > 2){
-			mat = PyMem_Malloc(matSize * matSize * sizeof(float));
+		} else if( ( ( strcmp( plane, "xy" ) == 0 )
+			     || ( strcmp( plane, "XY" ) == 0 ) )
+			   && matSize > 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;	mat[2] = 0.0f;	mat[3] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
+			mat[3] = 0.0f;
 			mat[4] = 1.0f;
-			mat[5] = 0.0f;	mat[6] = 0.0f;	mat[7] = 0.0f;	mat[8] = 0.0f;
-		}else if(((strcmp(plane, "xz") == 0) || (strcmp(plane, "XZ") == 0)) &&
-			matSize > 2){
-			mat = PyMem_Malloc(matSize * matSize * sizeof(float));
+			mat[5] = 0.0f;
+			mat[6] = 0.0f;
+			mat[7] = 0.0f;
+			mat[8] = 0.0f;
+		} else if( ( ( strcmp( plane, "xz" ) == 0 )
+			     || ( strcmp( plane, "XZ" ) == 0 ) )
+			   && matSize > 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;	mat[2] = 0.0f;	mat[3] = 0.0f;	mat[4] = 0.0f;
-			mat[5] = 0.0f;	mat[6] = 0.0f;	mat[7] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
+			mat[3] = 0.0f;
+			mat[4] = 0.0f;
+			mat[5] = 0.0f;
+			mat[6] = 0.0f;
+			mat[7] = 0.0f;
 			mat[8] = 1.0f;
-		}else if(((strcmp(plane, "yz") == 0) || (strcmp(plane, "YZ") == 0)) &&
-			matSize > 2){
-			mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-			mat[0] = 0.0f;	mat[1] = 0.0f;	mat[2] = 0.0f;	mat[3] = 0.0f;
+		} else if( ( ( strcmp( plane, "yz" ) == 0 )
+			     || ( strcmp( plane, "YZ" ) == 0 ) )
+			   && matSize > 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
+			mat[0] = 0.0f;
+			mat[1] = 0.0f;
+			mat[2] = 0.0f;
+			mat[3] = 0.0f;
 			mat[4] = 1.0f;
-			mat[5] = 0.0f;	mat[6] = 0.0f;	mat[7] = 0.0f;
+			mat[5] = 0.0f;
+			mat[6] = 0.0f;
+			mat[7] = 0.0f;
 			mat[8] = 1.0f;
-		}else{
-			return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"unknown plane - expected: x, y, xy, xz, yz\n");
+		} else {
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "unknown plane - expected: x, y, xy, xz, yz\n" );
 		}
-	}else{ //arbitrary plane
+	} else {		//arbitrary plane
 		//normalize arbitrary axis
-		for(x = 0; x < vec->size; x++){
+		for( x = 0; x < vec->size; x++ ) {
 			norm += vec->vec[x] * vec->vec[x];
 		}
-		norm = (float)sqrt(norm);
+		norm = ( float ) sqrt( norm );
 
-		for(x = 0; x < vec->size; x++){
+		for( x = 0; x < vec->size; x++ ) {
 			vec->vec[x] /= norm;
 		}
 
-		if (((strcmp(plane, "r") == 0) || (strcmp(plane, "R") == 0)) &&
-			matSize == 2){
-				mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-				mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
-				mat[1] = - (vec->vec[0] * vec->vec[1]);
-				mat[2] = - (vec->vec[0] * vec->vec[1]);
-				mat[3] = 1 - (vec->vec[1] * vec->vec[1]);
-		}else if (((strcmp(plane, "r") == 0) || (strcmp(plane, "R") == 0)) &&
-			matSize > 2){
-				mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-				mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
-				mat[1] = - (vec->vec[0] * vec->vec[1]);
-				mat[2] = - (vec->vec[0] * vec->vec[2]);
-				mat[3] = - (vec->vec[0] * vec->vec[1]);
-				mat[4] = 1 - (vec->vec[1] * vec->vec[1]);
-				mat[5] = - (vec->vec[1] * vec->vec[2]);
-				mat[6] = - (vec->vec[0] * vec->vec[2]);
-				mat[7] = - (vec->vec[1] * vec->vec[2]);
-				mat[8] = 1 - (vec->vec[2] * vec->vec[2]);
-		}else{
-			return EXPP_ReturnPyObjError(PyExc_AttributeError,
-				"unknown plane - expected: 'r' expected for axis designation\n");
+		if( ( ( strcmp( plane, "r" ) == 0 )
+		      || ( strcmp( plane, "R" ) == 0 ) ) && matSize == 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
+			mat[0] = 1 - ( vec->vec[0] * vec->vec[0] );
+			mat[1] = -( vec->vec[0] * vec->vec[1] );
+			mat[2] = -( vec->vec[0] * vec->vec[1] );
+			mat[3] = 1 - ( vec->vec[1] * vec->vec[1] );
+		} else if( ( ( strcmp( plane, "r" ) == 0 )
+			     || ( strcmp( plane, "R" ) == 0 ) )
+			   && matSize > 2 ) {
+			mat = PyMem_Malloc( matSize * matSize *
+					    sizeof( float ) );
+			mat[0] = 1 - ( vec->vec[0] * vec->vec[0] );
+			mat[1] = -( vec->vec[0] * vec->vec[1] );
+			mat[2] = -( vec->vec[0] * vec->vec[2] );
+			mat[3] = -( vec->vec[0] * vec->vec[1] );
+			mat[4] = 1 - ( vec->vec[1] * vec->vec[1] );
+			mat[5] = -( vec->vec[1] * vec->vec[2] );
+			mat[6] = -( vec->vec[0] * vec->vec[2] );
+			mat[7] = -( vec->vec[1] * vec->vec[2] );
+			mat[8] = 1 - ( vec->vec[2] * vec->vec[2] );
+		} else {
+			return EXPP_ReturnPyObjError( PyExc_AttributeError,
+						      "unknown plane - expected: 'r' expected for axis designation\n" );
 		}
 	}
 
-	if(matSize == 4){
+	if( matSize == 4 ) {
 		//resize matrix
-		mat[15] = 1.0f;	mat[14] = 0.0f;
-		mat[13] = 0.0f;	mat[12] = 0.0f;
-		mat[11] = 0.0f;	mat[10] = mat[8];
-		mat[9] = mat[7];mat[8] = mat[6];
-		mat[7] = 0.0f;	mat[6] = mat[5];
-		mat[5] = mat[4];mat[4] = mat[3];
+		mat[15] = 1.0f;
+		mat[14] = 0.0f;
+		mat[13] = 0.0f;
+		mat[12] = 0.0f;
+		mat[11] = 0.0f;
+		mat[10] = mat[8];
+		mat[9] = mat[7];
+		mat[8] = mat[6];
+		mat[7] = 0.0f;
+		mat[6] = mat[5];
+		mat[5] = mat[4];
+		mat[4] = mat[3];
 		mat[3] = 0.0f;
 	}
-
 	//pass to matrix creation
-	return newMatrixObject (mat, matSize, matSize);
+	return newMatrixObject( mat, matSize, matSize );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_ShearMatrix																				
-// Python equivalent:			Blender.Mathutils.ShearMatrix																		
+// Function:      M_Mathutils_ShearMatrix  
+// Python equivalent:       Blender.Mathutils.ShearMatrix 
 //***************************************************************************
-static PyObject *M_Mathutils_ShearMatrix(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args )
 {
 	float factor;
 	int matSize;
 	char *plane;
 	float *mat;
 
-	if (!PyArg_ParseTuple(args, "sfi",  &plane, &factor, &matSize)){
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected string float and int\n"));
+	if( !PyArg_ParseTuple( args, "sfi", &plane, &factor, &matSize ) ) {
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected string float and int\n" ) );
 	}
 
-	if(matSize != 2 && matSize != 3 && matSize != 4)
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"can only return a 2x2 3x3 or 4x4 matrix\n");
-
-	if (((strcmp(plane, "x") == 0) || (strcmp(plane, "X") == 0)) &&
-		matSize == 2){
-		mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-		mat[0] = 1.0f;	 mat[1] = 0.0f;	
-		mat[2] = factor; mat[3] = 1.0f;
-	}else if(((strcmp(plane, "y") == 0) || (strcmp(plane, "Y") == 0)) &&
-		matSize == 2){
-		mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-		mat[0] = 1.0f;	mat[1] = factor;	
-		mat[2] = 0.0f;	mat[3] = 1.0f;
-	}else if(((strcmp(plane, "xy") == 0) || (strcmp(plane, "XY") == 0)) &&
-		matSize > 2){
-		mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-		mat[0] = 1.0f;	mat[1] = 0.0f;	mat[2] = 0.0f;	mat[3] = 0.0f;
-		mat[4] = 1.0f;	mat[5] = 0.0f;	
-		mat[6] = factor; mat[7] = factor; mat[8] = 0.0f;
-	}else if(((strcmp(plane, "xz") == 0) || (strcmp(plane, "XZ") == 0)) &&
-		matSize > 2){
-		mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-		mat[0] = 1.0f;	mat[1] = 0.0f;	mat[2] = 0.0f;	
-		mat[3] = factor; mat[4] = 1.0f; mat[5] = factor;
-		mat[6] = 0.0f;	mat[7] = 0.0f;	mat[8] = 1.0f;
-	}else if(((strcmp(plane, "yz") == 0) || (strcmp(plane, "YZ") == 0)) &&
-		matSize > 2){
-		mat = PyMem_Malloc(matSize * matSize * sizeof(float));
-		mat[0] = 1.0f;	mat[1] = factor; mat[2] = factor;
-		mat[3] = 0.0f;	mat[4] = 1.0f;
-		mat[5] = 0.0f;	mat[6] = 0.0f;	mat[7] = 0.0f;
+	if( matSize != 2 && matSize != 3 && matSize != 4 )
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
+
+	if( ( ( strcmp( plane, "x" ) == 0 ) || ( strcmp( plane, "X" ) == 0 ) )
+	    && matSize == 2 ) {
+		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+		mat[0] = 1.0f;
+		mat[1] = 0.0f;
+		mat[2] = factor;
+		mat[3] = 1.0f;
+	} else if( ( ( strcmp( plane, "y" ) == 0 )
+		     || ( strcmp( plane, "Y" ) == 0 ) ) && matSize == 2 ) {
+		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+		mat[0] = 1.0f;
+		mat[1] = factor;
+		mat[2] = 0.0f;
+		mat[3] = 1.0f;
+	} else if( ( ( strcmp( plane, "xy" ) == 0 )
+		     || ( strcmp( plane, "XY" ) == 0 ) ) && matSize > 2 ) {
+		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+		mat[0] = 1.0f;
+		mat[1] = 0.0f;
+		mat[2] = 0.0f;
+		mat[3] = 0.0f;
+		mat[4] = 1.0f;
+		mat[5] = 0.0f;
+		mat[6] = factor;
+		mat[7] = factor;
+		mat[8] = 0.0f;
+	} else if( ( ( strcmp( plane, "xz" ) == 0 )
+		     || ( strcmp( plane, "XZ" ) == 0 ) ) && matSize > 2 ) {
+		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+		mat[0] = 1.0f;
+		mat[1] = 0.0f;
+		mat[2] = 0.0f;
+		mat[3] = factor;
+		mat[4] = 1.0f;
+		mat[5] = factor;
+		mat[6] = 0.0f;
+		mat[7] = 0.0f;
+		mat[8] = 1.0f;
+	} else if( ( ( strcmp( plane, "yz" ) == 0 )
+		     || ( strcmp( plane, "YZ" ) == 0 ) ) && matSize > 2 ) {
+		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+		mat[0] = 1.0f;
+		mat[1] = factor;
+		mat[2] = factor;
+		mat[3] = 0.0f;
+		mat[4] = 1.0f;
+		mat[5] = 0.0f;
+		mat[6] = 0.0f;
+		mat[7] = 0.0f;
 		mat[8] = 1.0f;
-	}else{
-		return EXPP_ReturnPyObjError(PyExc_AttributeError,
-			"expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n");
+	} else {
+		return EXPP_ReturnPyObjError( PyExc_AttributeError,
+					      "expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n" );
 	}
 
-	if(matSize == 4){
+	if( matSize == 4 ) {
 		//resize matrix
-		mat[15] = 1.0f;	mat[14] = 0.0f;
-		mat[13] = 0.0f;	mat[12] = 0.0f;
-		mat[11] = 0.0f;	mat[10] = mat[8];
-		mat[9] = mat[7];mat[8] = mat[6];
-		mat[7] = 0.0f;	mat[6] = mat[5];
-		mat[5] = mat[4];mat[4] = mat[3];
+		mat[15] = 1.0f;
+		mat[14] = 0.0f;
+		mat[13] = 0.0f;
+		mat[12] = 0.0f;
+		mat[11] = 0.0f;
+		mat[10] = mat[8];
+		mat[9] = mat[7];
+		mat[8] = mat[6];
+		mat[7] = 0.0f;
+		mat[6] = mat[5];
+		mat[5] = mat[4];
+		mat[4] = mat[3];
 		mat[3] = 0.0f;
 	}
-
 	//pass to matrix creation
-	return newMatrixObject (mat, matSize, matSize);
+	return newMatrixObject( mat, matSize, matSize );
 }
 
 //***************************************************************************
 //Begin Matrix Utils
 
-static PyObject *M_Mathutils_CopyMat(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CopyMat( PyObject * self, PyObject * args )
 {
 	MatrixObject *matrix;
 	float *mat;
-	int x,y,z;
+	int x, y, z;
 
-	if(!PyArg_ParseTuple(args, "O!", &matrix_Type, &matrix))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,	
-				"expected matrix\n"));
+	if( !PyArg_ParseTuple( args, "O!", &matrix_Type, &matrix ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected matrix\n" ) );
 
-	mat = PyMem_Malloc(matrix->rowSize * matrix->colSize * sizeof(float));
+	mat = PyMem_Malloc( matrix->rowSize * matrix->colSize *
+			    sizeof( float ) );
 
 	z = 0;
-	for(x = 0; x < matrix->rowSize; x++){
-		for(y = 0; y < matrix->colSize; y++){
+	for( x = 0; x < matrix->rowSize; x++ ) {
+		for( y = 0; y < matrix->colSize; y++ ) {
 			mat[z] = matrix->matrix[x][y];
 			z++;
 		}
 	}
 
-	return (PyObject*)newMatrixObject (mat, matrix->rowSize, matrix->colSize);
+	return ( PyObject * ) newMatrixObject( mat, matrix->rowSize,
+					       matrix->colSize );
 }
-static PyObject *M_Mathutils_MatMultVec(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_MatMultVec( PyObject * self, PyObject * args )
 {
 
-	PyObject * ob1 = NULL;
-	PyObject * ob2 = NULL;
-	MatrixObject * mat;
-	VectorObject * vec;
-	float * vecNew;
+	PyObject *ob1 = NULL;
+	PyObject *ob2 = NULL;
+	MatrixObject *mat;
+	VectorObject *vec;
+	float *vecNew;
 	int x, y;
 	int z = 0;
 	float dot = 0.0f;
 
 	//get pyObjects
-	if(!PyArg_ParseTuple(args, "O!O!", &matrix_Type, &ob1, &vector_Type, &ob2))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,	
-				"matrix and vector object expected - in that order\n"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!O!", &matrix_Type, &ob1, &vector_Type, &ob2 ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "matrix and vector object expected - in that order\n" ) );
+
+	mat = ( MatrixObject * ) ob1;
+	vec = ( VectorObject * ) ob2;
 
-	mat = (MatrixObject*)ob1;
-	vec = (VectorObject*)ob2;
+	if( mat->rowSize != vec->size )
+		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
+						"matrix row size and vector size must be the same\n" ) );
 
-	if(mat->rowSize != vec->size)
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,	
-				"matrix row size and vector size must be the same\n"));
+	vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
 
-	vecNew = PyMem_Malloc (vec->size*sizeof (float));
-	
-	for(x = 0; x < mat->rowSize; x++){
-		for(y = 0; y < mat->colSize; y++){
+	for( x = 0; x < mat->rowSize; x++ ) {
+		for( y = 0; y < mat->colSize; y++ ) {
 			dot += mat->matrix[x][y] * vec->vec[y];
 		}
 		vecNew[z] = dot;
@@ -918,14 +1061,14 @@ static PyObject *M_Mathutils_MatMultVec(PyObject *self, PyObject *args)
 		dot = 0;
 	}
 
-	return (PyObject *)newVectorObject(vecNew, vec->size);
+	return ( PyObject * ) newVectorObject( vecNew, vec->size );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_Quaternion																				
-// Python equivalent:			Blender.Mathutils.Quaternion																		
+// Function:     M_Mathutils_Quaternion   
+// Python equivalent:       Blender.Mathutils.Quaternion   
 //***************************************************************************
-static PyObject *M_Mathutils_Quaternion(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Quaternion( PyObject * self, PyObject * args )
 {
 	PyObject *listObject;
 	float *vec;
@@ -934,254 +1077,270 @@ static PyObject *M_Mathutils_Quaternion(PyObject *self, PyObject *args)
 	int x;
 	float norm;
 
-	if (!PyArg_ParseTuple(args, "O!|f", &PyList_Type, &listObject, &angle))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected list and optional float\n"));
-
-	if(PyList_Size(listObject) != 4 && PyList_Size(listObject) != 3)
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"3 or 4 expected floats for the quaternion\n"));
-
-	vec = PyMem_Malloc (PyList_Size(listObject)*sizeof (float));
-	for (x = 0; x < PyList_Size(listObject); x++) {
-		if (!PyArg_Parse(PyList_GetItem(listObject, x), "f", &vec[x]))
-			return EXPP_ReturnPyObjError (PyExc_TypeError,
-							"python list not parseable\n");		
+	if( !PyArg_ParseTuple
+	    ( args, "O!|f", &PyList_Type, &listObject, &angle ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected list and optional float\n" ) );
+
+	if( PyList_Size( listObject ) != 4 && PyList_Size( listObject ) != 3 )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"3 or 4 expected floats for the quaternion\n" ) );
+
+	vec = PyMem_Malloc( PyList_Size( listObject ) * sizeof( float ) );
+	for( x = 0; x < PyList_Size( listObject ); x++ ) {
+		if( !PyArg_Parse
+		    ( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
+			return EXPP_ReturnPyObjError( PyExc_TypeError,
+						      "python list not parseable\n" );
 	}
 
-	if(PyList_Size(listObject) == 3){ //an axis of rotation
-		norm = (float)sqrt(vec[0] * vec[0] + vec[1] * vec[1] +
-						   vec[2] * vec[2]);
-
-		vec[0] /= norm;	vec[1] /= norm;	vec[2] /= norm;
-
-		angle = angle * (float)(Py_PI/180);
-		quat = PyMem_Malloc(4*sizeof(float));
-		quat[0] = (float)(cos((double)(angle)/2));
-		quat[1] = (float)(sin((double)(angle)/2)) * vec[0];
-		quat[2] = (float)(sin((double)(angle)/2)) * vec[1];
-		quat[3] = (float)(sin((double)(angle)/2)) * vec[2];
-
-		PyMem_Free(vec);
-
-		return newQuaternionObject(quat);
-	}else
-		return newQuaternionObject(vec); 
+	if( PyList_Size( listObject ) == 3 ) {	//an axis of rotation
+		norm = ( float ) sqrt( vec[0] * vec[0] + vec[1] * vec[1] +
+				       vec[2] * vec[2] );
+
+		vec[0] /= norm;
+		vec[1] /= norm;
+		vec[2] /= norm;
+
+		angle = angle * ( float ) ( Py_PI / 180 );
+		quat = PyMem_Malloc( 4 * sizeof( float ) );
+		quat[0] = ( float ) ( cos( ( double ) ( angle ) / 2 ) );
+		quat[1] =
+			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[0];
+		quat[2] =
+			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[1];
+		quat[3] =
+			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[2];
+
+		PyMem_Free( vec );
+
+		return newQuaternionObject( quat );
+	} else
+		return newQuaternionObject( vec );
 }
 
 //***************************************************************************
 //Begin Quaternion Utils
 
-static PyObject *M_Mathutils_CopyQuat(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CopyQuat( PyObject * self, PyObject * args )
 {
-	QuaternionObject * quatU;
-	float * quat;
+	QuaternionObject *quatU;
+	float *quat;
 
-	if (!PyArg_ParseTuple(args, "O!", &quaternion_Type, &quatU))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Quaternion type"));
+	if( !PyArg_ParseTuple( args, "O!", &quaternion_Type, &quatU ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Quaternion type" ) );
 
-	quat = PyMem_Malloc (4*sizeof(float));
+	quat = PyMem_Malloc( 4 * sizeof( float ) );
 	quat[0] = quatU->quat[0];
 	quat[1] = quatU->quat[1];
 	quat[2] = quatU->quat[2];
 	quat[3] = quatU->quat[3];
 
-	return (PyObject*)newQuaternionObject(quat);
+	return ( PyObject * ) newQuaternionObject( quat );
 }
 
-static PyObject *M_Mathutils_CrossQuats(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CrossQuats( PyObject * self, PyObject * args )
 {
-	QuaternionObject * quatU;
-	QuaternionObject * quatV;
-	float * quat;
-
-	if (!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, 
-		&quaternion_Type, &quatV))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Quaternion types"));
-	quat = PyMem_Malloc (4*sizeof(float));
-	QuatMul(quat, quatU->quat, quatV->quat);
-
-	return (PyObject*)newQuaternionObject(quat);
+	QuaternionObject *quatU;
+	QuaternionObject *quatV;
+	float *quat;
+
+	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
+			       &quaternion_Type, &quatV ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Quaternion types" ) );
+	quat = PyMem_Malloc( 4 * sizeof( float ) );
+	QuatMul( quat, quatU->quat, quatV->quat );
+
+	return ( PyObject * ) newQuaternionObject( quat );
 }
 
-static PyObject *M_Mathutils_DotQuats(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_DotQuats( PyObject * self, PyObject * args )
 {
-	QuaternionObject * quatU;
-	QuaternionObject * quatV;
-	float * quat;
+	QuaternionObject *quatU;
+	QuaternionObject *quatV;
+	float *quat;
 	int x;
 	float dot = 0.0f;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, 
-		&quaternion_Type, &quatV))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Quaternion types"));
+	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
+			       &quaternion_Type, &quatV ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Quaternion types" ) );
 
-	quat = PyMem_Malloc (4*sizeof(float));
-	for(x = 0; x < 4; x++){
+	quat = PyMem_Malloc( 4 * sizeof( float ) );
+	for( x = 0; x < 4; x++ ) {
 		dot += quatU->quat[x] * quatV->quat[x];
 	}
 
-	return PyFloat_FromDouble((double)(dot));
+	return PyFloat_FromDouble( ( double ) ( dot ) );
 }
 
-static PyObject *M_Mathutils_DifferenceQuats(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_DifferenceQuats( PyObject * self,
+					      PyObject * args )
 {
-	QuaternionObject * quatU;
-	QuaternionObject * quatV;
-	float * quat;
-	float * tempQuat;
+	QuaternionObject *quatU;
+	QuaternionObject *quatV;
+	float *quat;
+	float *tempQuat;
 	int x;
 	float dot = 0.0f;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, 
-		&quatU, &quaternion_Type, &quatV))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Quaternion types"));
+	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type,
+			       &quatU, &quaternion_Type, &quatV ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Quaternion types" ) );
 
-	quat = PyMem_Malloc (4*sizeof(float));
-	tempQuat = PyMem_Malloc (4*sizeof(float));
+	quat = PyMem_Malloc( 4 * sizeof( float ) );
+	tempQuat = PyMem_Malloc( 4 * sizeof( float ) );
 
 	tempQuat[0] = quatU->quat[0];
 	tempQuat[1] = -quatU->quat[1];
 	tempQuat[2] = -quatU->quat[2];
 	tempQuat[3] = -quatU->quat[3];
 
-	dot= (float)sqrt((double)tempQuat[0] * (double)tempQuat[0] +
-				(double)tempQuat[1] * (double)tempQuat[1] +
-				(double)tempQuat[2] * (double)tempQuat[2] +
-				(double)tempQuat[3] * (double)tempQuat[3]);
+	dot = ( float ) sqrt( ( double ) tempQuat[0] * ( double ) tempQuat[0] +
+			      ( double ) tempQuat[1] * ( double ) tempQuat[1] +
+			      ( double ) tempQuat[2] * ( double ) tempQuat[2] +
+			      ( double ) tempQuat[3] *
+			      ( double ) tempQuat[3] );
 
-	for(x = 0; x < 4; x++){
-		tempQuat[x] /= (dot * dot);
+	for( x = 0; x < 4; x++ ) {
+		tempQuat[x] /= ( dot * dot );
 	}
-	QuatMul(quat, tempQuat, quatV->quat);
+	QuatMul( quat, tempQuat, quatV->quat );
 
-	return (PyObject*)newQuaternionObject(quat);
+	return ( PyObject * ) newQuaternionObject( quat );
 }
 
-static PyObject *M_Mathutils_Slerp(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Slerp( PyObject * self, PyObject * args )
 {
-	QuaternionObject * quatU;
-	QuaternionObject * quatV;
-	float * quat;
-	float param, x,y, cosD, sinD, deltaD, IsinD, val;
+	QuaternionObject *quatU;
+	QuaternionObject *quatV;
+	float *quat;
+	float param, x, y, cosD, sinD, deltaD, IsinD, val;
 	int flag, z;
 
-	if (!PyArg_ParseTuple(args, "O!O!f", &quaternion_Type, 
-		&quatU, &quaternion_Type, &quatV, &param))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Quaternion types and float"));
+	if( !PyArg_ParseTuple( args, "O!O!f", &quaternion_Type,
+			       &quatU, &quaternion_Type, &quatV, &param ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Quaternion types and float" ) );
+
+	quat = PyMem_Malloc( 4 * sizeof( float ) );
 
-	quat = PyMem_Malloc (4*sizeof(float));
-	
-	cosD = quatU->quat[0] * quatV->quat[0] + 
-		    quatU->quat[1] * quatV->quat[1] + 
-			quatU->quat[2] * quatV->quat[2] + 
-			quatU->quat[3] * quatV->quat[3]; 
+	cosD = quatU->quat[0] * quatV->quat[0] +
+		quatU->quat[1] * quatV->quat[1] +
+		quatU->quat[2] * quatV->quat[2] +
+		quatU->quat[3] * quatV->quat[3];
 
 	flag = 0;
-	if(cosD< 0.0f){
+	if( cosD < 0.0f ) {
 		flag = 1;
 		cosD = -cosD;
 	}
-	if(cosD > .99999f){
+	if( cosD > .99999f ) {
 		x = 1.0f - param;
 		y = param;
-	}else{
-		sinD = (float)sqrt(1.0f - cosD * cosD);
-		deltaD = (float)atan2(sinD, cosD);
-		IsinD = 1.0f/sinD;
-		x = (float)sin((1.0f - param) * deltaD) * IsinD;
-		y = (float)sin(param * deltaD) * IsinD;
+	} else {
+		sinD = ( float ) sqrt( 1.0f - cosD * cosD );
+		deltaD = ( float ) atan2( sinD, cosD );
+		IsinD = 1.0f / sinD;
+		x = ( float ) sin( ( 1.0f - param ) * deltaD ) * IsinD;
+		y = ( float ) sin( param * deltaD ) * IsinD;
 	}
-	for(z = 0; z < 4; z++){
+	for( z = 0; z < 4; z++ ) {
 		val = quatV->quat[z];
-		if(val) val = -val;
-		quat[z] = (quatU->quat[z] * x) + (val * y);
+		if( val )
+			val = -val;
+		quat[z] = ( quatU->quat[z] * x ) + ( val * y );
 	}
-	return (PyObject*)newQuaternionObject(quat);
+	return ( PyObject * ) newQuaternionObject( quat );
 }
 
 //***************************************************************************
-// Function:					M_Mathutils_Euler																			
-// Python equivalent:			Blender.Mathutils.Euler																		
+// Function:     M_Mathutils_Euler        
+// Python equivalent:      Blender.Mathutils.Euler    
 //***************************************************************************
-static PyObject *M_Mathutils_Euler(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_Euler( PyObject * self, PyObject * args )
 {
 	PyObject *listObject;
 	float *vec;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &listObject))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected list\n"));
+	if( !PyArg_ParseTuple( args, "O!", &PyList_Type, &listObject ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected list\n" ) );
 
-	if(PyList_Size(listObject) != 3)
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-							"only 3d eulers are supported\n");
+	if( PyList_Size( listObject ) != 3 )
+		return EXPP_ReturnPyObjError( PyExc_TypeError,
+					      "only 3d eulers are supported\n" );
 
-	vec = PyMem_Malloc (3*sizeof (float));
-	for (x = 0; x < 3; x++) {
-		if (!PyArg_Parse(PyList_GetItem(listObject, x), "f", &vec[x]))
-			return EXPP_ReturnPyObjError (PyExc_TypeError,
-							"python list not parseable\n");		
+	vec = PyMem_Malloc( 3 * sizeof( float ) );
+	for( x = 0; x < 3; x++ ) {
+		if( !PyArg_Parse
+		    ( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
+			return EXPP_ReturnPyObjError( PyExc_TypeError,
+						      "python list not parseable\n" );
 	}
 
-	return (PyObject*)newEulerObject(vec);
+	return ( PyObject * ) newEulerObject( vec );
 }
 
 
 //***************************************************************************
 //Begin Euler Util
 
-  static PyObject *M_Mathutils_CopyEuler(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_CopyEuler( PyObject * self, PyObject * args )
 {
-	EulerObject * eulU;
-	float * eul;
+	EulerObject *eulU;
+	float *eul;
 
-	if (!PyArg_ParseTuple(args, "O!", &euler_Type, &eulU))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected Euler types"));
+	if( !PyArg_ParseTuple( args, "O!", &euler_Type, &eulU ) )
+		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+						"expected Euler types" ) );
 
-	eul = PyMem_Malloc (3*sizeof(float));
+	eul = PyMem_Malloc( 3 * sizeof( float ) );
 	eul[0] = eulU->eul[0];
 	eul[1] = eulU->eul[1];
 	eul[2] = eulU->eul[2];
 
-	return (PyObject*)newEulerObject(eul);
+	return ( PyObject * ) newEulerObject( eul );
 }
 
-static PyObject *M_Mathutils_RotateEuler(PyObject *self, PyObject *args)
+static PyObject *M_Mathutils_RotateEuler( PyObject * self, PyObject * args )
 {
-	EulerObject * Eul;
+	EulerObject *Eul;
 	float angle;
 	char *axis;
 	int x;
 
-	if (!PyArg_ParseTuple(args, "O!fs", &euler_Type, &Eul, &angle, &axis))
-		return (EXPP_ReturnPyObjError (PyExc_TypeError,	
-		"expected euler type & float & string"));
+	if( !PyArg_ParseTuple
+	    ( args, "O!fs", &euler_Type, &Eul, &angle, &axis ) )
+		return ( EXPP_ReturnPyObjError
+			 ( PyExc_TypeError,
+			   "expected euler type & float & string" ) );
 
-	angle *= (float)(Py_PI/180);
-	for(x = 0; x < 3; x++){
-		Eul->eul[x] *= (float)(Py_PI/180);
+	angle *= ( float ) ( Py_PI / 180 );
+	for( x = 0; x < 3; x++ ) {
+		Eul->eul[x] *= ( float ) ( Py_PI / 180 );
 	}
-	euler_rot(Eul->eul, angle, *axis);
-	for(x = 0; x < 3; x++){
-		Eul->eul[x] *= (float)(180/Py_PI);
+	euler_rot( Eul->eul, angle, *axis );
+	for( x = 0; x < 3; x++ ) {
+		Eul->eul[x] *= ( float ) ( 180 / Py_PI );
 	}
 
-	return EXPP_incr_ret(Py_None);
+	return EXPP_incr_ret( Py_None );
 }
 
 //***************************************************************************
-// Function:					Mathutils_Init																					
+// Function:      Mathutils_Init     
 //***************************************************************************
-PyObject *Mathutils_Init (void)
+PyObject *Mathutils_Init( void )
 {
-	PyObject *mod= Py_InitModule3("Blender.Mathutils", M_Mathutils_methods, M_Mathutils_doc);
-	return(mod);
+	PyObject *mod =
+		Py_InitModule3( "Blender.Mathutils", M_Mathutils_methods,
+				M_Mathutils_doc );
+	return ( mod );
 }