*armature api for python

- don't get too excited
- allows you to get armatures from a scene
- makeEditable()/saveChanges() puts the armature into out of editmode (pythonically)
- Armature.bones is a dictionary that contains all the bones in the armature and can be iterated
- getters are available for:
name,
roll (dictionary) keys are BONESPACE, ARMATURESPACE
head (dictionary) keys are BONESPACE, ARMATURESPACE
tail (dictionary) keys are BONESPACE, ARMATURESPACE
matrix (dictionary) keys are BONESPACE, ARMATURESPACE
weight
deform_dist
subdivisions
options (list of constants)
parent
children

Setter work only in editmode. Some are not fully implemented.
Type class is embedded in the module. This means the construct is called as follows:
Blender.Armature.ArmatureType()

import Blender.Armature as Armature
arm = Armature.Get('myarm')
for name, bone in arm.bones.items():
...print name, bone, bone.matrix['ARMATURESPACE']

more documentation is forth coming. This is an alpha for this api.

1 files changed, 738 insertions, 1551 deletions

diff --git a/source/blender/python/api2_2x/Bone.c b/source/blender/python/api2_2x/Bone.c
index 9fd751248aa..2fe7faf3b90 100644
--- a/source/blender/python/api2_2x/Bone.c
+++ b/source/blender/python/api2_2x/Bone.c
@@ -23,1630 +23,817 @@
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
- * This is a new part of Blender.
- *
- * Contributor(s): Jordi Rovira i Bonet, Joseph Gilbert
+ * Contributor(s): Joseph Gilbert
  *
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
-struct ScrArea; /*keep me up here */
-
-#include "Bone.h" /*This must come first */
-
-#include "MEM_guardedalloc.h"
 
-#include "DNA_object_types.h"
-#include "DNA_ipo_types.h"
+#include "Bone.h"
 
 #include "BLI_blenlib.h"
 #include "BLI_arithb.h"
-
-#include "BKE_armature.h"
-#include "BKE_action.h"
-#include "BKE_global.h"
-#include "BKE_main.h"
 #include "BKE_utildefines.h"
-
-#include "BIF_editaction.h"
-#include "BSE_editipo.h"
-
-#include "NLA.h"
-
 #include "gen_utils.h"
-
-//--------------------Python API function prototypes for the Bone module----
-static PyObject *M_Bone_New( PyObject * self, PyObject * args );
-
-//------------------------Python API Doc strings for the Bone module--------
-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";
-char M_Bone_New_doc[] = "(name) - return a new Bone of name 'name'.";
-
-//----- Python method structure definition for Blender.Armature.Bone module---
-struct PyMethodDef M_Bone_methods[] = {
-	{"New", ( PyCFunction ) M_Bone_New, METH_VARARGS, M_Bone_New_doc},
-	{NULL, NULL, 0, NULL}
-};
-//--------------- Python BPy_Bone methods declarations:-------------------
-static PyObject *Bone_getName( BPy_Bone * self );
-static PyObject *Bone_getRoll( BPy_Bone * self );
-static PyObject *Bone_getHead( BPy_Bone * self );
-static PyObject *Bone_getTail( BPy_Bone * self );
-static PyObject *Bone_getLoc( BPy_Bone * self );
-static PyObject *Bone_getSize( BPy_Bone * self );
-static PyObject *Bone_getQuat( BPy_Bone * self );
-static PyObject *Bone_getParent( BPy_Bone * self );
-static PyObject *Bone_hasParent( BPy_Bone * self );
-static PyObject *Bone_getWeight( BPy_Bone * self );
-static PyObject *Bone_getBoneclass( BPy_Bone * self );
-static PyObject *Bone_hasIK( BPy_Bone * self );
-static PyObject *Bone_getChildren( BPy_Bone * self );
-static PyObject *Bone_clearParent( BPy_Bone * self );
-static PyObject *Bone_clearChildren( BPy_Bone * self );
-static PyObject *Bone_hide( BPy_Bone * self );
-static PyObject *Bone_unhide( BPy_Bone * self );
-static PyObject *Bone_setName( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setRoll( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setHead( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setTail( BPy_Bone * self, PyObject * args );
-		// note; this can only be done as POSE operation
-static PyObject *Bone_setLoc( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setSize( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setQuat( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setPose( BPy_Bone * self, PyObject * args );
-
-static PyObject *Bone_setParent( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setWeight( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_setBoneclass( BPy_Bone * self, PyObject * args );
-static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args );
-
-//--------------- Python BPy_Bone methods table:--------------------------
-static PyMethodDef BPy_Bone_methods[] = {
-	{"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"},
-	{"hide", ( PyCFunction ) Bone_hide, METH_NOARGS,
-	 "() - hides the bone"},
-	{"unhide", ( PyCFunction ) Bone_unhide, METH_NOARGS,
-	 "() - unhides the bone"},
-	{"getWeight", ( PyCFunction ) Bone_getWeight, METH_NOARGS,
-	 "() - return Bone weight"},
-	{"getBoneclass", ( PyCFunction ) Bone_getBoneclass, METH_NOARGS,
-	 "() - return Bone boneclass"},
-	{"hasIK", ( PyCFunction ) Bone_hasIK, METH_VARARGS,
-	 "() - get the Bone IKToParent flag."},
-	{"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"},
-	{"clearParent", ( PyCFunction ) Bone_clearParent, METH_NOARGS,
-	 "() - clears the bone's parent in the armature and makes it root"},
-	{"clearChildren", ( PyCFunction ) Bone_clearChildren, METH_NOARGS,
-	 "() - remove the children associated with this bone"},
-	{"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_VARARGS,
-	 "() - set the Bone parent of this one."},
-	{"setWeight", ( PyCFunction ) Bone_setWeight, METH_VARARGS,
-	 "() - set the Bone weight."},
-	{"setPose", ( PyCFunction ) Bone_setPose, METH_VARARGS,
-	 "() - set a pose for this bone at a frame."},
-	{"setBoneclass", ( PyCFunction ) Bone_setBoneclass, METH_VARARGS,
-	 "() - set the Bone boneclass."},
-	{"getRestMatrix", ( PyCFunction ) Bone_getRestMatrix, METH_VARARGS,
-	 "() - return the rest matrix for this bone"},
-	{NULL, NULL, 0, NULL}
-};
-
-//--------------- Python TypeBone callback function prototypes----------
-static void Bone_dealloc( BPy_Bone * bone );
-static PyObject *Bone_getAttr( BPy_Bone * bone, char *name );
-static int Bone_setAttr( BPy_Bone * bone, char *name, PyObject * v );
-static int Bone_compare( BPy_Bone * a1, BPy_Bone * a2 );
-static PyObject *Bone_repr( BPy_Bone * bone );
-
-//--------------- 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 */
-	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-};
-
-//--------------- Bone Module Init-----------------------------
-PyObject *Bone_Init( void )
-{
-	PyObject *submodule;
-
-	Bone_Type.ob_type = &PyType_Type;
-
-	submodule = Py_InitModule3( "Blender.Armature.Bone",
-				    M_Bone_methods, M_Bone_doc );
-
-	PyModule_AddIntConstant( submodule, "ROT", POSE_ROT );
-	PyModule_AddIntConstant( submodule, "LOC", POSE_LOC );
-	PyModule_AddIntConstant( submodule, "SIZE", POSE_SIZE );
-	PyModule_AddIntConstant( submodule, "SKINNABLE", 0 );
-	PyModule_AddIntConstant( submodule, "UNSKINNABLE", 1 );
-	PyModule_AddIntConstant( submodule, "HEAD", 2 );
-	PyModule_AddIntConstant( submodule, "NECK", 3 );
-	PyModule_AddIntConstant( submodule, "BACK", 4 );
-	PyModule_AddIntConstant( submodule, "SHOULDER", 5 );
-	PyModule_AddIntConstant( submodule, "ARM", 6 );
-	PyModule_AddIntConstant( submodule, "HAND", 7 );
-	PyModule_AddIntConstant( submodule, "FINGER", 8 );
-	PyModule_AddIntConstant( submodule, "THUMB", 9 );
-	PyModule_AddIntConstant( submodule, "PELVIS", 10 );
-	PyModule_AddIntConstant( submodule, "LEG", 11 );
-	PyModule_AddIntConstant( submodule, "FOOT", 12 );
-	PyModule_AddIntConstant( submodule, "TOE", 13 );
-	PyModule_AddIntConstant( submodule, "TENTACLE", 14 );
-
-	return ( submodule );
-}
-
-//--------------- Bone module internal callbacks-----------------
-
-//--------------- updatePyBone------------------------------------
-static int updatePyBone( BPy_Bone * self )
-{
-	char *parent_str = "";
-
-	if( !self->bone ) {
-		//nothing to update - not linked
-		return 0;
-	} else {
-		BLI_strncpy( self->name, self->bone->name,
-			     strlen( self->bone->name ) + 1 );
-		self->roll = self->bone->roll;
-		self->flag = self->bone->flag;
-		self->boneclass = self->bone->boneclass;
-		self->dist = self->bone->dist;
-		self->weight = self->bone->weight;
-
-		if( self->bone->parent ) {
-			self->parent =
-				BLI_strncpy( self->parent,
-					     self->bone->parent->name,
-					     strlen( self->bone->parent->
-						     name ) + 1 );
-		} else {
-			self->parent =
-				BLI_strncpy( self->parent, parent_str,
-					     strlen( parent_str ) + 1 );
-		}
-#if 0
-		for( x = 0; x < 3; x++ ) {
-			self->head->vec[x] = self->bone->head[x];
-			self->tail->vec[x] = self->bone->tail[x];
-			self->loc->vec[x] = self->bone->loc[x];
-			self->dloc->vec[x] = self->bone->dloc[x];
-			self->size->vec[x] = self->bone->size[x];
-			self->dsize->vec[x] = self->bone->dsize[x];
-		}
-		for( x = 0; x < 4; x++ ) {
-			self->quat->quat[x] = self->bone->quat[x];
-			self->dquat->quat[x] = self->bone->dquat[x];
-		}
-		for( x = 0; x < 4; x++ ) {
-			for( y = 0; y < 4; y++ ) {
-				self->obmat->matrix[x][y] =
-					self->bone->obmat[x][y];
-				self->parmat->matrix[x][y] =
-					self->bone->parmat[x][y];
-				self->defmat->matrix[x][y] =
-					self->bone->defmat[x][y];
-				self->irestmat->matrix[x][y] =
-					self->bone->irestmat[x][y];
-				self->posemat->matrix[x][y] =
-					self->bone->posemat[x][y];
-			}
-		}
-#endif
-		return 1;
-	}
-}
-
-//--------------- updateBoneData------------------------------------
-int updateBoneData( BPy_Bone * self, Bone * parent )
-{
-	//called from Armature.addBone()
-	int x, y;
-
-	//called in Armature.addBone() to update the Bone * data
-	if( !self->bone ) {
-		//nothing to update - not linked
-		return 0;
-	} else {
-		BLI_strncpy( self->bone->name, self->name,
-			     strlen( self->name ) + 1 );
-		self->bone->roll = self->roll;
-		self->bone->flag = self->flag;
-		self->bone->boneclass = (short)self->boneclass;
-		self->bone->dist = self->dist;
-		self->bone->weight = self->weight;
-		self->bone->parent = parent;	//parent will be checked from self->parent string in addBone()
-
-		for( x = 0; x < 3; x++ ) {
-			self->bone->head[x] = self->head->vec[x];
-			self->bone->tail[x] = self->tail->vec[x];
-//			self->bone->loc[x] = self->loc->vec[x];
-//			self->bone->dloc[x] = self->dloc->vec[x];
-//			self->bone->size[x] = self->size->vec[x];
-//			self->bone->dsize[x] = self->dsize->vec[x];
-		}
-		for( x = 0; x < 4; x++ ) {
-//			self->bone->quat[x] = self->quat->quat[x];
-//			self->bone->dquat[x] = self->dquat->quat[x];
-		}
-		for( x = 0; x < 4; x++ ) {
-			for( y = 0; y < 4; y++ ) {
-//				self->bone->obmat[x][y] =
-//					self->obmat->matrix[x][y];
-//				self->bone->parmat[x][y] =
-//					self->parmat->matrix[x][y];
-//				self->bone->defmat[x][y] =
-//					self->defmat->matrix[x][y];
-//				self->bone->irestmat[x][y] =
-//					self->irestmat->matrix[x][y];
-//				self->bone->posemat[x][y] =
-//					self->posemat->matrix[x][y];
-			}
-		}
-		return 1;
-	}
-}
-
-//--------------- testChildbase----------------------------------
-static int testChildbase( Bone * bone, Bone * test )
-{
-	Bone *child;
-
-	for( child = bone->childbase.first; child; child = child->next ) {
-		if( child == test ) {
-			return 1;
-		}
-		if( child->childbase.first != NULL )
-			testChildbase( child, test );
-	}
-
+#include "BKE_armature.h"
+#include "Mathutils.h"
+
+//------------------------ERROR CODES---------------------------------
+//This is here just to make me happy and to have more consistant error strings :)
+static const char sEditBoneError[] = "EditBone (internal) - Error: ";
+static const char sEditBoneBadArgs[] = "EditBone (internal) - Bad Arguments: ";
+static const char sBoneError[] = "Bone - Error: ";
+static const char sBoneBadArgs[] = "Bone - Bad Arguments: ";
+
+//----------------------(internal)
+//gets the bone->roll (which is a localspace roll) and puts it in parentspace
+//(which is the 'roll' value the user sees)
+double boneRoll_ToArmatureSpace(struct Bone *bone)
+{
+	float head[3], tail[3], delta[3];
+	float premat[3][3], postmat[3][3];
+	float imat[3][3], difmat[3][3];
+	double roll = 0.0f;
+
+	VECCOPY(head, bone->arm_head);
+	VECCOPY(tail, bone->arm_tail);		
+	VECSUB (delta, tail, head);			
+	vec_roll_to_mat3(delta, 0.0f, postmat);	
+	Mat3CpyMat4(premat, bone->arm_mat);		
+	Mat3Inv(imat, postmat);					
+	Mat3MulMat3(difmat, imat, premat);	
+
+	roll = atan(difmat[2][0] / difmat[2][2]); 
+	if (difmat[0][0] < 0.0){
+		roll += M_PI;
+	}
+	return roll; //result is in radians
+}
+//################## EditBone_Type (internal) ########################
+/*This type is a wrapper for a tempory bone. This is an 'unparented' bone
+*object. The armature->bonebase will be calculated from these temporary
+*python tracked objects.*/
+//#####################################################################
+
+//------------------METHOD IMPLEMENTATIONS-----------------------------
+//------------------ATTRIBUTE IMPLEMENTATION---------------------------
+//------------------------EditBone.name (get)
+static PyObject *EditBone_getName(BPy_EditBone *self, void *closure)
+{
+	return PyString_FromString(self->name);
+}
+//------------------------EditBone.name (set)
+//check for char[] overflow here...
+static int EditBone_setName(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	char *name = "";
+
+	if (!PyArg_Parse(value, "s", &name))
+		goto AttributeError;
+
+	BLI_strncpy(self->name, name, 32);
 	return 0;
-}
-
-//--------------- returnBoneclassEnum----------------------------
-static PyObject *returnBoneclassEnum( int value )
-{
-	char *str;
-	str = PyMem_Malloc( 32 + 1 );
 
-	switch ( value ) {
-	case 0:
-		BLI_strncpy( str, "SKINNABLE", 32 );
-		break;
-	case 1:
-		BLI_strncpy( str, "UNSKINNABLE", 32 );
-		break;
-	case 2:
-		BLI_strncpy( str, "HEAD", 32 );
-		break;
-	case 3:
-		BLI_strncpy( str, "NECK", 32 );
-		break;
-	case 4:
-		BLI_strncpy( str, "BACK", 32 );
-		break;
-	case 5:
-		BLI_strncpy( str, "SHOULDER", 32 );
-		break;
-	case 6:
-		BLI_strncpy( str, "ARM", 32 );
-		break;
-	case 7:
-		BLI_strncpy( str, "HAND", 32 );
-		break;
-	case 8:
-		BLI_strncpy( str, "FINGER", 32 );
-		break;
-	case 9:
-		BLI_strncpy( str, "THUMB", 32 );
-		break;
-	case 10:
-		BLI_strncpy( str, "PELVIS", 32 );
-		break;
-	case 11:
-		BLI_strncpy( str, "LEG", 32 );
-		break;
-	case 12:
-		BLI_strncpy( str, "FOOT", 32 );
-		break;
-	case 13:
-		BLI_strncpy( str, "TOE", 32 );
-		break;
-	case 14:
-		BLI_strncpy( str, "TENTACLE", 32 );
-		break;
-	default:
-		BLI_strncpy( str, "SKINNABLE", 32 );
-		break;
-	}
-	return ( PyObject * ) PyString_FromString( str );
+AttributeError:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".name: ", "expects a string");
 }
-
-//---------------BPy_Bone internal callbacks/methods---------------
-
-//--------------- dealloc------------------------------------------
-static void Bone_dealloc( BPy_Bone * self )
+//------------------------EditBone.roll (get)
+static PyObject *EditBone_getRoll(BPy_EditBone *self, void *closure)
 {
-	PyMem_Free( self->name );
-	PyMem_Free( self->parent );
-	PyObject_DEL( self );
+	return Py_BuildValue("{s:O}", 
+		"ARMATURESPACE", PyFloat_FromDouble((self->roll * (180/Py_PI))));
 }
-
-//---------------getattr-------------------------------------------
-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, "weight" ) == 0 )
-		attr = Bone_getWeight( self );
-	else if( strcmp( name, "boneclass" ) == 0 )
-		attr = Bone_getBoneclass( self );
-	else if( strcmp( name, "ik" ) == 0 )
-		attr = Bone_hasIK( self );
-	else if( strcmp( name, "__members__" ) == 0 ) {
-		/* 9 entries */
-		attr = Py_BuildValue( "[s,s,s,s,s,s,s,s,s,s,s]",
-				      "name", "roll", "head", "tail", "loc",
-				      "size", "quat", "parent", "children",
-				      "weight", "boneclass", "ik" );
-	}
-
-	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 );
+//------------------------EditBone.roll (set)
+static int EditBone_setRoll(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
 }
-
-//--------------- setattr-------------------------------------------
-static int Bone_setAttr( BPy_Bone * self, char *name, PyObject * value )
+//------------------------EditBone.head (get)
+static PyObject *EditBone_getHead(BPy_EditBone *self, void *closure)
 {
-	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 */
+	return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", newVectorObject(self->head, 3, Py_WRAP));;
 }
-
-//--------------- repr---------------------------------------------
-static PyObject *Bone_repr( BPy_Bone * self )
-{
-	if( self->bone )
-		return PyString_FromFormat( "[Bone \"%s\"]",
-					    self->bone->name );
-	else
-		return PyString_FromString( "NULL" );
+//------------------------EditBone.head (set)
+static int EditBone_setHead(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
 }
-
-//--------------- compare------------------------------------------
-static int Bone_compare( BPy_Bone * a, BPy_Bone * b )
+//------------------------EditBone.tail (get)
+static PyObject *EditBone_getTail(BPy_EditBone *self, void *closure)
 {
-	Bone *pa = a->bone, *pb = b->bone;
-	return ( pa == pb ) ? 0 : -1;
+    return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", newVectorObject(self->tail, 3, Py_WRAP));
 }
-
-//--------------- Bone_CreatePyObject---------------------------------
-PyObject *Bone_CreatePyObject( struct Bone * bone )
-{
-	BPy_Bone *blen_bone;
-
-	blen_bone = ( BPy_Bone * ) PyObject_NEW( BPy_Bone, &Bone_Type );
-
-	//set the all important Bone flag
-	blen_bone->bone = bone;
-
-	//allocate space for python vars
-	blen_bone->name = PyMem_Malloc( 32 + 1 );
-	blen_bone->parent = PyMem_Malloc( 32 + 1 );
-	blen_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	blen_bone->quat = blen_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
-	blen_bone->dquat = blen_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
-	blen_bone->obmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	blen_bone->parmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	blen_bone->defmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	blen_bone->irestmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	blen_bone->posemat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-
-	if( !updatePyBone( blen_bone ) )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "bone struct empty" );
-
-	return ( ( PyObject * ) blen_bone );
+//------------------------EditBone.tail (set)
+static int EditBone_setTail(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
 }
-
-//--------------- Bone_CheckPyObject--------------------------------
-int Bone_CheckPyObject( PyObject * py_obj )
+//------------------------EditBone.weight (get)
+static PyObject *EditBone_getWeight(BPy_EditBone *self, void *closure)
 {
-	return ( py_obj->ob_type == &Bone_Type );
-}
-
-//--------------- Bone_FromPyObject---------------------------------
-struct Bone *Bone_FromPyObject( PyObject * py_obj )
-{
-	BPy_Bone *blen_obj;
-
-	blen_obj = ( BPy_Bone * ) py_obj;
-	if( !( ( BPy_Bone * ) py_obj )->bone ) {	//test to see if linked to armature
-		//use python vars
-		return NULL;
-	} else {
-		//use bone datastruct
-		return ( blen_obj->bone );
-	}
-}
-
-//--------------- Python Bone Module methods------------------------
-
-//--------------- Blender.Armature.Bone.New()-----------------------
-static PyObject *M_Bone_New( PyObject * self, PyObject * args )
-{
-	char *name_str = "BoneName";
-	char *parent_str = "";
-	BPy_Bone *py_bone = NULL;	/* for Bone Data object wrapper in Python */
-
-	if( !PyArg_ParseTuple( args, "|s", &name_str ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected string or empty argument" ) );
-
-	//create python bone
-	py_bone = ( BPy_Bone * ) PyObject_NEW( BPy_Bone, &Bone_Type );
-
-	//allocate space for python vars
-	py_bone->name = PyMem_Malloc( 32 + 1 );
-	py_bone->parent = PyMem_Malloc( 32 + 1 );
-	py_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
-	py_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
-	py_bone->dquat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
-	py_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	py_bone->parmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	py_bone->defmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	py_bone->irestmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-	py_bone->posemat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
-
-	//default py values
-	BLI_strncpy( py_bone->name, name_str, strlen( name_str ) + 1 );
-	BLI_strncpy( py_bone->parent, parent_str, strlen( parent_str ) + 1 );
-	py_bone->roll = 0.0f;
-	py_bone->flag = 32;
-	py_bone->dist = 1.0f;
-	py_bone->weight = 1.0f;
-	Vector_Zero( py_bone->head );
-	Vector_Zero( py_bone->loc );
-	Vector_Zero( py_bone->dloc );
-	Vector_Zero( py_bone->size );
-	Vector_Zero( py_bone->dsize );
-	Quaternion_Identity( py_bone->quat );
-	Quaternion_Identity( py_bone->dquat );
-	Matrix_Identity( py_bone->obmat );
-	Matrix_Identity( py_bone->parmat );
-	Matrix_Identity( py_bone->defmat );
-	Matrix_Identity( py_bone->irestmat );
-	Matrix_Identity( py_bone->posemat );
-
-	//default tail of 2,0,0
-	py_bone->tail->vec[0] = 2.0f;
-	py_bone->tail->vec[1] = 0.0f;
-	py_bone->tail->vec[2] = 0.0f;
-
-	//set the datapointer to null (unlinked)
-	py_bone->bone = NULL;
-
-	return ( PyObject * ) py_bone;
-}
-
-//--------------- Python BPy_Bone methods---------------------------
-
-//--------------- BPy_Bone.getName()--------------------------------
-static PyObject *Bone_getName( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		attr = PyString_FromString( self->name );
-	} else {
-		//use bone datastruct
-		attr = PyString_FromString( self->bone->name );
-	}
-	if( attr )
-		return attr;
-
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.name attribute" ) );
-}
-
-//--------------- BPy_Bone.getRoll()---------------------------------
-static PyObject *Bone_getRoll( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		attr = Py_BuildValue( "f", self->roll );
-	} else {
-		//use bone datastruct
-		attr = Py_BuildValue( "f", self->bone->roll );
-	}
-	if( attr )
-		return attr;
-
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.roll attribute" ) );
-}
-
-//--------------- BPy_Bone.getWeight()---------------------------------
-static PyObject *Bone_getWeight( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		attr = Py_BuildValue( "f", self->weight );
-	} else {
-		//use bone datastruct
-		attr = Py_BuildValue( "f", self->bone->weight );
-	}
-	if( attr )
-		return attr;
-
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.weight attribute" ) );
-}
-
-//--------------- BPy_Bone.getHead()----------------------------------
-static PyObject *Bone_getHead( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-	float vec[3];
-	int x;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		for( x = 0; x < 3; x++ )
-			vec[x] = self->head->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
-	} else {
-		//use bone datastruct
-		attr = newVectorObject( NULL, 3, Py_NEW );
-		( ( VectorObject * ) attr )->vec[0] = self->bone->head[0];
-		( ( VectorObject * ) attr )->vec[1] = self->bone->head[1];
-		( ( VectorObject * ) attr )->vec[2] = self->bone->head[2];
-	}
-	if( attr )
-		return attr;
-
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.head attribute" ) );
+	return PyFloat_FromDouble(self->weight);
 }
+//------------------------EditBone.weight (set)
+static int EditBone_setWeight(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	float weight;
 
-//--------------- BPy_Bone.getTail()---------------------------------
-static PyObject *Bone_getTail( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-	float vec[3];
-	int x;
+	if (!PyArg_Parse(value, "f", &weight))
+		goto AttributeError;
+	CLAMP(weight, 0.0f, 1000.0f);
 
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		for( x = 0; x < 3; x++ )
-			vec[x] = self->tail->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
-	} else {
-		//use bone datastruct
-		attr = newVectorObject( NULL, 3, Py_NEW );
-		( ( VectorObject * ) attr )->vec[0] = self->bone->tail[0];
-		( ( VectorObject * ) attr )->vec[1] = self->bone->tail[1];
-		( ( VectorObject * ) attr )->vec[2] = self->bone->tail[2];
-	}
-	if( attr )
-		return attr;
+	self->weight = weight;
+	return 0;
 
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.tail attribute" ) );
+AttributeError:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".weight: ", "expects a float");
 }
-
-//--------------- BPy_Bone.getLoc()---------------------------------
-static PyObject *Bone_getLoc( BPy_Bone * self )
+//------------------------EditBone.deform_dist (get)
+static PyObject *EditBone_getDeform_dist(BPy_EditBone *self, void *closure)
 {
-	PyObject *attr = NULL;
-	float vec[3];
-	int x;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		for( x = 0; x < 3; x++ )
-			vec[x] = self->loc->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
-	} else {
-		//use bone datastruct
-		attr = newVectorObject( NULL, 3, Py_NEW );
-		
-//		( ( VectorObject * ) attr )->vec[0] = self->bone->loc[0];
-//		( ( VectorObject * ) attr )->vec[1] = self->bone->loc[1];
-//		( ( VectorObject * ) attr )->vec[2] = self->bone->loc[2];
-	}
-	if( attr )
-		return attr;
-
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.loc attribute" ) );
+    return PyFloat_FromDouble(self->dist);
 }
+//------------------------EditBone.deform_dist (set)
+static int EditBone_setDeform_dist(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	float deform;
 
-//--------------- BPy_Bone.getSize()-----------------------------
-static PyObject *Bone_getSize( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-	float vec[3];
-	int x;
+	if (!PyArg_Parse(value, "f", &deform))
+		goto AttributeError;
+	CLAMP(deform, 0.0f, 1000.0f);
 
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		for( x = 0; x < 3; x++ )
-			vec[x] = self->size->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
-	} else {
-		//use bone datastruct
-		attr = newVectorObject( NULL, 3, Py_NEW );
-//		( ( VectorObject * ) attr )->vec[0] = self->bone->size[0];
-//		( ( VectorObject * ) attr )->vec[1] = self->bone->size[1];
-//		( ( VectorObject * ) attr )->vec[2] = self->bone->size[2];
-	}
-	if( attr )
-		return attr;
+	self->dist = deform;
+	return 0;
 
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.size attribute" ) );
+AttributeError:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".deform_dist: ", "expects a float");
 }
-
-//--------------- BPy_Bone.getQuat()--------------------------------
-static PyObject *Bone_getQuat( BPy_Bone * self )
+//------------------------EditBone.subdivisions (get)
+static PyObject *EditBone_getSubdivisions(BPy_EditBone *self, void *closure)
 {
-	PyObject *attr = NULL;
-	float quat[4];
-	int x;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars - p.s. - you must return a copy or else
-		//python will trash the internal var
-		for( x = 0; x < 4; x++ )
-			quat[x] = self->quat->quat[x];
-		attr = ( PyObject * ) newQuaternionObject( quat, Py_NEW );
-	} else {
-		//use bone datastruct
-		attr = newQuaternionObject( NULL, Py_NEW );
-//		( ( QuaternionObject * ) attr )->quat[0] = self->bone->quat[0];
-//		( ( QuaternionObject * ) attr )->quat[1] = self->bone->quat[1];
-//		( ( QuaternionObject * ) attr )->quat[2] = self->bone->quat[2];
-//		( ( QuaternionObject * ) attr )->quat[3] = self->bone->quat[3];
-	}
-
-	return attr;
+    return PyInt_FromLong(self->segments);
 }
+//------------------------EditBone.subdivisions (set)
+static int EditBone_setSubdivisions(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	int segs;
 
-//--------------- BPy_Bone.hasParent()---------------------------
-static PyObject *Bone_hasParent( BPy_Bone * self )
-{
-	char *parent_str = "";
+	if (!PyArg_Parse(value, "i", &segs))
+		goto AttributeError;
+	CLAMP(segs, 1, 32);
 
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		if( BLI_streq( self->parent, parent_str ) ) {
-			return EXPP_incr_ret_False();
-		} else {
-			return EXPP_incr_ret_True();
-		}
-	} else {
-		//use bone datastruct
-		if( self->bone->parent ) {
-			return EXPP_incr_ret_True();
-		} else {
-			return EXPP_incr_ret_False();
-		}
-	}
-}
+	self->segments = (short)segs;
+	return 0;
 
-//--------------- BPy_Bone.getParent()------------------------------
-static PyObject *Bone_getParent( BPy_Bone * self )
-{
-	char *parent_str = "";
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		if( BLI_streq( self->parent, parent_str ) ) {
-			return EXPP_incr_ret( Py_None );
-		} else {
-			return PyString_FromString( self->parent );
-		}
-	} else {
-		//use bone datastruct
-		if( self->bone->parent ) {
-			return Bone_CreatePyObject( self->bone->parent );
-		} else {
-			return EXPP_incr_ret( Py_None );
+AttributeError:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".subdivisions: ", "expects a integer");
+}
+//------------------------EditBone.options (get)
+static PyObject *EditBone_getOptions(BPy_EditBone *self, void *closure)
+{
+	PyObject *list = NULL;
+
+	list = PyList_New(0);
+	if (list == NULL)
+		goto RuntimeError;
+
+	if(self->flag & BONE_CONNECTED)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "CONNECTED")) == -1)
+			goto RuntimeError;
+	if(self->flag & BONE_HINGE)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "HINGE")) == -1)
+			goto RuntimeError;
+	if(self->flag & BONE_NO_DEFORM)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "NO_DEFORM")) == -1)
+			goto RuntimeError;
+	if(self->flag & BONE_MULT_VG_ENV)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "MULTIPLY")) == -1)
+			goto RuntimeError;
+	if(self->flag & BONE_HIDDEN_A)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "HIDDEN_EDIT")) == -1)
+			goto RuntimeError;
+
+	return EXPP_incr_ret(list);
+
+RuntimeError:
+	return EXPP_objError(PyExc_RuntimeError, "%s%s%s", 
+		sEditBoneError, ".options: ", "Internal failure!");
+}
+//----------------------(internal) EditBone_CheckValidConstant
+static int EditBone_CheckValidConstant(PyObject *constant)
+{
+	PyObject *name = NULL;
+
+	if (constant){
+		if (BPy_Constant_Check(constant)){
+			name = PyDict_GetItemString(((BPy_constant*)constant)->dict, "name");
+			if (!name) return 0;
+			if (!(STREQ3(PyString_AsString(name), "CONNECTED", "HINGE", "NO_DEFORM")
+				|| STREQ2(PyString_AsString(name), "MULTIPLY", "HIDDEN_EDIT"))){
+					return 0;
+				}else{
+					return 1;
+				}
+		}else{
+			return 0;
 		}
+	}else{
+		return 0;
 	}
 }
 
-//--------------- BPy_Bone.getChildren()-----------------------------
-static PyObject *Bone_getChildren( BPy_Bone * self )
-{
-	int totbones = 0;
-	Bone *current = NULL;
-	PyObject *listbones = NULL;
-	int i;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		return EXPP_incr_ret( Py_None );
-	} else {
-		//use bone datastruct
-		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;
+//------------------------EditBone.options (set)
+static int EditBone_setOptions(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	int length, numeric_value, new_flag = 0, x;
+	PyObject *val = NULL, *index = NULL;
+
+	if (PyList_Check(value)){
+		length = PyList_Size(value);
+		for (x = 0; x < length; x++){
+			index = PyList_GetItem(value, x);
+			if (!EditBone_CheckValidConstant(index))
+				goto AttributeError2;
+			val = PyDict_GetItemString(((BPy_constant*)index)->dict, "value");
+			if (PyInt_Check(val)){
+				numeric_value = (int)PyInt_AS_LONG(val);
+				new_flag |= numeric_value;
+			}else{
+				goto AttributeError2;
+			}
 		}
-		return listbones;
-	}
-}
+		self->flag = new_flag;
+		return 0;
+	}else if (BPy_Constant_Check(value)){
+		if (!EditBone_CheckValidConstant(value))
+			goto AttributeError2;
+		val = PyDict_GetItemString(((BPy_constant*)value)->dict, "value");
+		if (PyInt_Check(val)){
+			numeric_value = (int)PyInt_AS_LONG(val);
+			self->flag = numeric_value;
+			return 0;
+		}else{
+			goto AttributeError2;
+		}
+	}else{
+		goto AttributeError1;
+	}
+
+AttributeError1:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".options(): ", "Expects a constant or list of constants");
+
+AttributeError2:
+	return EXPP_intError(PyExc_AttributeError, "%s%s%s",
+		sEditBoneError, ".options(): ", "Please use a constant defined in the Armature module");
+}
+//------------------------EditBone.parent (get)
+static PyObject *EditBone_getParent(BPy_EditBone *self, void *closure)
+{
+	//if (!STREQ(self->parent, ""))
+	//	return PyString_FromString(PyBone_FromBone(self->parent));
+	//else
+	printf("Sorry this isn't implemented yet.... :/");
+	return EXPP_incr_ret(Py_None);
+}
+//------------------------EditBone.parent (set)
+static int EditBone_setParent(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
+}
+
+//------------------------EditBone.children (get)
+static PyObject *EditBone_getChildren(BPy_EditBone *self, void *closure)
+{
+	printf("Sorry this isn't implemented yet.... :/");
+	return EXPP_incr_ret(Py_None);
+}
+//------------------------EditBone.children (set)
+static int EditBone_setChildren(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
+}
+//------------------------EditBone.matrix (get)
+static PyObject *EditBone_getMatrix(BPy_EditBone *self, void *closure)
+{
+	printf("Sorry this isn't implemented yet.... :/");
+    return EXPP_incr_ret(Py_None);
+}
+//------------------------EditBone.matrix (set)
+static int EditBone_setMatrix(BPy_EditBone *self, PyObject *value, void *closure)
+{  
+	printf("Sorry this isn't implemented yet.... :/");
+	return 1;
+}
+//------------------TYPE_OBECT IMPLEMENTATION--------------------------
+//TODO: We need to think about the below methods
+//------------------------tp_methods
+//This contains a list of all methods the object contains
+//static PyMethodDef BPy_Bone_methods[] = {
+//	{"clearParent", (PyCFunction) Bone_clearParent, METH_NOARGS, 
+//		"() - disconnects this bone from it's parent"},
+//	{"clearChildren", (PyCFunction) Bone_clearChildren, METH_NOARGS, 
+//		"() - disconnects all the children from this bone"},
+//	{NULL}
+//};
+//------------------------tp_getset
+//This contains methods for attributes that require checking
+static PyGetSetDef BPy_EditBone_getset[] = {
+	{"name", (getter)EditBone_getName, (setter)EditBone_setName, 
+		"The name of the bone", NULL},
+	{"roll", (getter)EditBone_getRoll, (setter)EditBone_setRoll, 
+		"The roll (or rotation around the axis) of the bone", NULL},
+	{"head", (getter)EditBone_getHead, (setter)EditBone_setHead, 
+		"The start point of the bone", NULL},
+	{"tail", (getter)EditBone_getTail, (setter)EditBone_setTail, 
+		"The end point of the bone", NULL},
+	{"matrix", (getter)EditBone_getMatrix, (setter)EditBone_setMatrix, 
+		"The matrix of the bone", NULL},
+	{"weight", (getter)EditBone_getWeight, (setter)EditBone_setWeight, 
+		"The weight of the bone in relation to a parented mesh", NULL},
+	{"deform_dist", (getter)EditBone_getDeform_dist, (setter)EditBone_setDeform_dist, 
+		"The distance at which deformation has effect", NULL},
+	{"subdivisions", (getter)EditBone_getSubdivisions, (setter)EditBone_setSubdivisions, 
+		"The number of subdivisions (for B-Bones)", NULL},
+	{"options", (getter)EditBone_getOptions, (setter)EditBone_setOptions, 
+		"The options effective on this bone", NULL},
+	{"parent", (getter)EditBone_getParent, (setter)EditBone_setParent, 
+		"The parent bone of this bone", NULL},
+	{"children", (getter)EditBone_getChildren, (setter)EditBone_setChildren, 
+		"The child bones of this bone", NULL},
+	{NULL}
+};
 
-//--------------- BPy_Bone.setName()---------------------------------
-static PyObject *Bone_setName( BPy_Bone * self, PyObject * args )
+//------------------------tp_repr
+//This is the string representation of the object
+static PyObject *EditBone_repr(BPy_EditBone *self)
 {
-	char *name;
-	char buf[25];
-
-	if( !PyArg_ParseTuple( args, "s", &name ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_AttributeError,
-			   "expected string argument" ) );
-	/* 
-	   note:
-	   a nicer way to do this is to have #defines for the size of names.
-	   stivs  25-jan-200
-	*/
-
-	/* guarantee a null terminated string of reasonable size */
-	PyOS_snprintf( buf, sizeof( buf ), "%s", name );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		BLI_strncpy( self->name, buf, sizeof( buf ) );
-	} else {
-		//use bone datastruct
-		BLI_strncpy( self->bone->name, buf, sizeof( buf )  );
-	}
-	return EXPP_incr_ret( Py_None );
+	return PyString_FromFormat( "[EditBone \"%s\"]", self->name ); 
 }
 
-//--------------- BPy_Bone.setRoll()--------------------------------
-PyObject *Bone_setRoll( BPy_Bone * self, PyObject * args )
-{
-	float roll;
-
-	if( !PyArg_ParseTuple( args, "f", &roll ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected float argument" ) );
+//------------------------tp_doc
+//The __doc__ string for this object
+static char BPy_EditBone_doc[] = "This is an internal subobject of armature\
+designed to act as a wrapper for an 'edit bone'.";
 
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->roll = roll;
-	} else {
-		//use bone datastruct
-		self->bone->roll = roll;
-	}
-	return EXPP_incr_ret( Py_None );
-}
-
-//--------------- BPy_Bone.setHead()---------------------------------
-static PyObject *Bone_setHead( BPy_Bone * self, PyObject * args )
-{
-	float f1, f2, f3;
-	int status;
-
-	if( PyObject_Length( args ) == 3 )
-		status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 );
-	else
-		status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 );
-
-	if( !status )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected 3 (or a list of 3) float arguments" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->head->vec[0] = f1;
-		self->head->vec[1] = f2;
-		self->head->vec[2] = f3;
-	} else {
-		//use bone datastruct
-		self->bone->head[0] = f1;
-		self->bone->head[1] = f2;
-		self->bone->head[2] = f3;
-	}
-	return EXPP_incr_ret( Py_None );
-}
-
-//--------------- BPy_Bone.setTail()---------------------------------
-static PyObject *Bone_setTail( BPy_Bone * self, PyObject * args )
+//------------------------tp_new
+//This methods creates a new object (note it does not initialize it - only the building)
+static PyObject *EditBone_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-	float f1, f2, f3;
-	int status;
-
-	if( PyObject_Length( args ) == 3 )
-		status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 );
-	else
-		status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 );
-
-	if( !status )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected 3 (or a list of 3) float arguments" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->tail->vec[0] = f1;
-		self->tail->vec[1] = f2;
-		self->tail->vec[2] = f3;
-	} else {
-		//use bone datastruct
-		self->bone->tail[0] = f1;
-		self->bone->tail[1] = f2;
-		self->bone->tail[2] = f3;
-	}
-	return EXPP_incr_ret( Py_None );
-}
-
-//--------------- BPy_Bone.setLoc()----------------------------------
-static PyObject *Bone_setLoc( BPy_Bone * self, PyObject * args )
-{
-	float f1, f2, f3;
-	int status;
-
-	if( PyObject_Length( args ) == 3 )
-		status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 );
-	else
-		status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 );
-
-	if( !status )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected 3 (or a list of 3) float arguments" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->loc->vec[0] = f1;
-		self->loc->vec[1] = f2;
-		self->loc->vec[2] = f3;
-	} else {
-		//use bone datastruct
-//		self->bone->loc[0] = f1;
-//		self->bone->loc[1] = f2;
-//		self->bone->loc[2] = f3;
-	}
-	return EXPP_incr_ret( Py_None );
-}
+	BPy_EditBone *py_editBone = NULL;
+	PyObject *py_bone;
+	struct Bone *bone;
+	int i;
 
-//--------------- BPy_Bone.setSize()---------------------------------
-static PyObject *Bone_setSize( BPy_Bone * self, PyObject * args )
-{
-	float f1, f2, f3;
-	int status;
+	if(!PyArg_ParseTuple(args, "O!", &Bone_Type, &py_bone))
+		goto AttributeError;
+
+	py_editBone = (BPy_EditBone*)type->tp_alloc(type, 0); //new
+	if (py_editBone == NULL)
+		goto RuntimeError;
+
+	bone = ((BPy_Bone*)py_bone)->bone;
+
+	BLI_strncpy(py_editBone->name, bone->name, 32);
+	py_editBone->flag = bone->flag;
+	py_editBone->length = bone->length;
+	py_editBone->weight = bone->weight;
+	py_editBone->dist = bone->dist;
+	py_editBone->xwidth = bone->xwidth;
+	py_editBone->zwidth = bone->zwidth;
+	py_editBone->ease1 = bone->ease1;
+	py_editBone->ease2 = bone->ease2;
+	py_editBone->rad_head = bone->rad_head;
+	py_editBone->rad_tail = bone->rad_tail;
+	py_editBone->segments = bone->segments;
+	py_editBone->temp = NULL;
+
+	if (bone->parent){
+		BLI_strncpy(py_editBone->parent, bone->parent->name, 32);
+	}else{
+		BLI_strncpy(py_editBone->parent, "", 32);
+	}
+
+	py_editBone->roll = (float)boneRoll_ToArmatureSpace(bone);
+
+	for (i = 0; i < 3; i++){
+		py_editBone->head[i] = bone->arm_head[i];
+		py_editBone->tail[i] = bone->arm_tail[i];
+	}
+	return (PyObject*)py_editBone;
+
+RuntimeError:
+	return EXPP_objError(PyExc_RuntimeError, "%s%s%s", 
+		sEditBoneError, " __new__: ", "Internal Error");
+AttributeError:
+	return EXPP_objError(PyExc_AttributeError, "%s%s%s", 
+		sEditBoneBadArgs, " __new__: ", "Expects PyBone and optional float");
+}
+//------------------------tp_dealloc
+//This tells how to 'tear-down' our object when ref count hits 0
+static void EditBone_dealloc(BPy_EditBone * self)
+{
+	((PyObject*)self)->ob_type->tp_free((PyObject*)self);
+	return;
+}
+//------------------TYPE_OBECT DEFINITION--------------------------
+PyTypeObject EditBone_Type = {
+	PyObject_HEAD_INIT(NULL)       //tp_head
+	0,                             //tp_internal
+	"EditBone",                    //tp_name
+	sizeof(BPy_EditBone),          //tp_basicsize
+	0,                             //tp_itemsize
+	(destructor)EditBone_dealloc,  //tp_dealloc
+	0,                             //tp_print
+	0,                             //tp_getattr
+	0,                             //tp_setattr
+	0,                             //tp_compare
+	(reprfunc)EditBone_repr,       //tp_repr
+	0,                             //tp_as_number
+	0,                             //tp_as_sequence
+	0,                             //tp_as_mapping
+	0,                             //tp_hash
+	0,                             //tp_call
+	0,                             //tp_str
+	0,                             //tp_getattro
+	0,                             //tp_setattro
+	0,                             //tp_as_buffer
+	Py_TPFLAGS_DEFAULT,            //tp_flags
+	BPy_EditBone_doc,              //tp_doc
+	0,                             //tp_traverse
+	0,                             //tp_clear
+	0,                             //tp_richcompare
+	0,                             //tp_weaklistoffset
+	0,                             //tp_iter
+	0,                             //tp_iternext
+	0,                             //tp_methods
+	0,                             //tp_members
+	BPy_EditBone_getset,           //tp_getset
+	0,                             //tp_base
+	0,                             //tp_dict
+	0,                             //tp_descr_get
+	0,                             //tp_descr_set
+	0,                             //tp_dictoffset
+	0,                             //tp_init
+	0,                             //tp_alloc
+	(newfunc)EditBone_new,         //tp_new
+	0,                             //tp_free
+	0,                             //tp_is_gc
+	0,                             //tp_bases
+	0,                             //tp_mro
+	0,                             //tp_cache
+	0,                             //tp_subclasses
+	0,                             //tp_weaklist
+	0                              //tp_del
+};
 
-	if( PyObject_Length( args ) == 3 )
-		status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 );
+//------------------METHOD IMPLEMENTATIONS--------------------------------
+//------------------ATTRIBUTE IMPLEMENTATIONS-----------------------------
+//------------------------Bone.name (get)
+static PyObject *Bone_getName(BPy_Bone *self, void *closure)
+{
+	return PyString_FromString(self->bone->name);
+}
+//------------------------Bone.name (set)
+//check for char[] overflow here...
+static int Bone_setName(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.roll (get)
+static PyObject *Bone_getRoll(BPy_Bone *self, void *closure)
+{
+	return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", PyFloat_FromDouble((self->bone->roll * (180/Py_PI))),
+		"ARMATURESPACE", PyFloat_FromDouble((boneRoll_ToArmatureSpace(self->bone) * (180/Py_PI))));
+}
+//------------------------Bone.roll (set)
+static int Bone_setRoll(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.head (get)
+static PyObject *Bone_getHead(BPy_Bone *self, void *closure)
+{
+	return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", newVectorObject(self->bone->head, 3, Py_WRAP),
+		"ARMATURESPACE", newVectorObject(self->bone->arm_head, 3, Py_WRAP));
+}
+//------------------------Bone.head (set)
+static int Bone_setHead(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.tail (get)
+static PyObject *Bone_getTail(BPy_Bone *self, void *closure)
+{
+    return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", newVectorObject(self->bone->tail, 3, Py_WRAP),
+		"ARMATURESPACE", newVectorObject(self->bone->arm_tail, 3, Py_WRAP));
+}
+//------------------------Bone.tail (set)
+static int Bone_setTail(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.weight (get)
+static PyObject *Bone_getWeight(BPy_Bone *self, void *closure)
+{
+	return PyFloat_FromDouble(self->bone->weight);
+}
+//------------------------Bone.weight (set)
+static int Bone_setWeight(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.deform_dist (get)
+static PyObject *Bone_getDeform_dist(BPy_Bone *self, void *closure)
+{
+    return PyFloat_FromDouble(self->bone->dist);
+}
+//------------------------Bone.deform_dist (set)
+static int Bone_setDeform_dist(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.subdivisions (get)
+static PyObject *Bone_getSubdivisions(BPy_Bone *self, void *closure)
+{
+    return PyInt_FromLong(self->bone->segments);
+}
+//------------------------Bone.subdivisions (set)
+static int Bone_setSubdivisions(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.connected (get)
+static PyObject *Bone_getOptions(BPy_Bone *self, void *closure)
+{
+	PyObject *list = NULL;
+
+	list = PyList_New(0);
+	if (list == NULL)
+		goto RuntimeError;
+
+	if(self->bone->flag & BONE_CONNECTED)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "CONNECTED")) == -1)
+			goto RuntimeError;
+	if(self->bone->flag & BONE_HINGE)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "HINGE")) == -1)
+			goto RuntimeError;
+	if(self->bone->flag & BONE_NO_DEFORM)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "NO_DEFORM")) == -1)
+			goto RuntimeError;
+	if(self->bone->flag & BONE_MULT_VG_ENV)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "MULTIPLY")) == -1)
+			goto RuntimeError;
+	if(self->bone->flag & BONE_HIDDEN_A)
+		if (PyList_Append(list, 
+			EXPP_GetModuleConstant("Blender.Armature", "HIDDEN_EDIT")) == -1)
+			goto RuntimeError;
+
+	return EXPP_incr_ret(list);
+
+RuntimeError:
+	return EXPP_objError(PyExc_RuntimeError, "%s%s%s", 
+		sBoneError, "getOptions(): ", "Internal failure!");
+}
+//------------------------Bone.connected (set)
+static int Bone_setOptions(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.parent (get)
+static PyObject *Bone_getParent(BPy_Bone *self, void *closure)
+{
+	if (self->bone->parent)
+		return PyBone_FromBone(self->bone->parent);
 	else
-		status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 );
-
-	if( !status )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected 3 (or a list of 3) float arguments" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->size->vec[0] = f1;
-		self->size->vec[1] = f2;
-		self->size->vec[2] = f3;
-	} else {
-		//use bone datastruct
-//		self->bone->size[0] = f1;
-//		self->bone->size[1] = f2;
-//		self->bone->size[2] = f3;
-	}
-	return EXPP_incr_ret( Py_None );
-}
-
-//--------------- BPy_Bone.setQuat()-------------------------------
-static PyObject *Bone_setQuat( BPy_Bone * self, PyObject * args )
-{
-	float f1, f2, f3, f4;
-	PyObject *argument;
-	QuaternionObject *quatOb;
-	int status;
-
-	if( !PyArg_ParseTuple( args, "O", &argument ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected quaternion or float list" ) );
-
-	if( QuaternionObject_Check( argument ) ) {
-		status = PyArg_ParseTuple( args, "O!", &quaternion_Type,
-					   &quatOb );
-		f1 = quatOb->quat[0];
-		f2 = quatOb->quat[1];
-		f3 = quatOb->quat[2];
-		f4 = quatOb->quat[3];
-	} else {
-		status = PyArg_ParseTuple( args, "(ffff)", &f1, &f2, &f3,
-					   &f4 );
-	}
-
-	if( !status )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"unable to parse argument" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->quat->quat[0] = f1;
-		self->quat->quat[1] = f2;
-		self->quat->quat[2] = f3;
-		self->quat->quat[3] = f4;
-	} else {
-		//use bone datastruct
-//		self->bone->quat[0] = f1;
-//		self->bone->quat[1] = f2;
-//		self->bone->quat[2] = f3;
-//		self->bone->quat[3] = f4;
-	}
-	return EXPP_incr_ret( Py_None );
+		return EXPP_incr_ret(Py_None);
 }
-
-//--------------- BPy_Bone.setParent()------------------------------
-static PyObject *Bone_setParent( BPy_Bone * self, PyObject * args )
-{
-	BPy_Bone *py_bone;
-	float M_boneObjectspace[4][4];
-	float iM_parentRest[4][4];
-
-	if( !PyArg_ParseTuple( args, "O", &py_bone ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected bone object argument" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		BLI_strncpy( self->parent, py_bone->name,
-			     strlen( py_bone->name ) + 1 );
-	} else {
-		//use bone datastruct
-		if( !py_bone->bone )
-			return ( EXPP_ReturnPyObjError
-				 ( PyExc_TypeError,
-				   "Parent bone must be linked to armature first!" ) );
-
-		if( py_bone->bone == self->bone )
-			return ( EXPP_ReturnPyObjError
-				 ( PyExc_AttributeError,
-				   "Cannot parent to self" ) );
-
-		//test to see if were creating an illegal loop by parenting to child
-		if( testChildbase( self->bone, py_bone->bone ) )
-			return ( EXPP_ReturnPyObjError
-				 ( PyExc_AttributeError,
-				   "Cannot parent to child" ) );
-
-		//set the parent of self - in this case 
-                //we are changing the parenting after this bone
-		//has been linked in it's armature
-		if( self->bone->parent ) {	//we are parenting something previously parented
-
-			//remove the childbase link from the parent bone
-			BLI_remlink( &self->bone->parent->childbase,
-				     self->bone );
-
-			//now get rid of the parent transformation
-			get_objectspace_bone_matrix( self->bone->parent,
-						     M_boneObjectspace, 0, 0 );
-			Mat4MulVecfl( M_boneObjectspace, self->bone->head );
-			Mat4MulVecfl( M_boneObjectspace, self->bone->tail );
-
-			//add to the childbase of new parent
-			BLI_addtail( &py_bone->bone->childbase, self->bone );
-
-			//transform bone according to new parent
-			get_objectspace_bone_matrix( py_bone->bone,
-						     M_boneObjectspace, 0, 0 );
-			Mat4Invert( iM_parentRest, M_boneObjectspace );
-			Mat4MulVecfl( iM_parentRest, self->bone->head );
-			Mat4MulVecfl( iM_parentRest, self->bone->tail );
-
-			//set parent
-			self->bone->parent = py_bone->bone;
-
-		} else {	//not previously parented
-
-			//add to the childbase of new parent
-			BLI_addtail( &py_bone->bone->childbase, self->bone );
-
-			//transform bone according to new parent
-			get_objectspace_bone_matrix( py_bone->bone,
-						     M_boneObjectspace, 0, 0 );
-			Mat4Invert( iM_parentRest, M_boneObjectspace );
-			Mat4MulVecfl( iM_parentRest, self->bone->head );
-			Mat4MulVecfl( iM_parentRest, self->bone->tail );
-
-			self->bone->parent = py_bone->bone;
-		}
-	}
-	return EXPP_incr_ret( Py_None );
-}
-
-//--------------- BPy_Bone.setWeight()----------------------------
-static PyObject *Bone_setWeight( BPy_Bone * self, PyObject * args )
-{
-	float weight;
-
-	if( !PyArg_ParseTuple( args, "f", &weight ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected float argument" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->weight = weight;
-	} else {
-		//use bone datastruct
-		self->bone->weight = weight;
-	}
-	return EXPP_incr_ret( Py_None );
+//------------------------Bone.parent (set)
+static int Bone_setParent(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
 }
-
-//--------------- BPy_Bone.clearParent()--------------------------
-static PyObject *Bone_clearParent( BPy_Bone * self )
-{
-	bArmature *arm = NULL;
+//------------------------(internal) PyBone_ChildrenAsList
+static int PyBone_ChildrenAsList(PyObject *list, ListBase *bones){
 	Bone *bone = NULL;
-	Bone *parent = NULL;
-	Bone *child = NULL;
-	Bone *childPrev = NULL;
-	int firstChild;
-	float M_boneObjectspace[4][4];
-	char *parent_str = "";
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		BLI_strncpy( self->parent, parent_str,
-			     strlen( parent_str ) + 1 );
-	} else {
-		//use bone datastruct
-		if( self->bone->parent == NULL )
-			return EXPP_incr_ret( Py_None );
-
-		//get parent and remove link
-		parent = self->bone->parent;
-		self->bone->parent = NULL;
-
-		//remove the childbase link from the parent bone
-		firstChild = 1;
-		for( child = parent->childbase.first; child;
-		     child = child->next ) {
-			if( child == self->bone && firstChild ) {
-				parent->childbase.first = child->next;
-				child->next = NULL;
-				break;
-			}
-			if( child == self->bone && !firstChild ) {
-				childPrev->next = child->next;
-				child->next = NULL;
-				break;
-			}
-			firstChild = 0;
-			childPrev = child;
-		}
-
-		//now get rid of the parent transformation
-		get_objectspace_bone_matrix( parent, M_boneObjectspace, 0, 0 );
-
-		//transformation of local bone
-		Mat4MulVecfl( M_boneObjectspace, self->bone->head );
-		Mat4MulVecfl( M_boneObjectspace, self->bone->tail );
-
-		//get the root bone
-		while( parent->parent != NULL ) {
-			parent = parent->parent;
-		}
-
-		//add unlinked bone to the bonebase of the armature
-		for( arm = G.main->armature.first; arm; arm = arm->id.next ) {
-			for( bone = arm->bonebase.first; bone;
-			     bone = bone->next ) {
-				if( parent == bone ) {
-					//we found the correct armature - now add it as root bone
-					BLI_addtail( &arm->bonebase,
-						     self->bone );
-					break;
-				}
-			}
-		}
-	}
-	return EXPP_incr_ret( Py_None );
-}
+	PyObject *py_bone = NULL;
+
+	for (bone = bones->first; bone; bone = bone->next){
+		py_bone = PyBone_FromBone(bone);
+		if (py_bone == NULL)
+			return 0;
+
+		if(PyList_Append(list, py_bone) == -1){
+			goto RuntimeError;
+		}
+		if (bone->childbase.first) 
+			PyBone_ChildrenAsList(list, &bone->childbase);
+	}
+	return 1;
+
+RuntimeError:
+	return EXPP_intError(PyExc_RuntimeError, "%s%s", 
+		sBoneError, "Internal error trying to wrap blender bones!");
+}
+
+//------------------------Bone.children (get)
+static PyObject *Bone_getChildren(BPy_Bone *self, void *closure)
+{
+	PyObject *list = NULL;
+
+	if (self->bone->childbase.first){
+		list = PyList_New(0);
+		if (!PyBone_ChildrenAsList(list, &self->bone->childbase))
+			return NULL;
+		return EXPP_incr_ret(list);
+	}else{
+		return EXPP_incr_ret(Py_None);
+	}
+}
+//------------------------Bone.children (set)
+static int Bone_setChildren(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------------Bone.matrix (get)
+static PyObject *Bone_getMatrix(BPy_Bone *self, void *closure)
+{
+    return Py_BuildValue("{s:O, s:O}", 
+		"BONESPACE", newMatrixObject((float*)self->bone->bone_mat, 3,3, Py_WRAP),
+		"ARMATURESPACE", newMatrixObject((float*)self->bone->arm_mat, 4,4, Py_WRAP));
+}
+//------------------------Bone.matrix (set)
+static int Bone_setMatrix(BPy_Bone *self, PyObject *value, void *closure)
+{  
+  return EXPP_intError(PyExc_ValueError, "%s%s", 
+		sBoneError, "You must first call Armature.makeEditable() to edit the armature");
+}
+//------------------TYPE_OBECT IMPLEMENTATION--------------------------
+//------------------------tp_getset
+//This contains methods for attributes that require checking
+static PyGetSetDef BPy_Bone_getset[] = {
+	{"name", (getter)Bone_getName, (setter)Bone_setName, 
+		"The name of the bone", NULL},
+	{"roll", (getter)Bone_getRoll, (setter)Bone_setRoll, 
+		"The roll (or rotation around the axis) of the bone", NULL},
+	{"head", (getter)Bone_getHead, (setter)Bone_setHead, 
+		"The start point of the bone", NULL},
+	{"tail", (getter)Bone_getTail, (setter)Bone_setTail, 
+		"The end point of the bone", NULL},
+	{"matrix", (getter)Bone_getMatrix, (setter)Bone_setMatrix, 
+		"The matrix of the bone", NULL},
+	{"weight", (getter)Bone_getWeight, (setter)Bone_setWeight, 
+		"The weight of the bone in relation to a parented mesh", NULL},
+	{"deform_dist", (getter)Bone_getDeform_dist, (setter)Bone_setDeform_dist, 
+		"The distance at which deformation has effect", NULL},
+	{"subdivisions", (getter)Bone_getSubdivisions, (setter)Bone_setSubdivisions, 
+		"The number of subdivisions (for B-Bones)", NULL},
+	{"options", (getter)Bone_getOptions, (setter)Bone_setOptions, 
+		"The options effective on this bone", NULL},
+	{"parent", (getter)Bone_getParent, (setter)Bone_setParent, 
+		"The parent bone of this bone", NULL},
+	{"children", (getter)Bone_getChildren, (setter)Bone_setChildren, 
+		"The child bones of this bone", NULL},
+	{NULL}
+};
 
-//--------------- BPy_Bone.clearChildren()------------------------
-static PyObject *Bone_clearChildren( BPy_Bone * self )
+//------------------------tp_new
+static PyObject *Bone_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-	Bone *root = NULL;
-	Bone *child = NULL;
-	bArmature *arm = NULL;
-	Bone *bone = NULL;
-	Bone *prev = NULL;
-	Bone *next = NULL;
-	float M_boneObjectspace[4][4];
-	int first;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		return EXPP_incr_ret( Py_None );
-	} else {
-		//use bone datastruct
-		if( self->bone->childbase.first == NULL )
-			return EXPP_incr_ret( Py_None );
-
-		//is this bone a part of an armature....
-		//get root bone for testing
-		root = self->bone->parent;
-		if( root != NULL ) {
-			while( root->parent != NULL ) {
-				root = root->parent;
-			}
-		} else {
-			root = self->bone;
-		}
-		//test armatures for root bone
-		for( arm = G.main->armature.first; arm; arm = arm->id.next ) {
-			for( bone = arm->bonebase.first; bone;
-			     bone = bone->next ) {
-				if( bone == root )
-					break;
-			}
-			if( bone == root )
-				break;
-		}
-
-		if( arm == NULL )
-			return ( EXPP_ReturnPyObjError
-				 ( PyExc_RuntimeError,
-				   "couldn't find armature that contains this bone" ) );
-
-		//now get rid of the parent transformation
-		get_objectspace_bone_matrix( self->bone, M_boneObjectspace, 0,
-					     0 );
-
-		//set children as root
-		first = 1;
-		for( child = self->bone->childbase.first; child; child = next ) {
-			//undo transformation of local bone
-			Mat4MulVecfl( M_boneObjectspace, child->head );
-			Mat4MulVecfl( M_boneObjectspace, child->tail );
-
-			//set next pointers to NULL
-			if( first ) {
-				prev = child;
-				first = 0;
-			} else {
-				prev->next = NULL;
-				prev = child;
-			}
-			next = child->next;
-
-			//remove parenting and linking
-			child->parent = NULL;
-			BLI_remlink( &self->bone->childbase, child );
-
-			//add as root
-			BLI_addtail( &arm->bonebase, child );
-		}
-	}
-	Py_INCREF( Py_None );
-	return Py_None;
+	return EXPP_incr_ret(Py_None);
 }
 
-//--------------- BPy_Bone.hide()-----------------------------------
-static PyObject *Bone_hide( BPy_Bone * self )
+//------------------------tp_richcompare
+//This method allows the object to use comparison operators
+static PyObject *Bone_richcmpr(BPy_Bone *self, PyObject *v, int op)
 {
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "link bone to armature before attempting to hide/unhide" );
-	} else {
-		//use bone datastruct
-		if( !( self->bone->flag & BONE_HIDDEN_P ) )
-			self->bone->flag |= BONE_HIDDEN_P;
-	}
-	return EXPP_incr_ret( Py_None );
+	return EXPP_incr_ret(Py_None);
 }
 
-//--------------- BPy_Bone.unhide()-------------------------------
-static PyObject *Bone_unhide( BPy_Bone * self )
+//------------------------tp_repr
+//This is the string representation of the object
+static PyObject *Bone_repr(BPy_Bone *self)
 {
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "link bone to armature before attempting to hide/unhide" );
-	} else {
-		//use bone datastruct
-		if( self->bone->flag & BONE_HIDDEN_P )
-			self->bone->flag &= ~BONE_HIDDEN_P;
-	}
-	return EXPP_incr_ret( Py_None );
+	return PyString_FromFormat( "[Bone \"%s\"]", self->bone->name ); 
 }
 
-//--------------- BPy_Bone.setPose()-------------------------------
-static PyObject *Bone_setPose( BPy_Bone * self, PyObject * args )
+//------------------------tp_dealloc
+//This tells how to 'tear-down' our object when ref count hits 0
+static void Bone_dealloc(BPy_Bone * self)
 {
-	Bone *root = NULL;
-	bPoseChannel *chan = NULL;
-	bPoseChannel *setChan = NULL;
-	Object *object = NULL;
-	bArmature *arm = NULL;
-	Bone *bone = NULL;
-	PyObject *flaglist = NULL;
-	PyObject *item = NULL;
-	BPy_Action *py_action = NULL;
-	int x;
-	int flagValue = 0;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "cannot set pose unless bone is linked to armature" );
-	} else {
-		//use bone datastruct
-		if( !PyArg_ParseTuple
-		    ( args, "O!|O!", &PyList_Type, &flaglist, &Action_Type,
-		      &py_action ) )
-			return ( EXPP_ReturnPyObjError
-				 ( PyExc_AttributeError,
-				   "expected list of flags and optional action" ) );
-
-		for( x = 0; x < PyList_Size( flaglist ); x++ ) {
-			item = PyList_GetItem( flaglist, x );
-			if( PyInt_Check( item ) ) {
-				flagValue |= PyInt_AsLong( item );
-			} else {
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_AttributeError,
-					   "expected list of flags (ints)" ) );
-			}
-		}
-
-		//is this bone a part of an armature....
-		//get root bone for testing
-		root = self->bone->parent;
-		if( root != NULL ) {
-			while( root->parent != NULL ) {
-				root = root->parent;
-			}
-		} else {
-			root = self->bone;
-		}
-		//test armatures for root bone
-		for( arm = G.main->armature.first; arm; arm = arm->id.next ) {
-			for( bone = arm->bonebase.first; bone;
-			     bone = bone->next ) {
-				if( bone == root )
-					break;
-			}
-			if( bone == root )
-				break;
-		}
-		if( arm == NULL )
-			return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-							"bone must belong to an armature to set it's pose!" ) );
-
-		//find if armature is object linked....
-		for( object = G.main->object.first; object;
-		     object = object->id.next ) {
-			if( object->data == arm ) {
-				break;
-			}
-		}
-
-		if( object == NULL )
-			return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-							"armature must be linked to an object to set a pose!" ) );
-
-		//set the active action as this one
-		if( py_action != NULL ) {
-			if( py_action->action != NULL ) {
-				object->action = py_action->action;
-			}
-		}
-		//if object doesn't have a pose create one
-		if( !object->pose )
-			object->pose = MEM_callocN( sizeof( bPose ), "Pose" );
-
-		//if bone does have a channel create one
-		// do not use anymore! (ton)
-		chan= verify_pose_channel( object->pose, self->bone->name );
-		
-		//create temp Pose Channel
-		 // chan = MEM_callocN( sizeof( bPoseChannel ), "PoseChannel" );
-		//set the variables for this pose
-//		memcpy( chan->loc, self->bone->loc, sizeof( chan->loc ) );
-//		memcpy( chan->quat, self->bone->quat, sizeof( chan->quat ) );
-//		memcpy( chan->size, self->bone->size, sizeof( chan->size ) );
-		strcpy( chan->name, self->bone->name );
-		chan->flag |= flagValue;
-		//set it to the channel
-		// setChan = set_pose_channel( object->pose, chan );
-		//frees unlinked pose/bone channels from object
-/* note; changing an Armature requires building poses again, consult me! (ton) */
-		// collect_pose_garbage( object );
-
-		//create an action if one not already assigned to object
-		if( !py_action && !object->action ) {
-			object->action = ( bAction * ) add_empty_action(ID_PO);
-			object->ipowin = ID_PO;
-		}
-
-		//set action keys (note, new uniform API for Pose ipos (ton)
-		if( setChan->flag & POSE_ROT ) {
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_QUAT_X);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_QUAT_Y);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_QUAT_Z);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_QUAT_W);
-		}
-		if( setChan->flag & POSE_SIZE ) {
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_SIZE_X);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_SIZE_Y);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_SIZE_Z);
-		}
-		if( setChan->flag & POSE_LOC ) {
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_LOC_X);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_LOC_Y);
-			insertkey(&object->id, ID_PO, setChan->name, NULL, AC_LOC_Z);
-		}
-		//rebuild ipos
-		remake_action_ipos( object->action );
-
-		//signal to rebuild displists (new! added by ton)
-		object->recalc |= OB_RECALC_DATA;
-	}
-	return EXPP_incr_ret( Py_None );
+	((PyObject*)self)->ob_type->tp_free((PyObject*)self);
+	return;
 }
 
-//--------------- BPy_Bone.getBoneclass()--------------------------
-static PyObject *Bone_getBoneclass( BPy_Bone * self )
-{
-	PyObject *attr = NULL;
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		attr = returnBoneclassEnum( self->boneclass );
-	} else {
-		//use bone datastruct
-		attr = returnBoneclassEnum( self->bone->boneclass );
-	}
-	if( attr )
-		return attr;
+//------------------------tp_doc
+//The __doc__ string for this object
+static char BPy_Bone_doc[] = "This object wraps a Blender Boneobject.\n\
+					  This object is a subobject of the Armature object.";
 
-	return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-					"couldn't get Bone.Boneclass attribute" ) );
-}
-
-//--------------- BPy_Bone.setBoneclass()---------------------------
-static PyObject *Bone_setBoneclass( BPy_Bone * self, PyObject * args )
+//------------------TYPE_OBECT DEFINITION--------------------------
+PyTypeObject Bone_Type = {
+	PyObject_HEAD_INIT(NULL)       //tp_head
+	0,                             //tp_internal
+	"Bone",                        //tp_name
+	sizeof(BPy_Bone),              //tp_basicsize
+	0,                             //tp_itemsize
+	(destructor)Bone_dealloc,      //tp_dealloc
+	0,                             //tp_print
+	0,                             //tp_getattr
+	0,                             //tp_setattr
+	0,                             //tp_compare
+	(reprfunc) Bone_repr,          //tp_repr
+	0,                             //tp_as_number
+	0,                             //tp_as_sequence
+	0,                             //tp_as_mapping
+	0,                             //tp_hash
+	0,                             //tp_call
+	0,                             //tp_str
+	0,                             //tp_getattro
+	0,                             //tp_setattro
+	0,                             //tp_as_buffer
+	Py_TPFLAGS_DEFAULT,            //tp_flags
+	BPy_Bone_doc,                  //tp_doc
+	0,                             //tp_traverse
+	0,                             //tp_clear
+	(richcmpfunc)Bone_richcmpr,    //tp_richcompare
+	0,                             //tp_weaklistoffset
+	0,                             //tp_iter
+	0,                             //tp_iternext
+	0,                             //tp_methods
+	0,                             //tp_members
+	BPy_Bone_getset,               //tp_getset
+	0,                             //tp_base
+	0,                             //tp_dict
+	0,                             //tp_descr_get
+	0,                             //tp_descr_set
+	0,                             //tp_dictoffset
+	0,                             //tp_init
+	0,                             //tp_alloc
+	(newfunc)Bone_new,             //tp_new
+	0,                             //tp_free
+	0,                             //tp_is_gc
+	0,                             //tp_bases
+	0,                             //tp_mro
+	0,                             //tp_cache
+	0,                             //tp_subclasses
+	0,                             //tp_weaklist
+	0                              //tp_del
+};
+//------------------VISIBLE PROTOTYPE IMPLEMENTATION-----------------------
+//-----------------(internal)
+//Converts a struct Bone to a BPy_Bone
+PyObject *PyBone_FromBone(struct Bone *bone)
 {
-	int boneclass;
-
-	if( !PyArg_ParseTuple( args, "i", &boneclass ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected enum argument" ) );
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		self->boneclass = boneclass;
-	} else {
-		//use bone datastruct
-		self->bone->boneclass = (short)boneclass;
-	}
-	return EXPP_incr_ret( Py_None );
-}
+	BPy_Bone *py_Bone = NULL;
 
-//--------------- BPy_Bone.hasIK()-------------------------------
-static PyObject *Bone_hasIK( BPy_Bone * self )
-{
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		if( self->flag & BONE_CONNECTED ) {
-			return EXPP_incr_ret_True();
-		} else {
-			return EXPP_incr_ret_False();
-		}
-	} else {
-		//use bone datastruct
-		if( self->bone->flag & BONE_CONNECTED ) {
-			return EXPP_incr_ret_True();
-		} else {
-			return EXPP_incr_ret_False();
-		}
-	}
-}
+	py_Bone = (BPy_Bone*)Bone_Type.tp_alloc(&Bone_Type, 0); //*new*
+	if (py_Bone == NULL)
+		goto RuntimeError;
 
-//--------------- BPy_Bone.getRestMatrix()-------------------------
+	py_Bone->bone = bone;
 
-/* we now got BoneSpace, ArmatureSpace, PoseSpace, WorldSpace.
-   check DNA_armature.h, only read from data itself, dont use evil calls
-   that evaluate animation system anymore (ton) */
+	return (PyObject *) py_Bone;
 
-static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args )
+RuntimeError:
+	return EXPP_objError(PyExc_RuntimeError, "%s%s%s", 
+		sBoneError, "PyBone_FromBone: ", "Internal Error Ocurred");
+}
+//-----------------(internal)
+//Converts a PyBone to a bBone
+struct Bone *PyBone_AsBone(BPy_Bone *py_Bone)
 {
-	char *local = "worldspace";
-	char *bonespace = "bonespace";
-	char *worldspace = "worldspace";
-	PyObject *matrix;
-	float delta[3];
-	float root[3];
-	float p_root[3];
-
-	if( !PyArg_ParseTuple( args, "|s", &local ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected string" ) );
-
-	if( !BLI_streq( local, bonespace ) && !BLI_streq( local, worldspace ) )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"expected 'bonespace' or 'worldspace'" ) );
-
-	matrix = newMatrixObject( NULL, 4, 4 , Py_NEW);
-
-	if( !self->bone ) {	//test to see if linked to armature
-		//use python vars
-		if( BLI_streq( local, worldspace ) ) {
-			VecSubf( delta, self->tail->vec, self->head->vec );
-//			make_boneMatrixvr( (float ( * )[4]) *( ( MatrixObject * ) matrix )->
-//					   matrix, delta, self->roll );
-		} else if( BLI_streq( local, bonespace ) ) {
-			return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-							"bone not yet linked to an armature....'" ) );
-		}
-	} else {
-		//use bone datastruct
-		if( BLI_streq( local, worldspace ) ) {
-			get_objectspace_bone_matrix( self->bone,
-						    ( float ( * )[4] ) *( ( MatrixObject * )
-							matrix )->matrix, 1,
-						     1 );
-		} else if( BLI_streq( local, bonespace ) ) {
-			VecSubf( delta, self->bone->tail, self->bone->head );
-//			make_boneMatrixvr( (float ( * )[4]) *( ( MatrixObject * ) matrix )->
-//					   matrix, delta, self->bone->roll );
-			if( self->bone->parent ) {
-				
-//				get_bone_root_pos( self->bone, root, 1 );
-//				get_bone_root_pos( self->bone->parent, p_root,
-//						   1 );
-				VecSubf( delta, root, p_root );
-				VECCOPY( ( ( MatrixObject * ) matrix )->
-					 matrix[3], delta );
-			}
-		}
-	}
-
-	return matrix;
+	return (py_Bone->bone);
 }