Exppython:

- Added "Radio" to Material modes
- Fixed bug in bone.getParent (bug report on blender.org py forum)
- Added more types to object.shareFrom (method to share obdata)
- Added nmesh.get/setMaxSmoothAngle and nmesh.get/setSubDivLevels
- Updated NMesh doc

6 files changed, 1534 insertions, 1355 deletions

diff --git a/source/blender/python/api2_2x/Bone.c b/source/blender/python/api2_2x/Bone.c
index 226ce3b2898..c0dade51140 100644
--- a/source/blender/python/api2_2x/Bone.c
+++ b/source/blender/python/api2_2x/Bone.c
@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
@@ -43,37 +43,37 @@
 
 
 /*****************************************************************************/
-/* Python API function prototypes for the Bone module.                       */
+/* Python API function prototypes for the Bone module.											 */
 /*****************************************************************************/
 static PyObject *M_Bone_New(PyObject *self, PyObject *args, PyObject *keywords);
 
 
 /*****************************************************************************/
-/* The following string definitions are used for documentation strings.      */
-/* In Python these will be written to the console when doing a               */
-/* Blender.Armature.Bone.__doc__                                             */
+/* The following string definitions are used for documentation strings.			 */
+/* In Python these will be written to the console when doing a							 */
+/* Blender.Armature.Bone.__doc__																						 */
 /*****************************************************************************/
 char M_Bone_doc[] =
 "The Blender Bone module\n\n\
 This module provides control over **Bone Data** objects in Blender.\n\n\
 Example::\n\n\
-  from Blender import Armature.Bone\n\
-  l = Armature.Bone.New()\n";
+	from Blender import Armature.Bone\n\
+	l = Armature.Bone.New()\n";
 
 char M_Bone_New_doc[] =
 "(name) - return a new Bone of name 'name'.";
 
 
 /*****************************************************************************/
-/* Python method structure definition for Blender.Armature.Bone module:      */
+/* Python method structure definition for Blender.Armature.Bone module:			 */
 /*****************************************************************************/
 struct PyMethodDef M_Bone_methods[] = {
-  {"New",(PyCFunction)M_Bone_New, METH_VARARGS|METH_KEYWORDS,M_Bone_New_doc},
-  {NULL, NULL, 0, NULL}
+	{"New",(PyCFunction)M_Bone_New, METH_VARARGS|METH_KEYWORDS,M_Bone_New_doc},
+	{NULL, NULL, 0, NULL}
 };
 
 /*****************************************************************************/
-/* Python BPy_Bone methods declarations:                                     */
+/* Python BPy_Bone methods declarations:																		 */
 /*****************************************************************************/
 static PyObject *Bone_getName(BPy_Bone *self);
 static PyObject *Bone_getRoll(BPy_Bone *self);
@@ -96,45 +96,45 @@ static PyObject *Bone_setQuat(BPy_Bone *self, PyObject *args);
 //static PyObject *Bone_setChildren(BPy_Bone *self, PyObject *args);
 
 /*****************************************************************************/
-/* Python BPy_Bone methods table:                                            */
+/* Python BPy_Bone methods table:																						 */
 /*****************************************************************************/
 static PyMethodDef BPy_Bone_methods[] = {
  /* name, method, flags, doc */
-  {"getName", (PyCFunction)Bone_getName, METH_NOARGS,  "() - return Bone name"},
-  {"getRoll", (PyCFunction)Bone_getRoll, METH_NOARGS,  "() - return Bone roll"},
-  {"getHead", (PyCFunction)Bone_getHead, METH_NOARGS,  "() - return Bone head"},
-  {"getTail", (PyCFunction)Bone_getTail, METH_NOARGS,  "() - return Bone tail"},
-  {"getLoc", (PyCFunction)Bone_getLoc, METH_NOARGS,  "() - return Bone loc"},
-  {"getSize", (PyCFunction)Bone_getSize, METH_NOARGS,  "() - return Bone size"},
-  {"getQuat", (PyCFunction)Bone_getQuat, METH_NOARGS,  "() - return Bone quat"},
-  {"getParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
-              "() - return the parent bone of this one if it exists."
-              " None if not found. You can check this condition with the "
-              "hasParent() method."},
-  {"hasParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
-          "() - return true if bone has a parent"},
-  {"getChildren", (PyCFunction)Bone_getChildren, METH_NOARGS,
-          "() - return Bone children list"},
-  {"setName", (PyCFunction)Bone_setName, METH_VARARGS, "(str) - rename Bone"},
-  {"setRoll", (PyCFunction)Bone_setRoll, METH_VARARGS,
-          "(float) - set Bone roll"},
-  {"setHead", (PyCFunction)Bone_setHead, METH_VARARGS,
-          "(float,float,float) - set Bone head pos"},
-  {"setTail", (PyCFunction)Bone_setTail, METH_VARARGS,
-          "(float,float,float) - set Bone tail pos"},
-  {"setLoc", (PyCFunction)Bone_setLoc, METH_VARARGS,
-          "(float,float,float) - set Bone loc"},
-  {"setSize", (PyCFunction)Bone_setSize, METH_VARARGS,
-          "(float,float,float) - set Bone size"},
-  {"setQuat", (PyCFunction)Bone_setQuat, METH_VARARGS,
-          "(float,float,float,float) - set Bone quat"},
-  /*  {"setParent", (PyCFunction)Bone_setParent, METH_NOARGS,  "() - set the Bone parent of this one."},
-      {"setChildren", (PyCFunction)Bone_setChildren, METH_NOARGS,  "() - replace the children list of the bone."},*/
-  {0}
+	{"getName", (PyCFunction)Bone_getName, METH_NOARGS,  "() - return Bone name"},
+	{"getRoll", (PyCFunction)Bone_getRoll, METH_NOARGS,  "() - return Bone roll"},
+	{"getHead", (PyCFunction)Bone_getHead, METH_NOARGS,  "() - return Bone head"},
+	{"getTail", (PyCFunction)Bone_getTail, METH_NOARGS,  "() - return Bone tail"},
+	{"getLoc", (PyCFunction)Bone_getLoc, METH_NOARGS,  "() - return Bone loc"},
+	{"getSize", (PyCFunction)Bone_getSize, METH_NOARGS,  "() - return Bone size"},
+	{"getQuat", (PyCFunction)Bone_getQuat, METH_NOARGS,  "() - return Bone quat"},
+	{"getParent", (PyCFunction)Bone_getParent, METH_NOARGS,
+							"() - return the parent bone of this one if it exists."
+							" None if not found. You can check this condition with the "
+							"hasParent() method."},
+	{"hasParent", (PyCFunction)Bone_hasParent, METH_NOARGS,
+					"() - return true if bone has a parent"},
+	{"getChildren", (PyCFunction)Bone_getChildren, METH_NOARGS,
+					"() - return Bone children list"},
+	{"setName", (PyCFunction)Bone_setName, METH_VARARGS, "(str) - rename Bone"},
+	{"setRoll", (PyCFunction)Bone_setRoll, METH_VARARGS,
+					"(float) - set Bone roll"},
+	{"setHead", (PyCFunction)Bone_setHead, METH_VARARGS,
+					"(float,float,float) - set Bone head pos"},
+	{"setTail", (PyCFunction)Bone_setTail, METH_VARARGS,
+					"(float,float,float) - set Bone tail pos"},
+	{"setLoc", (PyCFunction)Bone_setLoc, METH_VARARGS,
+					"(float,float,float) - set Bone loc"},
+	{"setSize", (PyCFunction)Bone_setSize, METH_VARARGS,
+					"(float,float,float) - set Bone size"},
+	{"setQuat", (PyCFunction)Bone_setQuat, METH_VARARGS,
+					"(float,float,float,float) - set Bone quat"},
+	/*	{"setParent", (PyCFunction)Bone_setParent, METH_NOARGS,  "() - set the Bone parent of this one."},
+			{"setChildren", (PyCFunction)Bone_setChildren, METH_NOARGS,  "() - replace the children list of the bone."},*/
+	{0}
 };
 
 /*****************************************************************************/
-/* Python TypeBone callback function prototypes:                             */
+/* Python TypeBone callback function prototypes:														 */
 /*****************************************************************************/
 static void Bone_dealloc (BPy_Bone *bone);
 static PyObject *Bone_getAttr (BPy_Bone *bone, char *name);
@@ -143,528 +143,528 @@ static int Bone_compare (BPy_Bone *a1, BPy_Bone *a2);
 static PyObject *Bone_repr (BPy_Bone *bone);
 
 /*****************************************************************************/
-/* Python TypeBone structure definition:                                     */
+/* Python TypeBone structure definition:																		 */
 /*****************************************************************************/
 PyTypeObject Bone_Type =
 {
-  PyObject_HEAD_INIT(NULL)
-  0,                                    /* ob_size */
-  "Blender Bone",                       /* tp_name */
-  sizeof (BPy_Bone),                    /* tp_basicsize */
-  0,                                    /* tp_itemsize */
-  /* methods */
-  (destructor)Bone_dealloc,             /* tp_dealloc */
-  0,                                    /* tp_print */
-  (getattrfunc)Bone_getAttr,            /* tp_getattr */
-  (setattrfunc)Bone_setAttr,            /* tp_setattr */
-  (cmpfunc)Bone_compare,                /* tp_compare */
-  (reprfunc)Bone_repr,                  /* 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_Bone_methods,                     /* tp_methods */
-  0,                                    /* tp_members */
+	PyObject_HEAD_INIT(NULL)
+	0,																		/* ob_size */
+	"Blender Bone",												/* tp_name */
+	sizeof (BPy_Bone),										/* tp_basicsize */
+	0,																		/* tp_itemsize */
+	/* methods */
+	(destructor)Bone_dealloc,							/* tp_dealloc */
+	0,																		/* tp_print */
+	(getattrfunc)Bone_getAttr,						/* tp_getattr */
+	(setattrfunc)Bone_setAttr,						/* tp_setattr */
+	(cmpfunc)Bone_compare,								/* tp_compare */
+	(reprfunc)Bone_repr,									/* 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_Bone_methods,											/* tp_methods */
+	0,																		/* tp_members */
 };
 
 
 
 
 /*****************************************************************************/
-/* Function:              M_Bone_New                                         */
-/* Python equivalent:     Blender.Armature.Bone.New                          */
+/* Function:							M_Bone_New																				 */
+/* Python equivalent:			Blender.Armature.Bone.New													 */
 /*****************************************************************************/
 static PyObject *M_Bone_New(PyObject *self, PyObject *args, PyObject *keywords)
 {
-  char        *name_str = "BoneName";
-  BPy_Bone    *py_bone = NULL; /* for Bone Data object wrapper in Python */
-  Bone        *bl_bone = NULL; /* for actual Bone Data we create in Blender */
-
-  if (!PyArg_ParseTuple(args, "|s", &name_str))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected string or empty argument"));
-
-  // Create the C structure for the newq bone
-  bl_bone = (Bone*)malloc(sizeof(Bone));
-  strncpy(bl_bone->name,name_str,sizeof(bl_bone->name));
-  
-  if (bl_bone) /* now create the wrapper obj in Python */
-    py_bone = (BPy_Bone *)PyObject_NEW(BPy_Bone, &Bone_Type);
-  else
-    return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                            "couldn't create Bone Data in Blender"));
-
-  if (py_bone == NULL)
-    return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-                            "couldn't create Bone Data object"));
-
-  py_bone->bone = bl_bone; /* link Python bone wrapper with Blender Bone */
-
-  if (strcmp(name_str, "BoneData") == 0)
-    return (PyObject *)py_bone;
-  else { /* user gave us a name for the bone, use it */
-    // TODO: check that name is not already in use?
-    PyOS_snprintf(bl_bone->name, sizeof(bl_bone->name), "%s", name_str);
-  }
-
-  return (PyObject *)py_bone;
+	char				*name_str = "BoneName";
+	BPy_Bone		*py_bone = NULL; /* for Bone Data object wrapper in Python */
+	Bone				*bl_bone = NULL; /* for actual Bone Data we create in Blender */
+
+	if (!PyArg_ParseTuple(args, "|s", &name_str))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected string or empty argument"));
+
+	// Create the C structure for the newq bone
+	bl_bone = (Bone*)malloc(sizeof(Bone));
+	strncpy(bl_bone->name,name_str,sizeof(bl_bone->name));
+	
+	if (bl_bone) /* now create the wrapper obj in Python */
+		py_bone = (BPy_Bone *)PyObject_NEW(BPy_Bone, &Bone_Type);
+	else
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+														"couldn't create Bone Data in Blender"));
+
+	if (py_bone == NULL)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+														"couldn't create Bone Data object"));
+
+	py_bone->bone = bl_bone; /* link Python bone wrapper with Blender Bone */
+
+	if (strcmp(name_str, "BoneData") == 0)
+		return (PyObject *)py_bone;
+	else { /* user gave us a name for the bone, use it */
+		// TODO: check that name is not already in use?
+		PyOS_snprintf(bl_bone->name, sizeof(bl_bone->name), "%s", name_str);
+	}
+
+	return (PyObject *)py_bone;
 }
 
 
 /*****************************************************************************/
-/* Function:              Bone_Init                                          */
+/* Function:							Bone_Init																					 */
 /*****************************************************************************/
 PyObject *Bone_Init (void)
 {
-  PyObject  *submodule;
+	PyObject	*submodule;
 
-  Bone_Type.ob_type = &PyType_Type;
+	Bone_Type.ob_type = &PyType_Type;
 
-  submodule = Py_InitModule3("Blender.Armature.Bone",
-                             M_Bone_methods, M_Bone_doc);
+	submodule = Py_InitModule3("Blender.Armature.Bone",
+														 M_Bone_methods, M_Bone_doc);
 
-  return (submodule);
+	return (submodule);
 }
 
 /*****************************************************************************/
-/* Python BPy_Bone methods:                                                  */
+/* Python BPy_Bone methods:																									 */
 /*****************************************************************************/
 static PyObject *Bone_getName(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = PyString_FromString(self->bone->name);
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = PyString_FromString(self->bone->name);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.name attribute"));
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.name attribute"));
 }
 
 
 static PyObject *Bone_getRoll(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("f", self->bone->roll);
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("f", self->bone->roll);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.roll attribute"));
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.roll attribute"));
 }
 
 
 static PyObject *Bone_getHead(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("[fff]", self->bone->head[0],self->bone->head[1],
-                  self->bone->head[2]);
-
-  if (attr) return attr;
-
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.head attribute"));
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("[fff]", self->bone->head[0],self->bone->head[1],
+									self->bone->head[2]);
+
+	if (attr) return attr;
+
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.head attribute"));
 }
 
 
 static PyObject *Bone_getTail(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("[fff]", self->bone->tail[0],self->bone->tail[1],
-                  self->bone->tail[2]);
-
-  if (attr) return attr;
-
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.tail attribute"));
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("[fff]", self->bone->tail[0],self->bone->tail[1],
+									self->bone->tail[2]);
+
+	if (attr) return attr;
+
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.tail attribute"));
 }
 
 
 static PyObject *Bone_getLoc (BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("[fff]", self->bone->loc[0],self->bone->loc[1],
-                  self->bone->loc[2]);
-
-  if (attr) return attr;
-
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.loc attribute"));
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("[fff]", self->bone->loc[0],self->bone->loc[1],
+									self->bone->loc[2]);
+
+	if (attr) return attr;
+
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.loc attribute"));
 }
 
 
 static PyObject *Bone_getSize(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("[fff]", self->bone->size[0],self->bone->size[1],
-                  self->bone->size[2]);
-
-  if (attr) return attr;
-
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.size attribute"));
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("[fff]", self->bone->size[0],self->bone->size[1],
+									self->bone->size[2]);
+
+	if (attr) return attr;
+
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.size attribute"));
 }
 
 
 static PyObject *Bone_getQuat(BPy_Bone *self)
 {
-  PyObject *attr=NULL;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  attr = Py_BuildValue("[ffff]", self->bone->quat[0],self->bone->quat[1],
-                  self->bone->quat[2],self->bone->quat[3]);
-
-  if (attr) return attr;
-
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-          "couldn't get Bone.tail attribute"));
+	PyObject *attr=NULL;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	attr = Py_BuildValue("[ffff]", self->bone->quat[0],self->bone->quat[1],
+									self->bone->quat[2],self->bone->quat[3]);
+
+	if (attr) return attr;
+
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+					"couldn't get Bone.tail attribute"));
 }
 
 
 static PyObject *Bone_hasParent(BPy_Bone *self)
 {
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-
-  /*
-  return Bone_CreatePyObject(self->bone->parent);
-  */
-  if (self->bone->parent)
-    {
-      Py_INCREF(Py_True);
-      return Py_True;
-    }
-  else
-    {
-      Py_INCREF(Py_False);
-      return Py_False;
-    }
-  
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+
+	/*
+	return Bone_CreatePyObject(self->bone->parent);
+	*/
+	if (self->bone->parent)
+		{
+			Py_INCREF(Py_True);
+			return Py_True;
+		}
+	else
+		{
+			Py_INCREF(Py_False);
+			return Py_False;
+		}
+	
 }
 
 
 static PyObject *Bone_getParent(BPy_Bone *self)
 {
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-
-  if (self->bone->parent) return Bone_CreatePyObject(self->bone->parent);
-  else /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
-         "couldn't get parent bone, because bone hasn't got a parent."));*/
-    {
-      Py_INCREF(Py_None);
-      return Py_None;
-    }
-  
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"couldn't get attribute from a NULL bone"));
+
+	if (self->bone->parent) return Bone_CreatePyObject(self->bone->parent);
+	else /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
+				 "couldn't get parent bone, because bone hasn't got a parent."));*/
+		{
+			Py_INCREF(Py_None);
+			return Py_None;
+		}
+	
 }
 
 
 static PyObject *Bone_getChildren(BPy_Bone *self)
 {
-  int totbones = 0;
-  Bone* current = NULL;
-  PyObject *listbones = NULL;
-  int i;
-  
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  /* Count the number of bones to create the list */
-  current = self->bone->childbase.first;
-  for (;current; current=current->next) totbones++;
-
-  /* Create a list with a bone wrapper for each bone */
-  current = self->bone->childbase.first;  
-  listbones = PyList_New(totbones);
-  for (i=0; i<totbones; i++) {
-    assert(current);
-    PyList_SetItem(listbones, i, Bone_CreatePyObject(current));
-    current = current->next;
-  }
-
-  return listbones;  
+	int totbones = 0;
+	Bone* current = NULL;
+	PyObject *listbones = NULL;
+	int i;
+	
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	/* Count the number of bones to create the list */
+	current = self->bone->childbase.first;
+	for (;current; current=current->next) totbones++;
+
+	/* Create a list with a bone wrapper for each bone */
+	current = self->bone->childbase.first;	
+	listbones = PyList_New(totbones);
+	for (i=0; i<totbones; i++) {
+		assert(current);
+		PyList_SetItem(listbones, i, Bone_CreatePyObject(current));
+		current = current->next;
+	}
+
+	return listbones;  
 }
 
 
 static PyObject *Bone_setName(BPy_Bone *self, PyObject *args)
 {
-  char *name;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "s", &name))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected string argument"));
-  
-  PyOS_snprintf(self->bone->name, sizeof(self->bone->name), "%s", name);
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	char *name;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected string argument"));
+	
+	PyOS_snprintf(self->bone->name, sizeof(self->bone->name), "%s", name);
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 PyObject *Bone_setRoll(BPy_Bone *self, PyObject *args)
 {
-  float roll;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "f", &roll))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected float argument"));
-  
-  self->bone->roll = roll;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float roll;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "f", &roll))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected float argument"));
+	
+	self->bone->roll = roll;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 static PyObject *Bone_setHead(BPy_Bone *self, PyObject *args)
 {
-  float f1,f2,f3;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected 3 float arguments"));
-  
-  self->bone->head[0] = f1;
-  self->bone->head[1] = f2;
-  self->bone->head[2] = f3;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float f1,f2,f3;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected 3 float arguments"));
+	
+	self->bone->head[0] = f1;
+	self->bone->head[1] = f2;
+	self->bone->head[2] = f3;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 static PyObject *Bone_setTail(BPy_Bone *self, PyObject *args)
 {
-  float f1,f2,f3;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected 3 float arguments"));
-  
-  self->bone->tail[0] = f1;
-  self->bone->tail[1] = f2;
-  self->bone->tail[2] = f3;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float f1,f2,f3;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected 3 float arguments"));
+	
+	self->bone->tail[0] = f1;
+	self->bone->tail[1] = f2;
+	self->bone->tail[2] = f3;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 static PyObject *Bone_setLoc(BPy_Bone *self, PyObject *args)
 {
-  float f1,f2,f3;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected 3 float arguments"));
-  
-  self->bone->loc[0] = f1;
-  self->bone->loc[1] = f2;
-  self->bone->loc[2] = f3;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float f1,f2,f3;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected 3 float arguments"));
+	
+	self->bone->loc[0] = f1;
+	self->bone->loc[1] = f2;
+	self->bone->loc[2] = f3;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 static PyObject *Bone_setSize(BPy_Bone *self, PyObject *args)
 {
-  float f1,f2,f3;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected 3 float arguments"));
-  
-  self->bone->size[0] = f1;
-  self->bone->size[1] = f2;
-  self->bone->size[2] = f3;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float f1,f2,f3;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "fff", &f1,&f2,&f3))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected 3 float arguments"));
+	
+	self->bone->size[0] = f1;
+	self->bone->size[1] = f2;
+	self->bone->size[2] = f3;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 static PyObject *Bone_setQuat(BPy_Bone *self, PyObject *args)
 {
-  float f1,f2,f3,f4;
-
-  if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                          "couldn't get attribute from a NULL bone"));
-    
-  if (!PyArg_ParseTuple(args, "ffff", &f1,&f2,&f3,&f4))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected 4 float arguments"));
-  
-  self->bone->quat[0] = f1;
-  self->bone->quat[1] = f2;
-  self->bone->quat[2] = f3;
-  self->bone->quat[3] = f4;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	float f1,f2,f3,f4;
+
+	if (!self->bone) (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+													"couldn't get attribute from a NULL bone"));
+		
+	if (!PyArg_ParseTuple(args, "ffff", &f1,&f2,&f3,&f4))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected 4 float arguments"));
+	
+	self->bone->quat[0] = f1;
+	self->bone->quat[1] = f2;
+	self->bone->quat[2] = f3;
+	self->bone->quat[3] = f4;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 
 /*****************************************************************************/
-/* Function:    Bone_dealloc                                                 */
-/* Description: This is a callback function for the BPy_Bone type. It is     */
-/*              the destructor function.                                     */
+/* Function:		Bone_dealloc																								 */
+/* Description: This is a callback function for the BPy_Bone type. It is		 */
+/*							the destructor function.																		 */
 /*****************************************************************************/
 static void Bone_dealloc (BPy_Bone *self)
 {
-  PyObject_DEL (self);
+	PyObject_DEL (self);
 }
 
 /*****************************************************************************/
-/* Function:    Bone_getAttr                                                 */
-/* Description: This is a callback function for the BPy_Bone type. It is     */
-/*              the function that accesses BPy_Bone member variables and     */
-/*              methods.                                                     */
+/* Function:		Bone_getAttr																								 */
+/* Description: This is a callback function for the BPy_Bone type. It is		 */
+/*							the function that accesses BPy_Bone member variables and		 */
+/*							methods.																										 */
 /*****************************************************************************/
 static PyObject* Bone_getAttr (BPy_Bone *self, char *name)
 {
-  PyObject *attr = Py_None;
-
-  if (strcmp(name, "name") == 0)
-    attr = Bone_getName(self);
-  else if (strcmp(name, "roll") == 0)
-    attr = Bone_getRoll(self);
-  else if (strcmp(name, "head") == 0)
-    attr = Bone_getHead(self);
-  else if (strcmp(name, "tail") == 0)
-    attr = Bone_getTail(self);
-  else if (strcmp(name, "size") == 0)
-    attr = Bone_getSize(self);
-  else if (strcmp(name, "loc") == 0)
-    attr = Bone_getLoc(self);
-  else if (strcmp(name, "quat") == 0)
-    attr = Bone_getQuat(self);
-  else if (strcmp(name, "parent") == 0)
-    // Skip the checks for Py_None as its a valid result to this call.
-    return Bone_getParent(self);  
-  else if (strcmp(name, "children") == 0)
-    attr = Bone_getChildren(self);
-  else if (strcmp(name, "__members__") == 0) {
-    /* 9 entries */
-    attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]",
-       "name","roll","head","tail","loc","size",
-       "quat","parent","children");
-  }
-
-  if (!attr)
-    return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-                      "couldn't create PyObject"));
-
-  if (attr != Py_None) return attr; /* member attribute found, return it */
-
-  /* not an attribute, search the methods table */
-  return Py_FindMethod(BPy_Bone_methods, (PyObject *)self, name);
+	PyObject *attr = Py_None;
+
+	if (strcmp(name, "name") == 0)
+		attr = Bone_getName(self);
+	else if (strcmp(name, "roll") == 0)
+		attr = Bone_getRoll(self);
+	else if (strcmp(name, "head") == 0)
+		attr = Bone_getHead(self);
+	else if (strcmp(name, "tail") == 0)
+		attr = Bone_getTail(self);
+	else if (strcmp(name, "size") == 0)
+		attr = Bone_getSize(self);
+	else if (strcmp(name, "loc") == 0)
+		attr = Bone_getLoc(self);
+	else if (strcmp(name, "quat") == 0)
+		attr = Bone_getQuat(self);
+	else if (strcmp(name, "parent") == 0)
+		// Skip the checks for Py_None as its a valid result to this call.
+		return Bone_getParent(self);	
+	else if (strcmp(name, "children") == 0)
+		attr = Bone_getChildren(self);
+	else if (strcmp(name, "__members__") == 0) {
+		/* 9 entries */
+		attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]",
+			 "name","roll","head","tail","loc","size",
+			 "quat","parent","children");
+	}
+
+	if (!attr)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+											"couldn't create PyObject"));
+
+	if (attr != Py_None) return attr; /* member attribute found, return it */
+
+	/* not an attribute, search the methods table */
+	return Py_FindMethod(BPy_Bone_methods, (PyObject *)self, name);
 }
 
 /*****************************************************************************/
-/* Function:    Bone_setAttr                                                 */
+/* Function:		Bone_setAttr																								 */
 /* Description: This is a callback function for the BPy_Bone type. It is the */
-/*              function that changes Bone Data members values. If this      */
-/*              data is linked to a Blender Bone, it also gets updated.      */
+/*							function that changes Bone Data members values. If this			 */
+/*							data is linked to a Blender Bone, it also gets updated.			 */
 /*****************************************************************************/
 static int Bone_setAttr (BPy_Bone *self, char *name, PyObject *value)
 {
-  PyObject *valtuple; 
-  PyObject *error = NULL;
-
-  valtuple = Py_BuildValue("(O)", value); /* the set* functions expect a tuple */
-
-  if (!valtuple)
-    return EXPP_ReturnIntError(PyExc_MemoryError,
-                  "BoneSetAttr: couldn't create tuple");
-
-  if (strcmp (name, "name") == 0)
-    error = Bone_setName (self, valtuple);
-  else { /* Error */
-    Py_DECREF(valtuple);
-  
-    /* ... member with the given name was found */
-    return (EXPP_ReturnIntError (PyExc_KeyError,
-         "attribute not found"));
-  }
-
-  Py_DECREF(valtuple);
-  
-  if (error != Py_None) return -1;
-
-  Py_DECREF(Py_None); /* was incref'ed by the called Bone_set* function */
-  return 0; /* normal exit */
+	PyObject *valtuple; 
+	PyObject *error = NULL;
+
+	valtuple = Py_BuildValue("(O)", value); /* the set* functions expect a tuple */
+
+	if (!valtuple)
+		return EXPP_ReturnIntError(PyExc_MemoryError,
+									"BoneSetAttr: couldn't create tuple");
+
+	if (strcmp (name, "name") == 0)
+		error = Bone_setName (self, valtuple);
+	else { /* Error */
+		Py_DECREF(valtuple);
+	
+		/* ... member with the given name was found */
+		return (EXPP_ReturnIntError (PyExc_KeyError,
+				 "attribute not found"));
+	}
+
+	Py_DECREF(valtuple);
+	
+	if (error != Py_None) return -1;
+
+	Py_DECREF(Py_None); /* was incref'ed by the called Bone_set* function */
+	return 0; /* normal exit */
 }
 
 /*****************************************************************************/
-/* Function:    Bone_repr                                                    */
-/* Description: This is a callback function for the BPy_Bone type. It        */
-/*              builds a meaninful string to represent bone objects.         */
+/* Function:		Bone_repr																										 */
+/* Description: This is a callback function for the BPy_Bone type. It				 */
+/*							builds a meaninful string to represent bone objects.				 */
 /*****************************************************************************/
 static PyObject *Bone_repr (BPy_Bone *self)
 {
-  if (self->bone)
+	if (self->bone)
 		return PyString_FromFormat("[Bone \"%s\"]", self->bone->name);
-  else return PyString_FromString("NULL");
+	else return PyString_FromString("NULL");
 }
 
 /**************************************************************************/
-/* Function:    Bone_compare                                              */
-/* Description: This is a callback function for the BPy_Bone type. It     */
-/*              compares the two bones: translate comparison to the       */
-/*              C pointers.                                               */
+/* Function:		Bone_compare																							*/
+/* Description: This is a callback function for the BPy_Bone type. It			*/
+/*							compares the two bones: translate comparison to the				*/
+/*							C pointers.																								*/
 /**************************************************************************/
 static int Bone_compare (BPy_Bone *a, BPy_Bone *b)
 {
-  Bone *pa = a->bone, *pb = b->bone;
+	Bone *pa = a->bone, *pb = b->bone;
 	return (pa == pb) ? 0:-1;
 }
 
@@ -672,43 +672,43 @@ static int Bone_compare (BPy_Bone *a, BPy_Bone *b)
 
 
 /*****************************************************************************/
-/* Function:    Bone_CreatePyObject                                          */
-/* Description: This function will create a new BlenBone from an existing    */
-/*              Bone structure.                                              */
+/* Function:		Bone_CreatePyObject																					 */
+/* Description: This function will create a new BlenBone from an existing		 */
+/*							Bone structure.																							 */
 /*****************************************************************************/
 PyObject* Bone_CreatePyObject (struct Bone *obj)
 {
-  BPy_Bone    * blen_bone;
+	BPy_Bone		* blen_bone;
 
-  blen_bone = (BPy_Bone*)PyObject_NEW (BPy_Bone, &Bone_Type);
+	blen_bone = (BPy_Bone*)PyObject_NEW (BPy_Bone, &Bone_Type);
 
-  if (blen_bone == NULL)
-    {
-      return (NULL);
-    }
-  blen_bone->bone = obj;
-  return ((PyObject*)blen_bone);
+	if (blen_bone == NULL)
+		{
+			return (NULL);
+		}
+	blen_bone->bone = obj;
+	return ((PyObject*)blen_bone);
 }
 
 /*****************************************************************************/
-/* Function:    Bone_CheckPyObject                                           */
+/* Function:		Bone_CheckPyObject																					 */
 /* Description: This function returns true when the given PyObject is of the */
-/*              type Bone. Otherwise it will return false.                   */
+/*							type Bone. Otherwise it will return false.									 */
 /*****************************************************************************/
 int Bone_CheckPyObject (PyObject *py_obj)
 {
-  return (py_obj->ob_type == &Bone_Type);
+	return (py_obj->ob_type == &Bone_Type);
 }
 
 /*****************************************************************************/
-/* Function:    Bone_FromPyObject                                            */
-/* Description: This function returns the Blender bone from the given        */
-/*              PyObject.                                                    */
+/* Function:		Bone_FromPyObject																						 */
+/* Description: This function returns the Blender bone from the given				 */
+/*							PyObject.																										 */
 /*****************************************************************************/
 struct Bone* Bone_FromPyObject (PyObject *py_obj)
 {
-  BPy_Bone    * blen_obj;
+	BPy_Bone		* blen_obj;
 
-  blen_obj = (BPy_Bone*)py_obj;
-  return (blen_obj->bone);
+	blen_obj = (BPy_Bone*)py_obj;
+	return (blen_obj->bone);
 }
diff --git a/source/blender/python/api2_2x/Material.c b/source/blender/python/api2_2x/Material.c
index f51fd7c4b32..16195bd73b6 100644
--- a/source/blender/python/api2_2x/Material.c
+++ b/source/blender/python/api2_2x/Material.c
@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
@@ -42,84 +42,85 @@
 #include "Material.h"
 
 /*****************************************************************************/
-/* Python BPy_Material defaults:                                             */
+/* Python BPy_Material defaults:																						 */
 /*****************************************************************************/
-#define EXPP_MAT_MODE_TRACEABLE           MA_TRACEBLE
-#define EXPP_MAT_MODE_SHADOW              MA_SHADOW
-#define EXPP_MAT_MODE_SHADELESS           MA_SHLESS
-#define EXPP_MAT_MODE_WIRE                MA_WIRE
-#define EXPP_MAT_MODE_VCOL_LIGHT          MA_VERTEXCOL
-#define EXPP_MAT_MODE_HALO                MA_HALO
-#define EXPP_MAT_MODE_ZTRANSP             MA_ZTRA
-#define EXPP_MAT_MODE_VCOL_PAINT          MA_VERTEXCOLP
-#define EXPP_MAT_MODE_ZINVERT             MA_ZINV
-#define EXPP_MAT_MODE_HALORINGS           MA_HALO_RINGS
-#define EXPP_MAT_MODE_ENV                 MA_ENV
-#define EXPP_MAT_MODE_HALOLINES           MA_HALO_LINES
-#define EXPP_MAT_MODE_ONLYSHADOW          MA_ONLYSHADOW
-#define EXPP_MAT_MODE_HALOXALPHA          MA_HALO_XALPHA
-#define EXPP_MAT_MODE_HALOSTAR            MA_STAR
-#define EXPP_MAT_MODE_TEXFACE             MA_FACETEXTURE
-#define EXPP_MAT_MODE_HALOTEX             MA_HALOTEX
-#define EXPP_MAT_MODE_HALOPUNO            MA_HALOPUNO
-#define EXPP_MAT_MODE_NOMIST              MA_NOMIST
-#define EXPP_MAT_MODE_HALOSHADE           MA_HALO_SHADE
-#define EXPP_MAT_MODE_HALOFLARE           MA_HALO_FLARE
+#define EXPP_MAT_MODE_TRACEABLE						MA_TRACEBLE
+#define EXPP_MAT_MODE_SHADOW							MA_SHADOW
+#define EXPP_MAT_MODE_SHADELESS						MA_SHLESS
+#define EXPP_MAT_MODE_WIRE								MA_WIRE
+#define EXPP_MAT_MODE_VCOL_LIGHT					MA_VERTEXCOL
+#define EXPP_MAT_MODE_HALO								MA_HALO
+#define EXPP_MAT_MODE_ZTRANSP							MA_ZTRA
+#define EXPP_MAT_MODE_VCOL_PAINT					MA_VERTEXCOLP
+#define EXPP_MAT_MODE_ZINVERT							MA_ZINV
+#define EXPP_MAT_MODE_HALORINGS						MA_HALO_RINGS
+#define EXPP_MAT_MODE_ENV									MA_ENV
+#define EXPP_MAT_MODE_HALOLINES						MA_HALO_LINES
+#define EXPP_MAT_MODE_ONLYSHADOW					MA_ONLYSHADOW
+#define EXPP_MAT_MODE_HALOXALPHA					MA_HALO_XALPHA
+#define EXPP_MAT_MODE_HALOSTAR						MA_STAR
+#define EXPP_MAT_MODE_TEXFACE							MA_FACETEXTURE
+#define EXPP_MAT_MODE_HALOTEX							MA_HALOTEX
+#define EXPP_MAT_MODE_HALOPUNO						MA_HALOPUNO
+#define EXPP_MAT_MODE_NOMIST							MA_NOMIST
+#define EXPP_MAT_MODE_HALOSHADE						MA_HALO_SHADE
+#define EXPP_MAT_MODE_HALOFLARE						MA_HALO_FLARE
+#define EXPP_MAT_MODE_RADIO								MA_RADIO
 
 /* Material MIN, MAX values */
-#define EXPP_MAT_ADD_MIN           0.0
-#define EXPP_MAT_ADD_MAX           1.0
-#define EXPP_MAT_ALPHA_MIN         0.0
-#define EXPP_MAT_ALPHA_MAX         1.0
-#define EXPP_MAT_AMB_MIN           0.0
-#define EXPP_MAT_AMB_MAX           1.0
-#define EXPP_MAT_COL_MIN           0.0 /* min/max for all ... */
-#define EXPP_MAT_COL_MAX           1.0 /* ... color triplets  */
-#define EXPP_MAT_EMIT_MIN          0.0
-#define EXPP_MAT_EMIT_MAX          1.0
-#define EXPP_MAT_REF_MIN           0.0
-#define EXPP_MAT_REF_MAX           1.0
-#define EXPP_MAT_SPEC_MIN          0.0
-#define EXPP_MAT_SPEC_MAX          2.0
-#define EXPP_MAT_SPECTRA_MIN       0.0
-#define EXPP_MAT_SPECTRA_MAX       1.0
-#define EXPP_MAT_ZOFFS_MIN         0.0
-#define EXPP_MAT_ZOFFS_MAX        10.0
-#define EXPP_MAT_HALOSIZE_MIN      0.0
-#define EXPP_MAT_HALOSIZE_MAX    100.0
-#define EXPP_MAT_FLARESIZE_MIN     0.1
-#define EXPP_MAT_FLARESIZE_MAX    25.0
-#define EXPP_MAT_FLAREBOOST_MIN    0.1
-#define EXPP_MAT_FLAREBOOST_MAX   10.0
-#define EXPP_MAT_SUBSIZE_MIN       0.1
-#define EXPP_MAT_SUBSIZE_MAX      25.0
-
-#define EXPP_MAT_HARD_MIN        1
-#define EXPP_MAT_HARD_MAX      255  /* 127 with MODE HALO ON */
-#define EXPP_MAT_HALOSEED_MIN    1
+#define EXPP_MAT_ADD_MIN					 0.0
+#define EXPP_MAT_ADD_MAX					 1.0
+#define EXPP_MAT_ALPHA_MIN				 0.0
+#define EXPP_MAT_ALPHA_MAX				 1.0
+#define EXPP_MAT_AMB_MIN					 0.0
+#define EXPP_MAT_AMB_MAX					 1.0
+#define EXPP_MAT_COL_MIN					 0.0 /* min/max for all ... */
+#define EXPP_MAT_COL_MAX					 1.0 /* ... color triplets	*/
+#define EXPP_MAT_EMIT_MIN					 0.0
+#define EXPP_MAT_EMIT_MAX					 1.0
+#define EXPP_MAT_REF_MIN					 0.0
+#define EXPP_MAT_REF_MAX					 1.0
+#define EXPP_MAT_SPEC_MIN					 0.0
+#define EXPP_MAT_SPEC_MAX					 2.0
+#define EXPP_MAT_SPECTRA_MIN			 0.0
+#define EXPP_MAT_SPECTRA_MAX			 1.0
+#define EXPP_MAT_ZOFFS_MIN				 0.0
+#define EXPP_MAT_ZOFFS_MAX				10.0
+#define EXPP_MAT_HALOSIZE_MIN			 0.0
+#define EXPP_MAT_HALOSIZE_MAX		 100.0
+#define EXPP_MAT_FLARESIZE_MIN		 0.1
+#define EXPP_MAT_FLARESIZE_MAX		25.0
+#define EXPP_MAT_FLAREBOOST_MIN		 0.1
+#define EXPP_MAT_FLAREBOOST_MAX		10.0
+#define EXPP_MAT_SUBSIZE_MIN			 0.1
+#define EXPP_MAT_SUBSIZE_MAX			25.0
+
+#define EXPP_MAT_HARD_MIN				 1
+#define EXPP_MAT_HARD_MAX			 255	/* 127 with MODE HALO ON */
+#define EXPP_MAT_HALOSEED_MIN		 1
 #define EXPP_MAT_HALOSEED_MAX  255
-#define EXPP_MAT_NFLARES_MIN     1
-#define EXPP_MAT_NFLARES_MAX    32
-#define EXPP_MAT_FLARESEED_MIN   1
+#define EXPP_MAT_NFLARES_MIN		 1
+#define EXPP_MAT_NFLARES_MAX		32
+#define EXPP_MAT_FLARESEED_MIN	 1
 #define EXPP_MAT_FLARESEED_MAX 255
-#define EXPP_MAT_NSTARS_MIN      3
-#define EXPP_MAT_NSTARS_MAX     50
-#define EXPP_MAT_NLINES_MIN      0
-#define EXPP_MAT_NLINES_MAX    250
-#define EXPP_MAT_NRINGS_MIN      0
-#define EXPP_MAT_NRINGS_MAX     24
+#define EXPP_MAT_NSTARS_MIN			 3
+#define EXPP_MAT_NSTARS_MAX			50
+#define EXPP_MAT_NLINES_MIN			 0
+#define EXPP_MAT_NLINES_MAX		 250
+#define EXPP_MAT_NRINGS_MIN			 0
+#define EXPP_MAT_NRINGS_MAX			24
 
 /*****************************************************************************/
-/* Python API function prototypes for the Material module.                   */
+/* Python API function prototypes for the Material module.									 */
 /*****************************************************************************/
 static PyObject *M_Material_New (PyObject *self, PyObject *args,
-                               PyObject *keywords);
+															 PyObject *keywords);
 static PyObject *M_Material_Get (PyObject *self, PyObject *args);
 
 /*****************************************************************************/
-/* The following string definitions are used for documentation strings.      */
-/* In Python these will be written to the console when doing a               */
-/* Blender.Material.__doc__                                                  */
+/* The following string definitions are used for documentation strings.			 */
+/* In Python these will be written to the console when doing a							 */
+/* Blender.Material.__doc__																									 */
 /*****************************************************************************/
 static char M_Material_doc[] =
 "The Blender Material module";
@@ -133,119 +134,119 @@ static char M_Material_Get_doc[] =
 () - return a list of all materials in the current scene.";
 
 /*****************************************************************************/
-/* Python method structure definition for Blender.Material module:           */
+/* Python method structure definition for Blender.Material module:					 */
 /*****************************************************************************/
 struct PyMethodDef M_Material_methods[] = {
-  {"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS,
-          M_Material_New_doc},
-  {"Get",         M_Material_Get,         METH_VARARGS, M_Material_Get_doc},
-  {"get",         M_Material_Get,         METH_VARARGS, M_Material_Get_doc},
-  {NULL, NULL, 0, NULL}
+	{"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS,
+					M_Material_New_doc},
+	{"Get",					M_Material_Get,					METH_VARARGS, M_Material_Get_doc},
+	{"get",					M_Material_Get,					METH_VARARGS, M_Material_Get_doc},
+	{NULL, NULL, 0, NULL}
 };
 
 /*****************************************************************************/
-/* Function:              M_Material_New                                     */
-/* Python equivalent:     Blender.Material.New                               */
+/* Function:							M_Material_New																		 */
+/* Python equivalent:			Blender.Material.New															 */
 /*****************************************************************************/
 static PyObject *M_Material_New(PyObject *self, PyObject *args,
 								PyObject *keywords)
 {
-  char        *name = "Mat";
-  static char *kwlist[] = {"name", NULL};
-  BPy_Material  *pymat; /* for Material Data object wrapper in Python */
-  Material      *blmat; /* for actual Material Data we create in Blender */
-  char        buf[21];
+	char				*name = "Mat";
+	static char *kwlist[] = {"name", NULL};
+	BPy_Material	*pymat; /* for Material Data object wrapper in Python */
+	Material			*blmat; /* for actual Material Data we create in Blender */
+	char				buf[21];
 
-  if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected string or nothing as argument"));
+	if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected string or nothing as argument"));
 
-  if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
-    PyOS_snprintf(buf, sizeof(buf), "%s", name);
+	if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
+		PyOS_snprintf(buf, sizeof(buf), "%s", name);
 
-  blmat = add_material(name); /* first create the Material Data in Blender */
+	blmat = add_material(name); /* first create the Material Data in Blender */
 
-  if (blmat) /* now create the wrapper obj in Python */
-    pymat = (BPy_Material *)Material_CreatePyObject (blmat);
-  else
-    return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                            "couldn't create Material Data in Blender"));
+	if (blmat) /* now create the wrapper obj in Python */
+		pymat = (BPy_Material *)Material_CreatePyObject (blmat);
+	else
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+														"couldn't create Material Data in Blender"));
 
-  blmat->id.us = 0; /* was incref'ed by add_material() above */
+	blmat->id.us = 0; /* was incref'ed by add_material() above */
 
-  if (pymat == NULL)
-    return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-                            "couldn't create Material Data object"));
+	if (pymat == NULL)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+														"couldn't create Material Data object"));
 
-  return (PyObject *)pymat;
+	return (PyObject *)pymat;
 }
 
 /*****************************************************************************/
-/* Function:              M_Material_Get                                     */
-/* Python equivalent:     Blender.Material.Get                               */
-/* Description:           Receives a string and returns the material whose   */
-/*                        name matches the string.  If no argument is        */
-/*                        passed in, a list with all materials in the        */
-/*                        current scene is returned.                         */
+/* Function:							M_Material_Get																		 */
+/* Python equivalent:			Blender.Material.Get															 */
+/* Description:						Receives a string and returns the material whose	 */
+/*												name matches the string.	If no argument is				 */
+/*												passed in, a list with all materials in the				 */
+/*												current scene is returned.												 */
 /*****************************************************************************/
 static PyObject *M_Material_Get(PyObject *self, PyObject *args)
 {
-  char   *name = NULL;
-  Material *mat_iter;
+	char	 *name = NULL;
+	Material *mat_iter;
 
-  if (!PyArg_ParseTuple(args, "|s", &name))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected string argument (or nothing)"));
+	if (!PyArg_ParseTuple(args, "|s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected string argument (or nothing)"));
 
-  mat_iter = G.main->mat.first;
+	mat_iter = G.main->mat.first;
 
-  if (name) { /* (name) - Search material by name */
+	if (name) { /* (name) - Search material by name */
 
-    BPy_Material *wanted_mat = NULL;
+		BPy_Material *wanted_mat = NULL;
 
-    while ((mat_iter) && (wanted_mat == NULL)) {
+		while ((mat_iter) && (wanted_mat == NULL)) {
 
-      if (strcmp (name, mat_iter->id.name+2) == 0)
-        wanted_mat = (BPy_Material *)Material_CreatePyObject (mat_iter);
+			if (strcmp (name, mat_iter->id.name+2) == 0)
+				wanted_mat = (BPy_Material *)Material_CreatePyObject (mat_iter);
 
-      mat_iter = mat_iter->id.next;
-    }
+			mat_iter = mat_iter->id.next;
+		}
 
-    if (wanted_mat == NULL) { /* Requested material doesn't exist */
-      char error_msg[64];
-      PyOS_snprintf(error_msg, sizeof(error_msg),
-                      "Material \"%s\" not found", name);
-      return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
-    }
+		if (wanted_mat == NULL) { /* Requested material doesn't exist */
+			char error_msg[64];
+			PyOS_snprintf(error_msg, sizeof(error_msg),
+											"Material \"%s\" not found", name);
+			return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
+		}
 
-    return (PyObject *)wanted_mat;
-  }
+		return (PyObject *)wanted_mat;
+	}
 
-  else { /* () - return a list with all materials in the scene */
-    int index = 0;
-    PyObject *matlist, *pyobj;
+	else { /* () - return a list with all materials in the scene */
+		int index = 0;
+		PyObject *matlist, *pyobj;
 
-    matlist = PyList_New (BLI_countlist (&(G.main->mat)));
+		matlist = PyList_New (BLI_countlist (&(G.main->mat)));
 
-    if (!matlist)
-      return (PythonReturnErrorObject (PyExc_MemoryError,
-              "couldn't create PyList"));
+		if (!matlist)
+			return (PythonReturnErrorObject (PyExc_MemoryError,
+							"couldn't create PyList"));
 
-    while (mat_iter) {
-      pyobj = Material_CreatePyObject (mat_iter);
+		while (mat_iter) {
+			pyobj = Material_CreatePyObject (mat_iter);
 
-      if (!pyobj)
-        return (PythonReturnErrorObject (PyExc_MemoryError,
-                  "couldn't create PyObject"));
+			if (!pyobj)
+				return (PythonReturnErrorObject (PyExc_MemoryError,
+									"couldn't create PyObject"));
 
-      PyList_SET_ITEM (matlist, index, pyobj);
+			PyList_SET_ITEM (matlist, index, pyobj);
 
-      mat_iter = mat_iter->id.next;
-      index++;
-    }
+			mat_iter = mat_iter->id.next;
+			index++;
+		}
 
-    return matlist;
-  }
+		return matlist;
+	}
 }
 
 static PyObject *Lamp_ModesDict (void)
@@ -285,27 +286,28 @@ static PyObject *Lamp_ModesDict (void)
 		EXPP_ADDCONST(NOMIST);
 		EXPP_ADDCONST(HALOSHADE);
 		EXPP_ADDCONST(HALOFLARE);
+		EXPP_ADDCONST(RADIO);
 	}
 
 	return Modes;
 }
 
 /*****************************************************************************/
-/* Function:              Material_Init                                      */
+/* Function:							Material_Init																			 */
 /*****************************************************************************/
 PyObject *Material_Init (void)
 {
-  PyObject  *submodule, *Modes;
+	PyObject	*submodule, *Modes;
 
-  Material_Type.ob_type = &PyType_Type;
+	Material_Type.ob_type = &PyType_Type;
 
 	Modes = Lamp_ModesDict ();
 
-  submodule = Py_InitModule3("Blender.Material",
-                  M_Material_methods, M_Material_doc);
+	submodule = Py_InitModule3("Blender.Material",
+									M_Material_methods, M_Material_doc);
 
 	if (Modes) PyModule_AddObject(submodule, "Modes", Modes);
-  return (submodule);
+	return (submodule);
 }
 
 /***************************/
@@ -313,7 +315,7 @@ PyObject *Material_Init (void)
 /***************************/
 
 /*****************************************************************************/
-/* Python BPy_Material methods declarations:                                 */
+/* Python BPy_Material methods declarations:																 */
 /*****************************************************************************/
 static PyObject *Material_getName(BPy_Material *self);
 static PyObject *Material_getMode(BPy_Material *self);
@@ -368,121 +370,121 @@ static PyObject *Material_setNLines(BPy_Material *self, PyObject *args);
 static PyObject *Material_setNRings(BPy_Material *self, PyObject *args);
 
 static PyObject *Material_setColorComponent(BPy_Material *self, char *key,
-                PyObject *args);
+								PyObject *args);
 
 /*****************************************************************************/
-/* Python BPy_Material methods table:                                        */
+/* Python BPy_Material methods table:																				 */
 /*****************************************************************************/
 static PyMethodDef BPy_Material_methods[] = {
  /* name, method, flags, doc */
-  {"getName", (PyCFunction)Material_getName, METH_NOARGS,
-      "() - Return Material Data name"},
-  {"getMode", (PyCFunction)Material_getMode, METH_NOARGS,
-      "() - Return Material mode flags"},
-  {"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS,
-      "() - Return Material's rgb color triplet"},
-/*  {"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
-      "() - Return Material's ambient color"},*/
-  {"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS,
-      "() - Return Material's specular color"},
-  {"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS,
-      "() - Return Material's mirror color"},
-  {"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS,
-      "() - Return Material's ambient color blend factor"},
-  {"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS,
-      "() - Return Material's emitting light intensity"},
-  {"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS,
-      "() - Return Material's alpha (transparency) value"},
-  {"getRef", (PyCFunction)Material_getRef, METH_NOARGS,
-      "() - Return Material's reflectivity"},
-  {"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS,
-      "() - Return Material's specularity"},
-  {"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS,
-      "() - Return Material's specular transparency"},
-  {"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS,
-      "() - Return Material's glow factor"},
-  {"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS,
-      "() - Return Material's artificial offset for faces"},
-  {"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS,
-      "() - Return Material's halo size"},
-  {"getHaloSeed", (PyCFunction)Material_getHaloSeed, METH_NOARGS,
-      "() - Return Material's seed for random ring dimension and line "
-	    "location in halos"},
-  {"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS,
-      "() - Return Material's (flare size)/(halo size) factor"},
-  {"getFlareSeed", (PyCFunction)Material_getFlareSeed, METH_NOARGS,
-      "() - Return Material's flare offset in the seed table"},
-  {"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS,
-      "() - Return Material's flare boost"},
-  {"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS,
-      "() - Return Material's dimension of subflare, dots and circles"},
-  {"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS,
-      "() - Return Material's specular hardness"},
-  {"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS,
-      "() - Return Material's number of flares in halo"},
-  {"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS,
-      "() - Return Material's number of points in the halo stars"},
-  {"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS,
-      "() - Return Material's number of lines in halo"},
-  {"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS,
-      "() - Return Material's number of rings in halo"},
-  {"setName", (PyCFunction)Material_setName, METH_VARARGS,
-      "(s) - Change Material Data name"},
-  {"setMode", (PyCFunction)Material_setMode, METH_VARARGS,
-      "([s[,s]]) - Set Material mode flag(s)"},
-  {"setRGBCol", (PyCFunction)Material_setRGBCol, METH_VARARGS,
-      "(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
-/*  {"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
-      "(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
-  {"setSpecCol", (PyCFunction)Material_setSpecCol, METH_VARARGS,
-      "(f,f,f or [f,f,f]) - Set Material's specular color"},
-  {"setMirCol", (PyCFunction)Material_setMirCol, METH_VARARGS,
-      "(f,f,f or [f,f,f]) - Set Material's mirror color"},
-  {"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS,
-      "(f) - Set how much the Material's color is affected"
-              " by \nthe global ambient colors - [0.0, 1.0]"},
-  {"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS,
-      "(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
-  {"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS,
-      "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
-  {"setRef", (PyCFunction)Material_setRef, METH_VARARGS,
-      "(f) - Set Material's reflectivity - [0.0, 1.0]"},
-  {"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS,
-      "(f) - Set Material's specularity - [0.0, 2.0]"},
-  {"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS,
-      "(f) - Set Material's specular transparency - [0.0, 1.0]"},
-  {"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS,
-      "(f) - Set Material's glow factor - [0.0, 1.0]"},
-  {"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS,
-      "(f) - Set Material's artificial offset - [0.0, 10.0]"},
-  {"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS,
-      "(f) - Set Material's halo size - [0.0, 100.0]"},
-  {"setHaloSeed", (PyCFunction)Material_setHaloSeed, METH_VARARGS,
-      "(i) - Set Material's halo seed - [0, 255]"},
-  {"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS,
-      "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
-  {"setFlareSeed", (PyCFunction)Material_setFlareSeed, METH_VARARGS,
-      "(i) - Set Material's flare seed - [0, 255]"},
-  {"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS,
-      "(f) - Set Material's flare boost - [0.1, 10.0]"},
-  {"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS,
-      "(f) - Set Material's dimension of subflare,"
-              " dots and circles - [0.1, 25.0]"},
-  {"setHardness", (PyCFunction)Material_setHardness, METH_VARARGS,
-      "(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
-  {"setNFlares", (PyCFunction)Material_setNFlares, METH_VARARGS,
-      "(i) - Set Material's number of flares in halo - [1, 32]"},
-  {"setNStars", (PyCFunction)Material_setNStars, METH_VARARGS,
-      "(i) - Set Material's number of stars in halo - [3, 50]"},
-  {"setNLines", (PyCFunction)Material_setNLines, METH_VARARGS,
-      "(i) - Set Material's number of lines in halo - [0, 250]"},
-  {"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS,
-      "(i) - Set Material's number of rings in halo - [0, 24]"},
-  {0}
+	{"getName", (PyCFunction)Material_getName, METH_NOARGS,
+			"() - Return Material Data name"},
+	{"getMode", (PyCFunction)Material_getMode, METH_NOARGS,
+			"() - Return Material mode flags"},
+	{"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS,
+			"() - Return Material's rgb color triplet"},
+/*	{"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
+			"() - Return Material's ambient color"},*/
+	{"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS,
+			"() - Return Material's specular color"},
+	{"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS,
+			"() - Return Material's mirror color"},
+	{"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS,
+			"() - Return Material's ambient color blend factor"},
+	{"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS,
+			"() - Return Material's emitting light intensity"},
+	{"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS,
+			"() - Return Material's alpha (transparency) value"},
+	{"getRef", (PyCFunction)Material_getRef, METH_NOARGS,
+			"() - Return Material's reflectivity"},
+	{"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS,
+			"() - Return Material's specularity"},
+	{"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS,
+			"() - Return Material's specular transparency"},
+	{"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS,
+			"() - Return Material's glow factor"},
+	{"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS,
+			"() - Return Material's artificial offset for faces"},
+	{"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS,
+			"() - Return Material's halo size"},
+	{"getHaloSeed", (PyCFunction)Material_getHaloSeed, METH_NOARGS,
+			"() - Return Material's seed for random ring dimension and line "
+			"location in halos"},
+	{"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS,
+			"() - Return Material's (flare size)/(halo size) factor"},
+	{"getFlareSeed", (PyCFunction)Material_getFlareSeed, METH_NOARGS,
+			"() - Return Material's flare offset in the seed table"},
+	{"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS,
+			"() - Return Material's flare boost"},
+	{"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS,
+			"() - Return Material's dimension of subflare, dots and circles"},
+	{"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS,
+			"() - Return Material's specular hardness"},
+	{"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS,
+			"() - Return Material's number of flares in halo"},
+	{"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS,
+			"() - Return Material's number of points in the halo stars"},
+	{"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS,
+			"() - Return Material's number of lines in halo"},
+	{"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS,
+			"() - Return Material's number of rings in halo"},
+	{"setName", (PyCFunction)Material_setName, METH_VARARGS,
+			"(s) - Change Material Data name"},
+	{"setMode", (PyCFunction)Material_setMode, METH_VARARGS,
+			"([s[,s]]) - Set Material mode flag(s)"},
+	{"setRGBCol", (PyCFunction)Material_setRGBCol, METH_VARARGS,
+			"(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
+/*	{"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
+			"(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
+	{"setSpecCol", (PyCFunction)Material_setSpecCol, METH_VARARGS,
+			"(f,f,f or [f,f,f]) - Set Material's specular color"},
+	{"setMirCol", (PyCFunction)Material_setMirCol, METH_VARARGS,
+			"(f,f,f or [f,f,f]) - Set Material's mirror color"},
+	{"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS,
+			"(f) - Set how much the Material's color is affected"
+							" by \nthe global ambient colors - [0.0, 1.0]"},
+	{"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS,
+			"(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
+	{"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS,
+			"(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
+	{"setRef", (PyCFunction)Material_setRef, METH_VARARGS,
+			"(f) - Set Material's reflectivity - [0.0, 1.0]"},
+	{"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS,
+			"(f) - Set Material's specularity - [0.0, 2.0]"},
+	{"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS,
+			"(f) - Set Material's specular transparency - [0.0, 1.0]"},
+	{"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS,
+			"(f) - Set Material's glow factor - [0.0, 1.0]"},
+	{"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS,
+			"(f) - Set Material's artificial offset - [0.0, 10.0]"},
+	{"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS,
+			"(f) - Set Material's halo size - [0.0, 100.0]"},
+	{"setHaloSeed", (PyCFunction)Material_setHaloSeed, METH_VARARGS,
+			"(i) - Set Material's halo seed - [0, 255]"},
+	{"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS,
+			"(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
+	{"setFlareSeed", (PyCFunction)Material_setFlareSeed, METH_VARARGS,
+			"(i) - Set Material's flare seed - [0, 255]"},
+	{"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS,
+			"(f) - Set Material's flare boost - [0.1, 10.0]"},
+	{"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS,
+			"(f) - Set Material's dimension of subflare,"
+							" dots and circles - [0.1, 25.0]"},
+	{"setHardness", (PyCFunction)Material_setHardness, METH_VARARGS,
+			"(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
+	{"setNFlares", (PyCFunction)Material_setNFlares, METH_VARARGS,
+			"(i) - Set Material's number of flares in halo - [1, 32]"},
+	{"setNStars", (PyCFunction)Material_setNStars, METH_VARARGS,
+			"(i) - Set Material's number of stars in halo - [3, 50]"},
+	{"setNLines", (PyCFunction)Material_setNLines, METH_VARARGS,
+			"(i) - Set Material's number of lines in halo - [0, 250]"},
+	{"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS,
+			"(i) - Set Material's number of rings in halo - [0, 24]"},
+	{0}
 };
 
 /*****************************************************************************/
-/* Python Material_Type callback function prototypes:                        */
+/* Python Material_Type callback function prototypes:												 */
 /*****************************************************************************/
 static void Material_dealloc (BPy_Material *self);
 static int Material_setAttr (BPy_Material *self, char *name, PyObject *v);
@@ -490,116 +492,116 @@ static PyObject *Material_getAttr (BPy_Material *self, char *name);
 static PyObject *Material_repr (BPy_Material *self);
 
 /*****************************************************************************/
-/* Python Material_Type structure definition:                                */
+/* Python Material_Type structure definition:																 */
 /*****************************************************************************/
 PyTypeObject Material_Type =
 {
-  PyObject_HEAD_INIT(NULL)
-  0,                                      /* ob_size */
-  "Blender Material",                     /* tp_name */
-  sizeof (BPy_Material),                  /* tp_basicsize */
-  0,                                      /* tp_itemsize */
-  /* methods */
-  (destructor)Material_dealloc,           /* tp_dealloc */
-  0,                                      /* tp_print */
-  (getattrfunc)Material_getAttr,          /* tp_getattr */
-  (setattrfunc)Material_setAttr,          /* tp_setattr */
-  0,                                      /* tp_compare */
-  (reprfunc)Material_repr,                /* 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_Material_methods,                     /* tp_methods */
-  0,                                      /* tp_members */
+	PyObject_HEAD_INIT(NULL)
+	0,																			/* ob_size */
+	"Blender Material",											/* tp_name */
+	sizeof (BPy_Material),									/* tp_basicsize */
+	0,																			/* tp_itemsize */
+	/* methods */
+	(destructor)Material_dealloc,						/* tp_dealloc */
+	0,																			/* tp_print */
+	(getattrfunc)Material_getAttr,					/* tp_getattr */
+	(setattrfunc)Material_setAttr,					/* tp_setattr */
+	0,																			/* tp_compare */
+	(reprfunc)Material_repr,								/* 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_Material_methods,											/* tp_methods */
+	0,																			/* tp_members */
 };
 
 /*****************************************************************************/
-/* Function:    Material_dealloc                                             */
+/* Function:		Material_dealloc																						 */
 /* Description: This is a callback function for the BPy_Material type. It is */
-/*              the destructor function.                                     */
+/*							the destructor function.																		 */
 /*****************************************************************************/
 static void Material_dealloc (BPy_Material *self)
 {
-  Py_DECREF (self->col);
-  Py_DECREF (self->amb);
-  Py_DECREF (self->spec);
-  Py_DECREF (self->mir);
-  PyObject_DEL (self);
+	Py_DECREF (self->col);
+	Py_DECREF (self->amb);
+	Py_DECREF (self->spec);
+	Py_DECREF (self->mir);
+	PyObject_DEL (self);
 }
 
 /*****************************************************************************/
-/* Function:    Material_CreatePyObject                                      */
+/* Function:		Material_CreatePyObject																			 */
 /* Description: This function will create a new BPy_Material from an existing*/
-/*              Blender material structure.                                  */
+/*							Blender material structure.																	 */
 /*****************************************************************************/
 PyObject *Material_CreatePyObject (struct Material *mat)
 {
-  BPy_Material *pymat;
-  float *col[3], *amb[3], *spec[3], *mir[3];
+	BPy_Material *pymat;
+	float *col[3], *amb[3], *spec[3], *mir[3];
 
-  pymat = (BPy_Material *)PyObject_NEW (BPy_Material, &Material_Type);
+	pymat = (BPy_Material *)PyObject_NEW (BPy_Material, &Material_Type);
 
-  if (!pymat)
-    return EXPP_ReturnPyObjError (PyExc_MemoryError,
-            "couldn't create BPy_Material object");
+	if (!pymat)
+		return EXPP_ReturnPyObjError (PyExc_MemoryError,
+						"couldn't create BPy_Material object");
 
-  pymat->material = mat;
+	pymat->material = mat;
 
-  col[0] = &mat->r;
-  col[1] = &mat->g;
-  col[2] = &mat->b;
+	col[0] = &mat->r;
+	col[1] = &mat->g;
+	col[2] = &mat->b;
 
-  amb[0] = &mat->ambr;
-  amb[1] = &mat->ambg;
-  amb[2] = &mat->ambb;
+	amb[0] = &mat->ambr;
+	amb[1] = &mat->ambg;
+	amb[2] = &mat->ambb;
 
-  spec[0] = &mat->specr;
-  spec[1] = &mat->specg;
-  spec[2] = &mat->specb;
+	spec[0] = &mat->specr;
+	spec[1] = &mat->specg;
+	spec[2] = &mat->specb;
 
-  mir[0] = &mat->mirr;
-  mir[1] = &mat->mirg;
-  mir[2] = &mat->mirb;
+	mir[0] = &mat->mirr;
+	mir[1] = &mat->mirg;
+	mir[2] = &mat->mirb;
 
-  pymat->col  = (BPy_rgbTuple *)rgbTuple_New(col);
-  pymat->amb  = (BPy_rgbTuple *)rgbTuple_New(amb);
-  pymat->spec = (BPy_rgbTuple *)rgbTuple_New(spec);
-  pymat->mir  = (BPy_rgbTuple *)rgbTuple_New(mir);
+	pymat->col	= (BPy_rgbTuple *)rgbTuple_New(col);
+	pymat->amb	= (BPy_rgbTuple *)rgbTuple_New(amb);
+	pymat->spec = (BPy_rgbTuple *)rgbTuple_New(spec);
+	pymat->mir	= (BPy_rgbTuple *)rgbTuple_New(mir);
 
-  return (PyObject *)pymat;
+	return (PyObject *)pymat;
 }
 
 /*****************************************************************************/
-/* Function:    Material_CheckPyObject                                       */
+/* Function:		Material_CheckPyObject																			 */
 /* Description: This function returns true when the given PyObject is of the */
-/*              type Material. Otherwise it will return false.               */
+/*							type Material. Otherwise it will return false.							 */
 /*****************************************************************************/
 int Material_CheckPyObject (PyObject *pyobj)
 {
-  return (pyobj->ob_type == &Material_Type);
+	return (pyobj->ob_type == &Material_Type);
 }
 
 /*****************************************************************************/
-/* Function:    Material_FromPyObject                                        */
-/* Description: This function returns the Blender material from the given    */
-/*              PyObject.                                                    */
+/* Function:		Material_FromPyObject																				 */
+/* Description: This function returns the Blender material from the given		 */
+/*							PyObject.																										 */
 /*****************************************************************************/
 Material *Material_FromPyObject (PyObject *pyobj)
 {
-  return ((BPy_Material *)pyobj)->material;
+	return ((BPy_Material *)pyobj)->material;
 }
 
 /*****************************************************************************/
-/* Description: Returns the object with the name specified by the argument   */
-/*              name. Note that the calling function has to remove the first */
-/*              two characters of the object name. These two characters      */
-/*              specify the type of the object (OB, ME, WO, ...)             */
-/*              The function will return NULL when no object with the given  */
-/*              name is found.                                               */
+/* Description: Returns the object with the name specified by the argument	 */
+/*							name. Note that the calling function has to remove the first */
+/*							two characters of the object name. These two characters			 */
+/*							specify the type of the object (OB, ME, WO, ...)						 */
+/*							The function will return NULL when no object with the given  */
+/*							name is found.																							 */
 /*****************************************************************************/
 Material * GetMaterialByName (char * name)
 {
@@ -620,253 +622,253 @@ Material * GetMaterialByName (char * name)
 }
 
 /*****************************************************************************/
-/* Python BPy_Material methods:                                                */
+/* Python BPy_Material methods:																								 */
 /*****************************************************************************/
 static PyObject *Material_getName(BPy_Material *self)
 {
-  PyObject *attr = PyString_FromString(self->material->id.name+2);
+	PyObject *attr = PyString_FromString(self->material->id.name+2);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.name attribute"));
+	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.name attribute"));
 }
 
 static PyObject *Material_getMode(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->mode);
+	PyObject *attr = PyInt_FromLong((long)self->material->mode);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.Mode attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.Mode attribute");
 }
 
 static PyObject *Material_getRGBCol(BPy_Material *self)
 {
-  return rgbTuple_getCol(self->col);
+	return rgbTuple_getCol(self->col);
 }
 /*
 static PyObject *Material_getAmbCol(BPy_Material *self)
 {
-  return rgbTuple_getCol(self->amb);
+	return rgbTuple_getCol(self->amb);
 }
 */
 static PyObject *Material_getSpecCol(BPy_Material *self)
 {
-  return rgbTuple_getCol(self->spec);
+	return rgbTuple_getCol(self->spec);
 }
 
 static PyObject *Material_getMirCol(BPy_Material *self)
 {
-  return rgbTuple_getCol(self->mir);
+	return rgbTuple_getCol(self->mir);
 }
 
 static PyObject *Material_getAmb(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->amb);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->amb);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.amb attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.amb attribute");
 }
 
 static PyObject *Material_getEmit(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->emit);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->emit);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.emit attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.emit attribute");
 }
 
 static PyObject *Material_getAlpha(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.alpha attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.alpha attribute");
 }
 
 static PyObject *Material_getRef(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->ref);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->ref);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.ref attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.ref attribute");
 }
 
 static PyObject *Material_getSpec(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->spec);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->spec);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.spec attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.spec attribute");
 }
 
 static PyObject *Material_getSpecTransp(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-              "couldn't get Material.specTransp attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+							"couldn't get Material.specTransp attribute");
 }
 
 static PyObject *Material_getAdd(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->add);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->add);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                                   "couldn't get Material.add attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+																	 "couldn't get Material.add attribute");
 }
 
 static PyObject *Material_getZOffset(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                        "couldn't get Material.zOffset attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+												"couldn't get Material.zOffset attribute");
 }
 
 static PyObject *Material_getHaloSize(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                   "couldn't get Material.haloSize attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+									 "couldn't get Material.haloSize attribute");
 }
 
 static PyObject *Material_getFlareSize(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                     "couldn't get Material.flareSize attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+										 "couldn't get Material.flareSize attribute");
 }
 
 static PyObject *Material_getFlareBoost(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                     "couldn't get Material.flareBoost attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+										 "couldn't get Material.flareBoost attribute");
 }
 
 static PyObject *Material_getSubSize(BPy_Material *self)
 {
-  PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);
+	PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-               "couldn't get Material.subSize attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+							 "couldn't get Material.subSize attribute");
 }
 
 static PyObject *Material_getHaloSeed(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->seed1);
+	PyObject *attr = PyInt_FromLong((long)self->material->seed1);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.haloSeed attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.haloSeed attribute");
 }
 
 static PyObject *Material_getFlareSeed(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->seed2);
+	PyObject *attr = PyInt_FromLong((long)self->material->seed2);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.flareSeed attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.flareSeed attribute");
 }
 
 static PyObject *Material_getHardness(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->har);
+	PyObject *attr = PyInt_FromLong((long)self->material->har);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.hard attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.hard attribute");
 }
 
 static PyObject *Material_getNFlares(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->flarec);
+	PyObject *attr = PyInt_FromLong((long)self->material->flarec);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.nFlares attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.nFlares attribute");
 }
 
 static PyObject *Material_getNStars(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->starc);
+	PyObject *attr = PyInt_FromLong((long)self->material->starc);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.nStars attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.nStars attribute");
 }
 
 static PyObject *Material_getNLines(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->linec);
+	PyObject *attr = PyInt_FromLong((long)self->material->linec);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.nLines attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.nLines attribute");
 }
 
 static PyObject *Material_getNRings(BPy_Material *self)
 {
-  PyObject *attr = PyInt_FromLong((long)self->material->ringc);
+	PyObject *attr = PyInt_FromLong((long)self->material->ringc);
 
-  if (attr) return attr;
+	if (attr) return attr;
 
-  return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-                       "couldn't get Material.nRings attribute");
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+											 "couldn't get Material.nRings attribute");
 }
 
 static PyObject *Material_setName(BPy_Material *self, PyObject *args)
 {
-  char *name;
-  char buf[21];
+	char *name;
+	char buf[21];
 
-  if (!PyArg_ParseTuple(args, "s", &name))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-                                     "expected string argument"));
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+																		 "expected string argument"));
 
-  PyOS_snprintf(buf, sizeof(buf), "%s", name);
+	PyOS_snprintf(buf, sizeof(buf), "%s", name);
 
-  rename_id(&self->material->id, buf);
+	rename_id(&self->material->id, buf);
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 /* Possible modes are traceable, shadow, shadeless, wire, vcolLight,
@@ -875,710 +877,712 @@ static PyObject *Material_setName(BPy_Material *self, PyObject *args)
  * haloShaded, haloFlare */
 static PyObject *Material_setMode(BPy_Material *self, PyObject *args)
 {
-  int i, flag = 0;
-  char *m[21] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                 NULL, NULL, NULL, NULL, NULL, NULL, NULL};
-
-  if (!PyArg_ParseTuple(args, "|sssssssssssssssssssss",
-          &m[0], &m[1], &m[2], &m[3],  &m[4],  &m[5],  &m[6],
-          &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13],
-          &m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20]))
-  {
-    return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-            "expected from none to 21 string argument(s)"));
-  }
-
-  for (i = 0; i < 21; i++) {
-    if (m[i] == NULL) break;
-    if (strcmp(m[i], "Traceable") == 0)
-      flag |= (short)EXPP_MAT_MODE_TRACEABLE;
-    else if (strcmp(m[i], "Shadow") == 0)
-      flag |= (short)EXPP_MAT_MODE_SHADOW;
-    else if (strcmp(m[i], "Shadeless") == 0)
-      flag |= (short)EXPP_MAT_MODE_SHADELESS;
-    else if (strcmp(m[i], "Wire") == 0)
-      flag |= (short)EXPP_MAT_MODE_WIRE;
-    else if (strcmp(m[i], "VColLight") == 0)
-      flag |= (short)EXPP_MAT_MODE_VCOL_LIGHT;
-    else if (strcmp(m[i], "VColPaint") == 0)
-      flag |= (short)EXPP_MAT_MODE_VCOL_PAINT;
-    else if (strcmp(m[i], "Halo") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALO;
-    else if (strcmp(m[i], "ZTransp") == 0)
-      flag |= (short)EXPP_MAT_MODE_ZTRANSP;
-    else if (strcmp(m[i], "ZInvert") == 0)
-      flag |= (short)EXPP_MAT_MODE_ZINVERT;
-    else if (strcmp(m[i], "HaloRings") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALORINGS;
-    else if (strcmp(m[i], "Env") == 0)
-      flag |= (short)EXPP_MAT_MODE_ENV;
-    else if (strcmp(m[i], "HaloLines") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOLINES;
-    else if (strcmp(m[i], "OnlyShadow") == 0)
-      flag |= (short)EXPP_MAT_MODE_ONLYSHADOW;
-    else if (strcmp(m[i], "HaloXAlpha") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOXALPHA;
-    else if (strcmp(m[i], "HaloStar") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOSTAR;
-    else if (strcmp(m[i], "TexFace") == 0)
-      flag |= (short)EXPP_MAT_MODE_TEXFACE;
-    else if (strcmp(m[i], "HaloTex") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOTEX;
-    else if (strcmp(m[i], "HaloPuno") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOPUNO;
-    else if (strcmp(m[i], "NoMist") == 0)
-      flag |= (short)EXPP_MAT_MODE_NOMIST;
-    else if (strcmp(m[i], "HaloShaded") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOSHADE;
-    else if (strcmp(m[i], "HaloFlare") == 0)
-      flag |= (short)EXPP_MAT_MODE_HALOFLARE;
-    else
-      return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-              "unknown Material mode argument"));
-  }
-
-  self->material->mode = flag;
-
-  Py_INCREF(Py_None);
-  return Py_None;
+	int i, flag = 0;
+	char *m[22] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+								 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+								 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+
+	if (!PyArg_ParseTuple(args, "|ssssssssssssssssssssss",
+					&m[0], &m[1], &m[2], &m[3],  &m[4],  &m[5],  &m[6],
+					&m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13],
+					&m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20], &m[21]))
+	{
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected from none to 22 string argument(s)"));
+	}
+
+	for (i = 0; i < 22; i++) {
+		if (m[i] == NULL) break;
+		if (strcmp(m[i], "Traceable") == 0)
+			flag |= EXPP_MAT_MODE_TRACEABLE;
+		else if (strcmp(m[i], "Shadow") == 0)
+			flag |= EXPP_MAT_MODE_SHADOW;
+		else if (strcmp(m[i], "Shadeless") == 0)
+			flag |= EXPP_MAT_MODE_SHADELESS;
+		else if (strcmp(m[i], "Wire") == 0)
+			flag |= EXPP_MAT_MODE_WIRE;
+		else if (strcmp(m[i], "VColLight") == 0)
+			flag |= EXPP_MAT_MODE_VCOL_LIGHT;
+		else if (strcmp(m[i], "VColPaint") == 0)
+			flag |= EXPP_MAT_MODE_VCOL_PAINT;
+		else if (strcmp(m[i], "Halo") == 0)
+			flag |= EXPP_MAT_MODE_HALO;
+		else if (strcmp(m[i], "ZTransp") == 0)
+			flag |= EXPP_MAT_MODE_ZTRANSP;
+		else if (strcmp(m[i], "ZInvert") == 0)
+			flag |= EXPP_MAT_MODE_ZINVERT;
+		else if (strcmp(m[i], "HaloRings") == 0)
+			flag |= EXPP_MAT_MODE_HALORINGS;
+		else if (strcmp(m[i], "Env") == 0)
+			flag |= EXPP_MAT_MODE_ENV;
+		else if (strcmp(m[i], "HaloLines") == 0)
+			flag |= EXPP_MAT_MODE_HALOLINES;
+		else if (strcmp(m[i], "OnlyShadow") == 0)
+			flag |= EXPP_MAT_MODE_ONLYSHADOW;
+		else if (strcmp(m[i], "HaloXAlpha") == 0)
+			flag |= EXPP_MAT_MODE_HALOXALPHA;
+		else if (strcmp(m[i], "HaloStar") == 0)
+			flag |= EXPP_MAT_MODE_HALOSTAR;
+		else if (strcmp(m[i], "TexFace") == 0)
+			flag |= EXPP_MAT_MODE_TEXFACE;
+		else if (strcmp(m[i], "HaloTex") == 0)
+			flag |= EXPP_MAT_MODE_HALOTEX;
+		else if (strcmp(m[i], "HaloPuno") == 0)
+			flag |= EXPP_MAT_MODE_HALOPUNO;
+		else if (strcmp(m[i], "NoMist") == 0)
+			flag |= EXPP_MAT_MODE_NOMIST;
+		else if (strcmp(m[i], "HaloShaded") == 0)
+			flag |= EXPP_MAT_MODE_HALOSHADE;
+		else if (strcmp(m[i], "HaloFlare") == 0)
+			flag |= EXPP_MAT_MODE_HALOFLARE;
+		else if (strcmp(m[i], "Radio") == 0)
+			flag |= EXPP_MAT_MODE_RADIO;
+		else
+			return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+							"unknown Material mode argument"));
+	}
+
+	self->material->mode = flag;
+
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 /* Another helper function, for the same reason.
  * (See comment before Material_setIntType above). */
 static PyObject *Material_setIntMode(BPy_Material *self, PyObject *args)
 {
-  int value;
+	int value;
 
-  if (!PyArg_ParseTuple(args, "i", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-                                     "expected int argument"));
+	if (!PyArg_ParseTuple(args, "i", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+																		 "expected int argument"));
 
-  self->material->mode = value;
+	self->material->mode = value;
 
-  Py_INCREF(Py_None);
-  return Py_None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 static PyObject *Material_setRGBCol (BPy_Material *self, PyObject *args)
 {
-  return rgbTuple_setCol(self->col, args);
+	return rgbTuple_setCol(self->col, args);
 }
 /*
 static PyObject *Material_setAmbCol (BPy_Material *self, PyObject *args)
 {
-  return rgbTuple_setCol(self->amb, args);
+	return rgbTuple_setCol(self->amb, args);
 }
 */
 static PyObject *Material_setSpecCol (BPy_Material *self, PyObject *args)
 {
-  return rgbTuple_setCol(self->spec, args);
+	return rgbTuple_setCol(self->spec, args);
 }
 
 static PyObject *Material_setMirCol (BPy_Material *self, PyObject *args)
 {
-  return rgbTuple_setCol(self->mir, args);
+	return rgbTuple_setCol(self->mir, args);
 }
 
 static PyObject *Material_setColorComponent(BPy_Material *self, char *key,
-                PyObject *args)
+								PyObject *args)
 { /* for compatibility with old bpython */
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN,
-                  EXPP_MAT_COL_MAX);
+	value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN,
+									EXPP_MAT_COL_MAX);
 
-  if (!strcmp(key, "R"))
-    self->material->r = value;
-  else if (!strcmp(key, "G"))
-    self->material->g = value;
-  else if (!strcmp(key, "B"))
-    self->material->b = value;
-  else if (!strcmp(key, "specR"))
-    self->material->specr = value;
-  else if (!strcmp(key, "specG"))
-    self->material->specg = value;
-  else if (!strcmp(key, "specB"))
-    self->material->specb = value;
+	if (!strcmp(key, "R"))
+		self->material->r = value;
+	else if (!strcmp(key, "G"))
+		self->material->g = value;
+	else if (!strcmp(key, "B"))
+		self->material->b = value;
+	else if (!strcmp(key, "specR"))
+		self->material->specr = value;
+	else if (!strcmp(key, "specG"))
+		self->material->specg = value;
+	else if (!strcmp(key, "specB"))
+		self->material->specb = value;
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setAmb(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN,
-                  EXPP_MAT_AMB_MAX);
+	self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN,
+									EXPP_MAT_AMB_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setEmit(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN,
-                  EXPP_MAT_EMIT_MAX);
+	self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN,
+									EXPP_MAT_EMIT_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setSpecTransp(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN,
-                  EXPP_MAT_SPECTRA_MAX);
+	self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN,
+									EXPP_MAT_SPECTRA_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setAlpha(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN,
-                  EXPP_MAT_ALPHA_MAX);
+	self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN,
+									EXPP_MAT_ALPHA_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setRef(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN,
-                  EXPP_MAT_REF_MAX);
+	self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN,
+									EXPP_MAT_REF_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setSpec(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN,
-                  EXPP_MAT_SPEC_MAX);
+	self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN,
+									EXPP_MAT_SPEC_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setZOffset(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 10.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 10.0]"));
 
-  self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN,
-                  EXPP_MAT_ZOFFS_MAX);
+	self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN,
+									EXPP_MAT_ZOFFS_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setAdd(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 1.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 1.0]"));
 
-  self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN,
-                  EXPP_MAT_ADD_MAX);
+	self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN,
+									EXPP_MAT_ADD_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setHaloSize(BPy_Material *self, PyObject *args)
 {
-  float value;
+	float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.0, 100.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.0, 100.0]"));
 
-  self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN,
-                  EXPP_MAT_HALOSIZE_MAX);
+	self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN,
+									EXPP_MAT_HALOSIZE_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setFlareSize(BPy_Material *self, PyObject *args)
 {
-   float value;
+	 float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.1, 25.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.1, 25.0]"));
 
-  self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN,
-                  EXPP_MAT_FLARESIZE_MAX);
+	self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN,
+									EXPP_MAT_FLARESIZE_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setFlareBoost(BPy_Material *self, PyObject *args)
 {
-   float value;
+	 float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.1, 10.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.1, 10.0]"));
 
-  self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN,
-                  EXPP_MAT_FLAREBOOST_MAX);
+	self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN,
+									EXPP_MAT_FLAREBOOST_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setSubSize(BPy_Material *self, PyObject *args)
 {
-   float value;
+	 float value;
 
-  if (!PyArg_ParseTuple(args, "f", &value))
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected float argument in [0.1, 25.0]"));
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected float argument in [0.1, 25.0]"));
 
-  self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN,
-                  EXPP_MAT_SUBSIZE_MAX);
+	self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN,
+									EXPP_MAT_SUBSIZE_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setHaloSeed(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [1, 255]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [1, 255]"));
 
-  self->material->seed1 = EXPP_ClampInt (value, EXPP_MAT_HALOSEED_MIN,
-                  EXPP_MAT_HALOSEED_MAX);
+	self->material->seed1 = EXPP_ClampInt (value, EXPP_MAT_HALOSEED_MIN,
+									EXPP_MAT_HALOSEED_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setFlareSeed(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [1, 255]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [1, 255]"));
 
-  self->material->seed2 = EXPP_ClampInt (value, EXPP_MAT_FLARESEED_MIN,
-                  EXPP_MAT_FLARESEED_MAX);
+	self->material->seed2 = EXPP_ClampInt (value, EXPP_MAT_FLARESEED_MIN,
+									EXPP_MAT_FLARESEED_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 
 static PyObject *Material_setHardness(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [1, 255]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [1, 255]"));
 
-  self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN,
-                  EXPP_MAT_HARD_MAX);
+	self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN,
+									EXPP_MAT_HARD_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setNFlares(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [1, 32]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [1, 32]"));
 
-  self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN,
-                  EXPP_MAT_NFLARES_MAX);
+	self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN,
+									EXPP_MAT_NFLARES_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setNStars(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [3, 50]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [3, 50]"));
 
-  self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN,
-                  EXPP_MAT_NSTARS_MAX);
+	self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN,
+									EXPP_MAT_NSTARS_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setNLines(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [0, 250]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [0, 250]"));
 
-  self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN,
-                  EXPP_MAT_NLINES_MAX);
+	self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN,
+									EXPP_MAT_NLINES_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 static PyObject *Material_setNRings(BPy_Material *self, PyObject *args)
 {
-  short value;
+	short value;
 
-  if (!PyArg_ParseTuple(args, "h", &value))      
-    return (EXPP_ReturnPyObjError (PyExc_TypeError,
-            "expected int argument in [0, 24]"));
+	if (!PyArg_ParseTuple(args, "h", &value))			 
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument in [0, 24]"));
 
-  self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN,
-                  EXPP_MAT_NRINGS_MAX);
+	self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN,
+									EXPP_MAT_NRINGS_MAX);
 
-  return EXPP_incr_ret (Py_None);
+	return EXPP_incr_ret (Py_None);
 }
 
 /*****************************************************************************/
-/* Function:    Material_getAttr                                             */
+/* Function:		Material_getAttr																						 */
 /* Description: This is a callback function for the BPy_Material type. It is */
-/*              the function that accesses BPy_Material "member variables"   */
-/*              and methods.                                                 */
+/*							the function that accesses BPy_Material "member variables"	 */
+/*							and methods.																								 */
 /*****************************************************************************/
 static PyObject *Material_getAttr (BPy_Material *self, char *name)
 {
-  PyObject *attr = Py_None;
-
-  if (strcmp(name, "name") == 0)
-    attr = PyString_FromString(self->material->id.name+2);
-  else if (strcmp(name, "mode") == 0)
-    attr = PyInt_FromLong(self->material->mode);
-  else if (strcmp(name, "rgbCol") == 0)
-    attr = Material_getRGBCol(self);
-/*  else if (strcmp(name, "ambCol") == 0)
-    attr = Material_getAmbCol(self);*/
-  else if (strcmp(name, "specCol") == 0)
-    attr = Material_getSpecCol(self);
-  else if (strcmp(name, "mirCol") == 0)
-    attr = Material_getMirCol(self);
-  else if (strcmp(name, "R") == 0)
-    attr = PyFloat_FromDouble((double)self->material->r);
-  else if (strcmp(name, "G") == 0)
-    attr = PyFloat_FromDouble((double)self->material->g);
-  else if (strcmp(name, "B") == 0)
-    attr = PyFloat_FromDouble((double)self->material->b);
-  else if (strcmp(name, "specR") == 0)
-    attr = PyFloat_FromDouble((double)self->material->specr);
-  else if (strcmp(name, "specG") == 0)
-    attr = PyFloat_FromDouble((double)self->material->specg);
-  else if (strcmp(name, "specB") == 0)
-    attr = PyFloat_FromDouble((double)self->material->specb);
-  else if (strcmp(name, "amb") == 0)
-    attr = PyFloat_FromDouble((double)self->material->amb);
-  else if (strcmp(name, "emit") == 0)
-    attr = PyFloat_FromDouble((double)self->material->emit);
-  else if (strcmp(name, "alpha") == 0)
-    attr = PyFloat_FromDouble((double)self->material->alpha);
-  else if (strcmp(name, "ref") == 0)
-    attr = PyFloat_FromDouble((double)self->material->ref);
-  else if (strcmp(name, "spec") == 0)
-    attr = PyFloat_FromDouble((double)self->material->spec);
-  else if (strcmp(name, "specTransp") == 0)
-    attr = PyFloat_FromDouble((double)self->material->spectra);
-  else if (strcmp(name, "add") == 0)
-    attr = PyFloat_FromDouble((double)self->material->add);
-  else if (strcmp(name, "zOffset") == 0)
-    attr = PyFloat_FromDouble((double)self->material->zoffs);
-  else if (strcmp(name, "haloSize") == 0)
-    attr = PyFloat_FromDouble((double)self->material->hasize);
-  else if (strcmp(name, "haloSeed") == 0)
-    attr = PyInt_FromLong((double)self->material->seed1);
-  else if (strcmp(name, "flareSize") == 0)
-    attr = PyFloat_FromDouble((double)self->material->flaresize);
-  else if (strcmp(name, "flareBoost") == 0)
-    attr = PyFloat_FromDouble((double)self->material->flareboost);
-  else if (strcmp(name, "flareSeed") == 0)
-    attr = PyInt_FromLong((double)self->material->seed2);
-  else if (strcmp(name, "subSize") == 0)
-    attr = PyFloat_FromDouble((double)self->material->subsize);
-  else if (strcmp(name, "hard") == 0)
-    attr = PyInt_FromLong((long)self->material->har);
-  else if (strcmp(name, "nFlares") == 0)
-    attr = PyInt_FromLong((long)self->material->flarec);
-  else if (strcmp(name, "nStars") == 0)
-    attr = PyInt_FromLong((long)self->material->starc);
-  else if (strcmp(name, "nLines") == 0)
-    attr = PyInt_FromLong((long)self->material->linec);
-  else if (strcmp(name, "nRings") == 0)
-    attr = PyInt_FromLong((long)self->material->ringc);
-
-  else if (strcmp(name, "__members__") == 0) {
-    attr = /* 27 items */
-      Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
-        "name", "mode", "rgbCol", "specCol", "mirCol",
-        "R", "G", "B", "alpha", "amb", "emit", "ref", "spec",
-		    "specTransp", "add", "zOffset", "haloSize", "haloSeed",
-		    "flareSize", "flareBoost", "flareSeed", "subSize", "hard",
-		    "nFlares", "nStars", "nLines", "nRings");
-  }
-
-  if (!attr)
-    return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-                      "couldn't create PyObject"));
-
-  if (attr != Py_None) return attr; /* member attribute found, return it */
-
-  /* not an attribute, search the methods table */
-  return Py_FindMethod(BPy_Material_methods, (PyObject *)self, name);
+	PyObject *attr = Py_None;
+
+	if (strcmp(name, "name") == 0)
+		attr = PyString_FromString(self->material->id.name+2);
+	else if (strcmp(name, "mode") == 0)
+		attr = PyInt_FromLong(self->material->mode);
+	else if (strcmp(name, "rgbCol") == 0)
+		attr = Material_getRGBCol(self);
+/*	else if (strcmp(name, "ambCol") == 0)
+		attr = Material_getAmbCol(self);*/
+	else if (strcmp(name, "specCol") == 0)
+		attr = Material_getSpecCol(self);
+	else if (strcmp(name, "mirCol") == 0)
+		attr = Material_getMirCol(self);
+	else if (strcmp(name, "R") == 0)
+		attr = PyFloat_FromDouble((double)self->material->r);
+	else if (strcmp(name, "G") == 0)
+		attr = PyFloat_FromDouble((double)self->material->g);
+	else if (strcmp(name, "B") == 0)
+		attr = PyFloat_FromDouble((double)self->material->b);
+	else if (strcmp(name, "specR") == 0)
+		attr = PyFloat_FromDouble((double)self->material->specr);
+	else if (strcmp(name, "specG") == 0)
+		attr = PyFloat_FromDouble((double)self->material->specg);
+	else if (strcmp(name, "specB") == 0)
+		attr = PyFloat_FromDouble((double)self->material->specb);
+	else if (strcmp(name, "amb") == 0)
+		attr = PyFloat_FromDouble((double)self->material->amb);
+	else if (strcmp(name, "emit") == 0)
+		attr = PyFloat_FromDouble((double)self->material->emit);
+	else if (strcmp(name, "alpha") == 0)
+		attr = PyFloat_FromDouble((double)self->material->alpha);
+	else if (strcmp(name, "ref") == 0)
+		attr = PyFloat_FromDouble((double)self->material->ref);
+	else if (strcmp(name, "spec") == 0)
+		attr = PyFloat_FromDouble((double)self->material->spec);
+	else if (strcmp(name, "specTransp") == 0)
+		attr = PyFloat_FromDouble((double)self->material->spectra);
+	else if (strcmp(name, "add") == 0)
+		attr = PyFloat_FromDouble((double)self->material->add);
+	else if (strcmp(name, "zOffset") == 0)
+		attr = PyFloat_FromDouble((double)self->material->zoffs);
+	else if (strcmp(name, "haloSize") == 0)
+		attr = PyFloat_FromDouble((double)self->material->hasize);
+	else if (strcmp(name, "haloSeed") == 0)
+		attr = PyInt_FromLong((double)self->material->seed1);
+	else if (strcmp(name, "flareSize") == 0)
+		attr = PyFloat_FromDouble((double)self->material->flaresize);
+	else if (strcmp(name, "flareBoost") == 0)
+		attr = PyFloat_FromDouble((double)self->material->flareboost);
+	else if (strcmp(name, "flareSeed") == 0)
+		attr = PyInt_FromLong((double)self->material->seed2);
+	else if (strcmp(name, "subSize") == 0)
+		attr = PyFloat_FromDouble((double)self->material->subsize);
+	else if (strcmp(name, "hard") == 0)
+		attr = PyInt_FromLong((long)self->material->har);
+	else if (strcmp(name, "nFlares") == 0)
+		attr = PyInt_FromLong((long)self->material->flarec);
+	else if (strcmp(name, "nStars") == 0)
+		attr = PyInt_FromLong((long)self->material->starc);
+	else if (strcmp(name, "nLines") == 0)
+		attr = PyInt_FromLong((long)self->material->linec);
+	else if (strcmp(name, "nRings") == 0)
+		attr = PyInt_FromLong((long)self->material->ringc);
+
+	else if (strcmp(name, "__members__") == 0) {
+		attr = /* 27 items */
+			Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
+				"name", "mode", "rgbCol", "specCol", "mirCol",
+				"R", "G", "B", "alpha", "amb", "emit", "ref", "spec",
+				"specTransp", "add", "zOffset", "haloSize", "haloSeed",
+				"flareSize", "flareBoost", "flareSeed", "subSize", "hard",
+				"nFlares", "nStars", "nLines", "nRings");
+	}
+
+	if (!attr)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+											"couldn't create PyObject"));
+
+	if (attr != Py_None) return attr; /* member attribute found, return it */
+
+	/* not an attribute, search the methods table */
+	return Py_FindMethod(BPy_Material_methods, (PyObject *)self, name);
 }
 
 /****************************************************************************/
-/* Function:    Material_setAttr                                            */
-/* Description: This is a callback function for the BPy_Material type.      */
-/*              It is the function that sets Material attributes (member    */
-/*              variables).                                                 */
+/* Function:		Material_setAttr																						*/
+/* Description: This is a callback function for the BPy_Material type.			*/
+/*							It is the function that sets Material attributes (member		*/
+/*							variables).																									*/
 /****************************************************************************/
 static int Material_setAttr (BPy_Material *self, char *name, PyObject *value)
 {
-  PyObject *valtuple; 
-  PyObject *error = NULL;
+	PyObject *valtuple; 
+	PyObject *error = NULL;
 
-/* We're playing a trick on the Python API users here.  Even if they use
+/* We're playing a trick on the Python API users here.	Even if they use
  * Material.member = val instead of Material.setMember(val), we end up using the
  * function anyway, since it already has error checking, clamps to the right
  * interval and updates the Blender Material structure when necessary. */
 
 /* First we put "value" in a tuple, because we want to pass it to functions
  * that only accept PyTuples. */
-  valtuple = Py_BuildValue("(O)", value);
+	valtuple = Py_BuildValue("(O)", value);
 
-  if (!valtuple) /* everything OK with our PyObject? */
-    return EXPP_ReturnIntError(PyExc_MemoryError,
-                         "MaterialSetAttr: couldn't create PyTuple");
+	if (!valtuple) /* everything OK with our PyObject? */
+		return EXPP_ReturnIntError(PyExc_MemoryError,
+												 "MaterialSetAttr: couldn't create PyTuple");
 
 /* Now we just compare "name" with all possible BPy_Material member variables */
-  if (strcmp (name, "name") == 0)
-    error = Material_setName (self, valtuple);
-  else if (strcmp (name, "mode") == 0)
-    error = Material_setIntMode (self, valtuple); /* special case */
-  else if (strcmp (name, "rgbCol") == 0)
-    error = Material_setRGBCol (self, valtuple);
-/*  else if (strcmp (name, "ambCol") == 0)
-    error = Material_setAmbCol (self, valtuple);*/
-  else if (strcmp (name, "specCol") == 0)
-    error = Material_setSpecCol (self, valtuple);
-  else if (strcmp (name, "mirCol") == 0)
-    error = Material_setMirCol (self, valtuple);
-  else if (strcmp (name, "R") == 0)
-    error = Material_setColorComponent (self, "R", valtuple);
-  else if (strcmp (name, "G") == 0)
-    error = Material_setColorComponent (self, "G", valtuple);
-  else if (strcmp (name, "B") == 0)
-    error = Material_setColorComponent (self, "B", valtuple);
-  else if (strcmp (name, "specR") == 0)
-    error = Material_setColorComponent (self, "specR", valtuple);
-  else if (strcmp (name, "specG") == 0)
-    error = Material_setColorComponent (self, "specG", valtuple);
-  else if (strcmp (name, "specB") == 0)
-    error = Material_setColorComponent (self, "specB", valtuple);
-  else if (strcmp (name, "amb") == 0)
-    error = Material_setAmb (self, valtuple);
-  else if (strcmp (name, "emit") == 0)
-    error = Material_setEmit (self, valtuple);
-  else if (strcmp (name, "alpha") == 0)
-    error = Material_setAlpha (self, valtuple);
-  else if (strcmp (name, "ref") == 0)
-    error = Material_setRef (self, valtuple);
-  else if (strcmp (name, "spec") == 0)
-    error = Material_setSpec (self, valtuple);
-  else if (strcmp (name, "specTransp") == 0)
-    error = Material_setSpecTransp (self, valtuple);
-  else if (strcmp (name, "add") == 0)
-    error = Material_setAdd (self, valtuple);
-  else if (strcmp (name, "zOffset") == 0)
-    error = Material_setZOffset (self, valtuple);
-  else if (strcmp (name, "haloSize") == 0)
-    error = Material_setHaloSize (self, valtuple);
-  else if (strcmp (name, "haloSeed") == 0)
-    error = Material_setHaloSeed (self, valtuple);
-  else if (strcmp (name, "flareSize") == 0)
-    error = Material_setFlareSize (self, valtuple);
-  else if (strcmp (name, "flareBoost") == 0)
-    error = Material_setFlareBoost (self, valtuple);
-  else if (strcmp (name, "flareSeed") == 0)
-    error = Material_setFlareSeed (self, valtuple);
-  else if (strcmp (name, "subSize") == 0)
-    error = Material_setSubSize (self, valtuple);
-  else if (strcmp (name, "hard") == 0)
-    error = Material_setHardness (self, valtuple);
-  else if (strcmp (name, "nFlares") == 0)
-    error = Material_setNFlares (self, valtuple);
-  else if (strcmp (name, "nStars") == 0)
-    error = Material_setNStars (self, valtuple);
-  else if (strcmp (name, "nLines") == 0)
-    error = Material_setNLines (self, valtuple);
-  else if (strcmp (name, "nRings") == 0)
-    error = Material_setNRings (self, valtuple);
-
-  else { /* Error */
-    Py_DECREF(valtuple);
-    return (EXPP_ReturnIntError (PyExc_AttributeError, name));
-  }
+	if (strcmp (name, "name") == 0)
+		error = Material_setName (self, valtuple);
+	else if (strcmp (name, "mode") == 0)
+		error = Material_setIntMode (self, valtuple); /* special case */
+	else if (strcmp (name, "rgbCol") == 0)
+		error = Material_setRGBCol (self, valtuple);
+/*	else if (strcmp (name, "ambCol") == 0)
+		error = Material_setAmbCol (self, valtuple);*/
+	else if (strcmp (name, "specCol") == 0)
+		error = Material_setSpecCol (self, valtuple);
+	else if (strcmp (name, "mirCol") == 0)
+		error = Material_setMirCol (self, valtuple);
+	else if (strcmp (name, "R") == 0)
+		error = Material_setColorComponent (self, "R", valtuple);
+	else if (strcmp (name, "G") == 0)
+		error = Material_setColorComponent (self, "G", valtuple);
+	else if (strcmp (name, "B") == 0)
+		error = Material_setColorComponent (self, "B", valtuple);
+	else if (strcmp (name, "specR") == 0)
+		error = Material_setColorComponent (self, "specR", valtuple);
+	else if (strcmp (name, "specG") == 0)
+		error = Material_setColorComponent (self, "specG", valtuple);
+	else if (strcmp (name, "specB") == 0)
+		error = Material_setColorComponent (self, "specB", valtuple);
+	else if (strcmp (name, "amb") == 0)
+		error = Material_setAmb (self, valtuple);
+	else if (strcmp (name, "emit") == 0)
+		error = Material_setEmit (self, valtuple);
+	else if (strcmp (name, "alpha") == 0)
+		error = Material_setAlpha (self, valtuple);
+	else if (strcmp (name, "ref") == 0)
+		error = Material_setRef (self, valtuple);
+	else if (strcmp (name, "spec") == 0)
+		error = Material_setSpec (self, valtuple);
+	else if (strcmp (name, "specTransp") == 0)
+		error = Material_setSpecTransp (self, valtuple);
+	else if (strcmp (name, "add") == 0)
+		error = Material_setAdd (self, valtuple);
+	else if (strcmp (name, "zOffset") == 0)
+		error = Material_setZOffset (self, valtuple);
+	else if (strcmp (name, "haloSize") == 0)
+		error = Material_setHaloSize (self, valtuple);
+	else if (strcmp (name, "haloSeed") == 0)
+		error = Material_setHaloSeed (self, valtuple);
+	else if (strcmp (name, "flareSize") == 0)
+		error = Material_setFlareSize (self, valtuple);
+	else if (strcmp (name, "flareBoost") == 0)
+		error = Material_setFlareBoost (self, valtuple);
+	else if (strcmp (name, "flareSeed") == 0)
+		error = Material_setFlareSeed (self, valtuple);
+	else if (strcmp (name, "subSize") == 0)
+		error = Material_setSubSize (self, valtuple);
+	else if (strcmp (name, "hard") == 0)
+		error = Material_setHardness (self, valtuple);
+	else if (strcmp (name, "nFlares") == 0)
+		error = Material_setNFlares (self, valtuple);
+	else if (strcmp (name, "nStars") == 0)
+		error = Material_setNStars (self, valtuple);
+	else if (strcmp (name, "nLines") == 0)
+		error = Material_setNLines (self, valtuple);
+	else if (strcmp (name, "nRings") == 0)
+		error = Material_setNRings (self, valtuple);
+
+	else { /* Error */
+		Py_DECREF(valtuple);
+		return (EXPP_ReturnIntError (PyExc_AttributeError, name));
+	}
 
 /* valtuple won't be returned to the caller, so we need to DECREF it */
-  Py_DECREF(valtuple);
+	Py_DECREF(valtuple);
 
-  if (error != Py_None) return -1;
+	if (error != Py_None) return -1;
 
 /* Py_None was incref'ed by the called Material_set* function. We probably
  * don't need to decref Py_None (!), but since Python/C API manual tells us
  * to treat it like any other PyObject regarding ref counting ... */
-  Py_DECREF(Py_None);
-  return 0; /* normal exit */
+	Py_DECREF(Py_None);
+	return 0; /* normal exit */
 }
 
 /*****************************************************************************/
-/* Function:    Material_repr                                                */
-/* Description: This is a callback function for the BPy_Material type. It    */
-/*              builds a meaninful string to represent material objects.     */
+/* Function:		Material_repr																								 */
+/* Description: This is a callback function for the BPy_Material type. It		 */
+/*							builds a meaninful string to represent material objects.		 */
 /*****************************************************************************/
 static PyObject *Material_repr (BPy_Material *self)
 {
-  return PyString_FromFormat ("[Material \"%s\"]", self->material->id.name+2);
+	return PyString_FromFormat ("[Material \"%s\"]", self->material->id.name+2);
 }
 
 
 /*****************************************************************************/
-/* These functions are used in NMesh.c and Object.c                          */
+/* These functions are used in NMesh.c and Object.c													 */
 /*****************************************************************************/
 PyObject *EXPP_PyList_fromMaterialList (Material **matlist, int len)
 {
-  PyObject *list;
-  int i;
+	PyObject *list;
+	int i;
 
-  list = PyList_New(0);
-  if (!matlist) return list;
+	list = PyList_New(0);
+	if (!matlist) return list;
 
-  for (i = 0; i < len; i++) {
-    Material *mat = matlist[i];
-    PyObject *ob;
+	for (i = 0; i < len; i++) {
+		Material *mat = matlist[i];
+		PyObject *ob;
 
-    if (mat) {
-      ob = Material_CreatePyObject (mat);
-      PyList_Append (list, ob);
-      Py_DECREF (ob); /* because Append increfs */
-    }
-  }
+		if (mat) {
+			ob = Material_CreatePyObject (mat);
+			PyList_Append (list, ob);
+			Py_DECREF (ob); /* because Append increfs */
+		}
+	}
 
-  return list;
+	return list;
 }
 
 Material **EXPP_newMaterialList_fromPyList (PyObject *list)
 {
-  int i, len;
-  BPy_Material *pymat = 0;
-  Material *mat;
-  Material **matlist;
+	int i, len;
+	BPy_Material *pymat = 0;
+	Material *mat;
+	Material **matlist;
 
-  len = PySequence_Length (list);
-  if (len > 16) len = 16;
+	len = PySequence_Length (list);
+	if (len > 16) len = 16;
 
-  matlist = EXPP_newMaterialList (len);
+	matlist = EXPP_newMaterialList (len);
 
-  for (i= 0; i < len; i++) {
+	for (i= 0; i < len; i++) {
 
-    pymat = (BPy_Material *)PySequence_GetItem (list, i);
+		pymat = (BPy_Material *)PySequence_GetItem (list, i);
 
-    if (Material_CheckPyObject ((PyObject *)pymat)) {
-      mat = pymat->material;
-      matlist[i] = mat;
-    }
+		if (Material_CheckPyObject ((PyObject *)pymat)) {
+			mat = pymat->material;
+			matlist[i] = mat;
+		}
 
-    else { /* error; illegal type in material list */
-      Py_DECREF(pymat);
-      MEM_freeN(matlist);
-      return NULL;
-    }
+		else { /* error; illegal type in material list */
+			Py_DECREF(pymat);
+			MEM_freeN(matlist);
+			return NULL;
+		}
 
-    Py_DECREF(pymat);
-  }
+		Py_DECREF(pymat);
+	}
 
-  return matlist;
+	return matlist;
 }
 
 Material **EXPP_newMaterialList(int len)
 {
-  Material **matlist =
-    (Material **)MEM_mallocN(len * sizeof(Material *), "MaterialList");
+	Material **matlist =
+		(Material **)MEM_mallocN(len * sizeof(Material *), "MaterialList");
 
-  return matlist;
+	return matlist;
 }
 
 int EXPP_releaseMaterialList (Material **matlist, int len)
 {
-    int           i;
-    Material    * mat;
+		int						i;
+		Material		* mat;
 
-    if ((len < 0) || (len > MAXMAT)) {
-        printf ("illegal matindex!\n");
-        return 0;
-    }
+		if ((len < 0) || (len > MAXMAT)) {
+				printf ("illegal matindex!\n");
+				return 0;
+		}
 
-    for (i=0 ; i<len ; i++) {
-        mat = matlist[i];
-        if (mat != NULL) {
-            if (((ID *)mat)->us > 0)
-                ((ID *)mat)->us--;
-            else
-                printf ("FATAL: material usage=0: %s", ((ID *)mat)->name);
-        }
-    }
-    MEM_freeN (matlist);
+		for (i=0 ; i<len ; i++) {
+				mat = matlist[i];
+				if (mat != NULL) {
+						if (((ID *)mat)->us > 0)
+								((ID *)mat)->us--;
+						else
+								printf ("FATAL: material usage=0: %s", ((ID *)mat)->name);
+				}
+		}
+		MEM_freeN (matlist);
 
-    return 1;
+		return 1;
 }
 
 /** expands pointer array of length 'oldsize' to length 'newsize'.
-  * A pointer to the (void *) array must be passed as first argument 
-  * The array pointer content can be NULL, in this case a new array of length
-  * 'newsize' is created.
-  */
+	* A pointer to the (void *) array must be passed as first argument 
+	* The array pointer content can be NULL, in this case a new array of length
+	* 'newsize' is created.
+	*/
 
 static int expandPtrArray(void **p, int oldsize, int newsize)
 {
@@ -1598,28 +1602,28 @@ static int expandPtrArray(void **p, int oldsize, int newsize)
 
 int EXPP_synchronizeMaterialLists (Object *object, void *data)
 {
-    Material  *** p_dataMaterials = give_matarar (object);
-    short       * nmaterials = give_totcolp (object);
-
-    if (object->totcol > *nmaterials) {
-        /* More object mats than data mats */
-        *nmaterials = object->totcol;
-        return expandPtrArray ((void *) p_dataMaterials,
-                               *nmaterials,
-                               object->totcol);
-    }
-    else {
-        if (object->totcol < *nmaterials) {
-            /* More data mats than object mats */
-            object->totcol = *nmaterials;
-            return expandPtrArray ((void *) &object->mat,
-                                   object->totcol,
-                                   *nmaterials);
-        }
-    }
-
-    /* No synchronization is needed; they're of equal length */
-    return 1;
+		Material	*** p_dataMaterials = give_matarar (object);
+		short				* nmaterials = give_totcolp (object);
+
+		if (object->totcol > *nmaterials) {
+				/* More object mats than data mats */
+				*nmaterials = object->totcol;
+				return expandPtrArray ((void *) p_dataMaterials,
+															 *nmaterials,
+															 object->totcol);
+		}
+		else {
+				if (object->totcol < *nmaterials) {
+						/* More data mats than object mats */
+						object->totcol = *nmaterials;
+						return expandPtrArray ((void *) &object->mat,
+																	 object->totcol,
+																	 *nmaterials);
+				}
+		}
+
+		/* No synchronization is needed; they're of equal length */
+		return 1;
 }
 
 void EXPP_incr_mats_us (Material **matlist, int len)
diff --git a/source/blender/python/api2_2x/NMesh.c b/source/blender/python/api2_2x/NMesh.c
index bae9faa42ea..d76d45de2e7 100644
--- a/source/blender/python/api2_2x/NMesh.c
+++ b/source/blender/python/api2_2x/NMesh.c
@@ -31,7 +31,13 @@
 
 #include "NMesh.h"
 
-#define NMESH_FRAME_MAX 18000
+#define NMESH_FRAME_MAX				18000
+#define NMESH_SMOOTHRESH			30
+#define NMESH_SMOOTHRESH_MIN	1
+#define NMESH_SMOOTHRESH_MAX	80
+#define NMESH_SUBDIV					1
+#define NMESH_SUBDIV_MIN			1
+#define NMESH_SUBDIV_MAX			6
 
 void mesh_update(Mesh *mesh)
 {
@@ -944,6 +950,61 @@ PyObject *NMesh_link(PyObject *self, PyObject *args)
 	return EXPP_incr_ret(Py_None);
 }
 
+static PyObject *NMesh_getMaxSmoothAngle (BPy_NMesh *self)
+{
+	PyObject *attr = PyInt_FromLong (self->smoothresh);
+
+	if (attr) return attr;
+
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						 "couldn't get NMesh.maxSmoothAngle attribute");
+}
+
+static PyObject *NMesh_setMaxSmoothAngle (PyObject *self, PyObject *args)
+{
+	short value = 0;
+	BPy_NMesh *nmesh = (BPy_NMesh *)self;
+
+	if (!PyArg_ParseTuple(args, "h", &value))
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
+							 "expected an int in [1, 80] as argument");
+
+	nmesh->smoothresh =
+		(short)EXPP_ClampInt (value, NMESH_SMOOTHRESH_MIN, NMESH_SMOOTHRESH_MAX);
+
+	Py_INCREF (Py_None);
+	return Py_None;
+}
+
+static PyObject *NMesh_getSubDivLevels (BPy_NMesh *self)
+{
+	PyObject *attr = Py_BuildValue ("[h,h]", self->subdiv[0], self->subdiv[1]);
+
+	if (attr) return attr;
+
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						 "couldn't get NMesh.subDivLevels attribute");
+}
+
+static PyObject *NMesh_setSubDivLevels (PyObject *self, PyObject *args)
+{
+	short display = 0, render = 0;
+	BPy_NMesh *nmesh = (BPy_NMesh *)self;
+
+	if (!PyArg_ParseTuple(args, "(hh)", &display, &render))
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
+							 "expected a sequence [int, int] as argument");
+
+	nmesh->subdiv[0] =
+		(short)EXPP_ClampInt (display, NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+
+	nmesh->subdiv[1] =
+		(short)EXPP_ClampInt (render, NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+
+	Py_INCREF (Py_None);
+	return Py_None;
+}
+
 static PyObject *NMesh_getMode (BPy_NMesh *self)
 {
 	PyObject *attr = PyInt_FromLong (self->mode);
@@ -1005,8 +1066,14 @@ static struct PyMethodDef NMesh_methods[] =
 	MethodDef(insertKey),
 	MethodDef(removeAllKeys),
 	MethodDef(update),
-	{"getMode", (PyCFunction)NMesh_getMode, METH_NOARGS, NMesh_getMode_doc},
 	MethodDef(setMode),
+	MethodDef(setMaxSmoothAngle),
+	MethodDef(setSubDivLevels),
+	{"getMode", (PyCFunction)NMesh_getMode, METH_NOARGS, NMesh_getMode_doc},
+	{"getMaxSmoothAngle", (PyCFunction)NMesh_getMaxSmoothAngle, METH_NOARGS,
+		NMesh_getMaxSmoothAngle_doc},
+	{"getSubDivLevels", (PyCFunction)NMesh_getSubDivLevels, METH_NOARGS,
+		NMesh_getSubDivLevels_doc},
 	{NULL, NULL}
 };
 
@@ -1029,6 +1096,12 @@ static PyObject *NMesh_getattr(PyObject *self, char *name)
 	else if (strcmp(name, "verts") == 0)
 		return EXPP_incr_ret(me->verts);
 
+	else if (strcmp(name, "maxSmoothAngle") == 0)
+		return PyInt_FromLong(me->smoothresh);
+
+	else if (strcmp(name, "subDivLevels") == 0)
+		return Py_BuildValue("[h,h]", me->subdiv[0], me->subdiv[1]);
+
 	else if (strcmp(name, "users") == 0) {
 		if (me->mesh) {
 			return PyInt_FromLong(me->mesh->id.us); 
@@ -1042,8 +1115,9 @@ static PyObject *NMesh_getattr(PyObject *self, char *name)
 		return EXPP_incr_ret(me->faces);
 
 	else if (strcmp(name, "__members__") == 0)
-		return Py_BuildValue("[s,s,s,s,s]",
-										"name", "materials", "verts", "users", "faces");
+		return Py_BuildValue("[s,s,s,s,s,s,s]",
+			"name", "materials", "verts", "users", "faces", "maxSmoothAngle",
+			"subdivLevels");
 
 	return Py_FindMethod(NMesh_methods, (PyObject*)self, name);
 }
@@ -1099,6 +1173,47 @@ static int NMesh_setattr(PyObject *self, char *name, PyObject *v)
 			return EXPP_ReturnIntError (PyExc_TypeError, "expected a sequence");
 	}
 
+	else if (!strcmp(name, "maxSmoothAngle")) {
+		short smoothresh = 0;
+
+		if (!PyInt_Check(v))
+			return EXPP_ReturnIntError (PyExc_TypeError,
+							"expected int argument");
+
+		smoothresh = (short)PyInt_AsLong(v);
+
+		me->smoothresh =
+			EXPP_ClampInt(smoothresh, NMESH_SMOOTHRESH_MIN, NMESH_SMOOTHRESH_MAX);
+	}
+
+	else if (!strcmp(name, "subDivLevels")) {
+		int subdiv[2] = {0,0};
+		int i;
+		PyObject *tmp;
+
+		if (!PySequence_Check(v) || (PySequence_Length(v) != 2))
+			return EXPP_ReturnIntError (PyExc_TypeError,
+							"expected a list [int, int] as argument");
+
+		for (i = 0; i < 2; i++) {
+			tmp = PySequence_GetItem(v, i);
+			if (tmp) {
+				if (!PyInt_Check(tmp)) {
+					Py_DECREF (tmp);
+					return EXPP_ReturnIntError (PyExc_TypeError,
+						"expected a list [int, int] as argument");
+				}
+
+				subdiv[i] = PyInt_AsLong (tmp);
+				me->subdiv[i] =
+					(short)EXPP_ClampInt(subdiv[i], NMESH_SUBDIV_MIN, NMESH_SUBDIV_MAX);
+				Py_DECREF (tmp);
+			}
+			else return EXPP_ReturnIntError (PyExc_RuntimeError,
+				"couldn't retrieve subdiv values from list");
+		}
+	}
+
 	else
 			return EXPP_ReturnIntError (PyExc_AttributeError, name);
 
@@ -1241,6 +1356,10 @@ static PyObject *new_NMesh_internal(Mesh *oldmesh,
 {
 	BPy_NMesh *me = PyObject_NEW (BPy_NMesh, &NMesh_Type);
 	me->flags = 0;
+	me->subdiv[0] = NMESH_SUBDIV;
+	me->subdiv[1] = NMESH_SUBDIV;
+	me->smoothresh = NMESH_SMOOTHRESH;
+
 	me->object = NULL; /* not linked to any object yet */
 
 	if (!oldmesh) {
@@ -1276,7 +1395,10 @@ static PyObject *new_NMesh_internal(Mesh *oldmesh,
 		else {
 			me->name = PyString_FromString(oldmesh->id.name+2);
 			me->mesh = oldmesh;
-			me->mode = oldmesh->flag; /* yes, we save the mesh flags in nmesh->mode */
+			me->mode = oldmesh->flag; /* yes, we save the mesh flags in nmesh->mode*/
+			me->subdiv[0] = oldmesh->subdiv;
+			me->subdiv[1] = oldmesh->subdivr;
+			me->smoothresh = oldmesh->smoothresh;
 
 			mfaceints = NULL;
 			msticky = oldmesh->msticky;
@@ -1703,8 +1825,12 @@ static int convert_NMeshToMesh (Mesh *mesh, BPy_NMesh *nmesh)
 	mesh->tface = NULL;
 	mesh->mat = NULL;
 
-	/* Minor note: we used 'mode' because 'flag' was already used internally by nmesh */
+	/* Minor note: we used 'mode' because 'flag' was already used internally
+	 * by nmesh */
 	mesh->flag = nmesh->mode;
+	mesh->smoothresh = nmesh->smoothresh;
+	mesh->subdiv = nmesh->subdiv[0];
+	mesh->subdivr = nmesh->subdiv[1];
 
 	/*@ material assignment moved to PutRaw */
 	mesh->totvert = PySequence_Length(nmesh->verts);
diff --git a/source/blender/python/api2_2x/NMesh.h b/source/blender/python/api2_2x/NMesh.h
index 492760b02a9..4d0d0253fa1 100644
--- a/source/blender/python/api2_2x/NMesh.h
+++ b/source/blender/python/api2_2x/NMesh.h
@@ -208,6 +208,20 @@ static char NMesh_setMode_doc[] =
 "(none to 4 strings) - set the mode flags of this nmesh.\n\
 () - unset all flags.";
 
+static char NMesh_getMaxSmoothAngle_doc[] =
+"() - get the max smooth angle for mesh auto smoothing.";
+
+static char NMesh_setMaxSmoothAngle_doc[] =
+"(int) - set the max smooth angle for mesh auto smoothing in the range\n\
+[1,80] in degrees.";
+
+static char NMesh_getSubDivLevels_doc[] =
+"() - get the subdivision levels for display and rendering: [display, render]";
+
+static char NMesh_setSubDivLevels_doc[] =
+"([int, int]) - set the subdivision levels for [display, render] -- they are\n\
+clamped to the range [1,6].";
+
 static char M_NMesh_New_doc[] =
 "() - returns a new, empty NMesh mesh object\n";
 
@@ -271,6 +285,8 @@ typedef struct {
 	PyObject *verts;
 	PyObject *faces;
   int sel_face; /*@ XXX remove */
+	short smoothresh; /* max AutoSmooth angle */
+	short subdiv[2]; /* SubDiv Levels: display and rendering */
 	short mode; /* see the EXPP_NMESH_* defines in the beginning of this file */
 	char flags;
 
diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c
index dd93e4114b0..170cfa61f4b 100644
--- a/source/blender/python/api2_2x/Object.c
+++ b/source/blender/python/api2_2x/Object.c
@@ -1236,6 +1236,10 @@ static PyObject *Object_shareFrom (BPy_Object *self, PyObject *args)
 		switch (self->object->type)
 		{
 				case OB_MESH:
+				case OB_LAMP:
+				case OB_CAMERA: /* we can probably add the other types, too */
+				case OB_ARMATURE:
+				case OB_CURVE:
 						oldid = (ID*) self->object->data;
 						id = (ID*) object->object->data;
 						self->object->data = object->object->data;
diff --git a/source/blender/python/api2_2x/doc/NMesh.py b/source/blender/python/api2_2x/doc/NMesh.py
index 0fc0e434a7d..900821303f9 100644
--- a/source/blender/python/api2_2x/doc/NMesh.py
+++ b/source/blender/python/api2_2x/doc/NMesh.py
@@ -232,7 +232,9 @@ class NMesh:
   @cvar verts: The list of NMesh vertices (NMVerts).
   @cvar users: The number of Objects using (linked to) this mesh.
   @cvar faces: The list of NMesh faces (NMFaces).
-  @cvar mode:  The mode flags for this mesh.  See L{setMode}
+  @cvar mode:  The mode flags for this mesh.  See L{setMode}.
+  @cvar subDivLevels: The [display, rendering] subdivision levels in [1, 6].
+  @cvar maxSmoothAngle: The max angle for auto smoothing.  See L{setMode}.
   """
 
   def addMaterial(material):
@@ -483,4 +485,31 @@ class NMesh:
     @type vertList: list of ints
     @param vertList: if given, only those vertex points that are both in the
         list and group passed in are returned.
-   """
+    """
+
+  def getMaxSmoothAngle():
+    """
+    Get the max angle for auto smoothing.
+    @return: The value in degrees.
+    """
+
+  def setMaxSmoothAngle(angle):
+    """
+    Set the max angle for auto smoothing.
+    @type angle: int
+    @param angle: The new value in degrees -- it's clamped to [1, 80].
+    """
+
+  def getSubDivLevels():
+    """
+    Get the mesh subdivision levels for realtime display and rendering.
+    @return: list of ints: [display, render].
+    """
+
+  def setSubDivLevels(subdiv):
+    """
+    Set the mesh subdivision levels for realtime display and rendering.
+    @type subdiv: list of 2 ints
+    @param subdiv: new subdiv levels: [display, render].  Both are clamped to
+        lie in the range [1, 6].
+    """