- parenting checks for bone additions to armature
[blender.git] / source / blender / python / api2_2x / Bone.c
1 /* 
2  *
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA        02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * This is a new part of Blender.
26  *
27  * Contributor(s): Jordi Rovira i Bonet, Joseph Gilbert
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30 */
31
32 #include "Bone.h"
33
34 #include <BKE_main.h>
35 #include <BKE_global.h>
36 #include <BKE_object.h>
37 #include <BKE_armature.h>
38 #include <BKE_library.h>
39 #include <MEM_guardedalloc.h>
40 #include <BLI_blenlib.h>
41
42 #include "constant.h"
43 #include "gen_utils.h"
44 #include "modules.h"
45 #include "quat.h"
46
47
48 /*****************************************************************************/
49 /* Python API function prototypes for the Bone module.                   */
50 /*****************************************************************************/
51 static PyObject *M_Bone_New (PyObject * self, PyObject * args,
52                              PyObject * keywords);
53
54
55 /*****************************************************************************/
56 /* The following string definitions are used for documentation strings.          */
57 /* In Python these will be written to the console when doing a           */
58 /* Blender.Armature.Bone.__doc__                                         */
59 /*****************************************************************************/
60 char M_Bone_doc[] = "The Blender Bone module\n\n\
61 This module provides control over **Bone Data** objects in Blender.\n\n\
62 Example::\n\n\
63         from Blender import Armature.Bone\n\
64         l = Armature.Bone.New()\n";
65
66 char M_Bone_New_doc[] = "(name) - return a new Bone of name 'name'.";
67
68
69 /*****************************************************************************/
70 /* Python method structure definition for Blender.Armature.Bone module:                  */
71 /*****************************************************************************/
72 struct PyMethodDef M_Bone_methods[] = {
73   {"New", (PyCFunction) M_Bone_New, METH_VARARGS | METH_KEYWORDS,
74    M_Bone_New_doc},
75   {NULL, NULL, 0, NULL}
76 };
77
78 /*****************************************************************************/
79 /* Python BPy_Bone methods declarations:                                                                                                                                                 */
80 /*****************************************************************************/
81 static PyObject *Bone_getName (BPy_Bone * self);
82 static PyObject *Bone_getRoll (BPy_Bone * self);
83 static PyObject *Bone_getHead (BPy_Bone * self);
84 static PyObject *Bone_getTail (BPy_Bone * self);
85 static PyObject *Bone_getLoc (BPy_Bone * self);
86 static PyObject *Bone_getSize (BPy_Bone * self);
87 static PyObject *Bone_getQuat (BPy_Bone * self);
88 static PyObject *Bone_getParent (BPy_Bone * self);
89 static PyObject *Bone_hasParent (BPy_Bone * self);
90 static PyObject *Bone_getWeight (BPy_Bone * self);
91 static PyObject *Bone_getChildren (BPy_Bone * self);
92 static PyObject *Bone_clearParent (BPy_Bone * self);
93 static PyObject *Bone_clearChildren (BPy_Bone * self);
94 static PyObject *Bone_hide (BPy_Bone * self);
95 static PyObject *Bone_unhide (BPy_Bone * self);
96 static PyObject *Bone_setName (BPy_Bone * self, PyObject * args);
97 static PyObject *Bone_setRoll (BPy_Bone * self, PyObject * args);
98 static PyObject *Bone_setHead (BPy_Bone * self, PyObject * args);
99 static PyObject *Bone_setTail (BPy_Bone * self, PyObject * args);
100 static PyObject *Bone_setLoc (BPy_Bone * self, PyObject * args);
101 static PyObject *Bone_setSize (BPy_Bone * self, PyObject * args);
102 static PyObject *Bone_setQuat (BPy_Bone * self, PyObject * args);
103 static PyObject *Bone_setParent(BPy_Bone *self, PyObject *args);
104 static PyObject *Bone_setWeight(BPy_Bone *self, PyObject *args);
105
106 /*****************************************************************************/
107 /* Python BPy_Bone methods table:                                        */
108 /*****************************************************************************/
109 static PyMethodDef BPy_Bone_methods[] = {
110   /* name, method, flags, doc */
111   {"getName", (PyCFunction) Bone_getName, METH_NOARGS,
112    "() - return Bone name"},
113   {"getRoll", (PyCFunction) Bone_getRoll, METH_NOARGS,
114    "() - return Bone roll"},
115   {"getHead", (PyCFunction) Bone_getHead, METH_NOARGS,
116    "() - return Bone head"},
117   {"getTail", (PyCFunction) Bone_getTail, METH_NOARGS,
118    "() - return Bone tail"},
119   {"getLoc", (PyCFunction) Bone_getLoc, METH_NOARGS, "() - return Bone loc"},
120   {"getSize", (PyCFunction) Bone_getSize, METH_NOARGS,
121    "() - return Bone size"},
122   {"getQuat", (PyCFunction) Bone_getQuat, METH_NOARGS,
123    "() - return Bone quat"},
124   {"hide", (PyCFunction) Bone_hide, METH_NOARGS,
125    "() - hides the bone"},
126   {"unhide", (PyCFunction) Bone_unhide, METH_NOARGS,
127    "() - unhides the bone"},
128   {"getWeight", (PyCFunction) Bone_getWeight, METH_NOARGS,
129    "() - return Bone weight"},
130   {"getParent", (PyCFunction) Bone_getParent, METH_NOARGS,
131    "() - return the parent bone of this one if it exists."
132    " None if not found. You can check this condition with the "
133    "hasParent() method."},
134   {"hasParent", (PyCFunction) Bone_hasParent, METH_NOARGS,
135    "() - return true if bone has a parent"},
136   {"getChildren", (PyCFunction) Bone_getChildren, METH_NOARGS,
137    "() - return Bone children list"},
138   {"clearParent", (PyCFunction) Bone_clearParent, METH_NOARGS,
139    "() - clears the bone's parent in the armature and makes it root"},
140   {"clearChildren", (PyCFunction) Bone_clearChildren, METH_NOARGS,
141    "() - remove the children associated with this bone"},
142   {"setName", (PyCFunction) Bone_setName, METH_VARARGS,
143    "(str) - rename Bone"},
144   {"setRoll", (PyCFunction) Bone_setRoll, METH_VARARGS,
145    "(float) - set Bone roll"},
146   {"setHead", (PyCFunction) Bone_setHead, METH_VARARGS,
147    "(float,float,float) - set Bone head pos"},
148   {"setTail", (PyCFunction) Bone_setTail, METH_VARARGS,
149    "(float,float,float) - set Bone tail pos"},
150   {"setLoc", (PyCFunction) Bone_setLoc, METH_VARARGS,
151    "(float,float,float) - set Bone loc"},
152   {"setSize", (PyCFunction) Bone_setSize, METH_VARARGS,
153    "(float,float,float) - set Bone size"},
154   {"setQuat", (PyCFunction) Bone_setQuat, METH_VARARGS,
155    "(float,float,float,float) - set Bone quat"},
156   {"setParent", (PyCFunction)Bone_setParent, METH_VARARGS,  
157    "() - set the Bone parent of this one."},
158   {"setWeight", (PyCFunction)Bone_setWeight, METH_VARARGS,  
159    "() - set the Bone weight."},
160   {NULL, NULL, 0, NULL}
161 };
162
163 /*****************************************************************************/
164 /* Python TypeBone callback function prototypes:                                 */
165 /*****************************************************************************/
166 static void Bone_dealloc (BPy_Bone * bone);
167 static PyObject *Bone_getAttr (BPy_Bone * bone, char *name);
168 static int Bone_setAttr (BPy_Bone * bone, char *name, PyObject * v);
169 static int Bone_compare (BPy_Bone * a1, BPy_Bone * a2);
170 static PyObject *Bone_repr (BPy_Bone * bone);
171
172 /*****************************************************************************/
173 /* Python TypeBone structure definition:                                 */
174 /*****************************************************************************/
175 PyTypeObject Bone_Type = {
176   PyObject_HEAD_INIT (NULL) 0,  /* ob_size */
177   "Blender Bone",               /* tp_name */
178   sizeof (BPy_Bone),            /* tp_basicsize */
179   0,                            /* tp_itemsize */
180   /* methods */
181   (destructor) Bone_dealloc,    /* tp_dealloc */
182   0,                            /* tp_print */
183   (getattrfunc) Bone_getAttr,   /* tp_getattr */
184   (setattrfunc) Bone_setAttr,   /* tp_setattr */
185   (cmpfunc) Bone_compare,       /* tp_compare */
186   (reprfunc) Bone_repr,         /* tp_repr */
187   0,                            /* tp_as_number */
188   0,                            /* tp_as_sequence */
189   0,                            /* tp_as_mapping */
190   0,                            /* tp_as_hash */
191   0, 0, 0, 0, 0, 0,
192   0,                            /* tp_doc */
193   0, 0, 0, 0, 0, 0,
194   BPy_Bone_methods,             /* tp_methods */
195   0,                            /* tp_members */
196 };
197
198
199 /*****************************************************************************/
200 /* Function:    M_Bone_New                                               */
201 /* Python equivalent:   Blender.Armature.Bone.New                        */
202 /*****************************************************************************/
203
204 static PyObject *
205 M_Bone_New (PyObject * self, PyObject * args, PyObject * keywords)
206 {
207   char *name_str = "BoneName";
208   BPy_Bone *py_bone = NULL;     /* for Bone Data object wrapper in Python */
209   Bone *bl_bone = NULL;         /* for actual Bone Data we create in Blender */
210
211   if (!PyArg_ParseTuple (args, "|s", &name_str))
212     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
213                                    "expected string or empty argument"));
214
215   /*  Create the C structure for the newq bone */
216   bl_bone = (Bone *) MEM_callocN(sizeof (Bone), "bone");
217   strncpy (bl_bone->name, name_str, sizeof (bl_bone->name));
218
219   bl_bone->dist=1.0;
220   bl_bone->weight=1.0;
221   bl_bone->flag=32;
222   bl_bone->parent = NULL;
223   bl_bone->roll = 0.0;
224   bl_bone->boneclass = BONE_SKINNABLE;
225
226   // now create the wrapper obj in Python
227   if (bl_bone)                          
228     py_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type);
229   else
230     return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
231                                    "couldn't create Bone Data in Blender"));
232
233   if (py_bone == NULL)
234     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
235                                    "couldn't create Bone Data object"));
236
237   py_bone->bone = bl_bone;      // link Python bone wrapper with Blender Bone
238  
239   Py_INCREF(py_bone);
240   return (PyObject *) py_bone;
241 }
242
243
244 /*****************************************************************************/
245 /* Function:    Bone_Init                                                */
246 /*****************************************************************************/
247 PyObject *
248 Bone_Init (void)
249 {
250   PyObject *submodule;
251
252   Bone_Type.ob_type = &PyType_Type;
253
254   submodule = Py_InitModule3 ("Blender.Armature.Bone",
255                               M_Bone_methods, M_Bone_doc);
256
257   return (submodule);
258 }
259
260 /*****************************************************************************/
261 /* Python BPy_Bone methods:                                              */
262 /*****************************************************************************/
263 static PyObject *
264 Bone_getName (BPy_Bone * self)
265 {
266   PyObject *attr = NULL;
267
268   if (!self->bone)
269     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
270                             "couldn't get attribute from a NULL bone"));
271
272   attr = PyString_FromString (self->bone->name);
273
274   if (attr)
275     return attr;
276
277   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
278                                  "couldn't get Bone.name attribute"));
279 }
280
281
282 static PyObject *
283 Bone_getRoll (BPy_Bone * self)
284 {
285   PyObject *attr = NULL;
286
287   if (!self->bone)
288     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
289                             "couldn't get attribute from a NULL bone"));
290
291   attr = Py_BuildValue ("f", self->bone->roll);
292
293   if (attr)
294     return attr;
295
296   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
297                                  "couldn't get Bone.roll attribute"));
298 }
299
300 static PyObject *
301 Bone_getWeight (BPy_Bone * self)
302 {
303   PyObject *attr = NULL;
304
305   if (!self->bone)
306     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
307                             "couldn't get attribute from a NULL bone"));
308
309   attr = Py_BuildValue ("f", self->bone->weight);
310
311   if (attr)
312     return attr;
313
314   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
315                                  "couldn't get Bone.weight attribute"));
316 }
317
318 static PyObject *
319 Bone_getHead (BPy_Bone * self)
320 {
321   PyObject *attr = NULL;
322
323   if (!self->bone)
324     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
325                             "couldn't get attribute from a NULL bone"));
326
327   attr = Py_BuildValue ("[fff]", self->bone->head[0], self->bone->head[1],
328                         self->bone->head[2]);
329
330   if (attr)
331     return attr;
332
333   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
334                                  "couldn't get Bone.head attribute"));
335 }
336
337
338 static PyObject *
339 Bone_getTail (BPy_Bone * self)
340 {
341   PyObject *attr = NULL;
342
343   if (!self->bone)
344     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
345                             "couldn't get attribute from a NULL bone"));
346
347   attr = Py_BuildValue ("[fff]", self->bone->tail[0], self->bone->tail[1],
348                         self->bone->tail[2]);
349
350   if (attr)
351     return attr;
352
353   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
354                                  "couldn't get Bone.tail attribute"));
355 }
356
357
358 static PyObject *
359 Bone_getLoc (BPy_Bone * self)
360 {
361   PyObject *attr = NULL;
362
363   if (!self->bone)
364     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
365                             "couldn't get attribute from a NULL bone"));
366
367   attr = Py_BuildValue ("[fff]", self->bone->loc[0], self->bone->loc[1],
368                         self->bone->loc[2]);
369
370   if (attr)
371     return attr;
372
373   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
374                                  "couldn't get Bone.loc attribute"));
375 }
376
377
378 static PyObject *
379 Bone_getSize (BPy_Bone * self)
380 {
381   PyObject *attr = NULL;
382
383   if (!self->bone)
384     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
385                             "couldn't get attribute from a NULL bone"));
386
387   attr = Py_BuildValue ("[fff]", self->bone->size[0], self->bone->size[1],
388                         self->bone->size[2]);
389
390   if (attr)
391     return attr;
392
393   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
394                                  "couldn't get Bone.size attribute"));
395 }
396
397
398 static PyObject *
399 Bone_getQuat (BPy_Bone * self)
400 {
401   float *quat;
402
403   if (!self->bone)
404     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
405                             "couldn't get attribute from a NULL bone"));
406
407   quat = PyMem_Malloc (4*sizeof (float));
408   quat[0] = self->bone->quat[0];
409   quat[1] = self->bone->quat[1];
410   quat[2] = self->bone->quat[2];
411   quat[3] = self->bone->quat[3];
412
413   return (PyObject*)newQuaternionObject(quat);
414 }
415
416 static PyObject *
417 Bone_hasParent (BPy_Bone * self)
418 {
419
420   if (!self->bone)
421     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
422                             "couldn't get attribute from a NULL bone"));
423
424   /*
425      return Bone_CreatePyObject(self->bone->parent);
426    */
427   if (self->bone->parent)
428     {
429       Py_INCREF (Py_True);
430       return Py_True;
431     }
432   else
433     {
434       Py_INCREF (Py_False);
435       return Py_False;
436     }
437
438 }
439
440
441 static PyObject *
442 Bone_getParent (BPy_Bone * self)
443 {
444
445   if (!self->bone)
446     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
447                             "couldn't get attribute from a NULL bone"));
448
449   if (self->bone->parent)
450     return Bone_CreatePyObject (self->bone->parent);
451   else                          /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
452                                    "couldn't get parent bone, because bone hasn't got a parent.")); */
453     {
454       Py_INCREF (Py_None);
455       return Py_None;
456     }
457
458 }
459
460
461 static PyObject *
462 Bone_getChildren (BPy_Bone * self)
463 {
464   int totbones = 0;
465   Bone *current = NULL;
466   PyObject *listbones = NULL;
467   int i;
468
469   if (!self->bone)
470     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
471                             "couldn't get attribute from a NULL bone"));
472
473   /* Count the number of bones to create the list */
474   current = self->bone->childbase.first;
475   for (; current; current = current->next)
476     totbones++;
477
478   /* Create a list with a bone wrapper for each bone */
479   current = self->bone->childbase.first;
480   listbones = PyList_New (totbones);
481   for (i = 0; i < totbones; i++)
482     {
483       assert (current);
484       PyList_SetItem (listbones, i, Bone_CreatePyObject (current));
485       current = current->next;
486     }
487
488   return listbones;
489 }
490
491
492 static PyObject *
493 Bone_setName (BPy_Bone * self, PyObject * args)
494 {
495   char *name;
496
497   if (!self->bone)
498     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
499                             "couldn't get attribute from a NULL bone"));
500
501   if (!PyArg_ParseTuple (args, "s", &name))
502     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
503                                    "expected string argument"));
504
505   PyOS_snprintf (self->bone->name, sizeof (self->bone->name), "%s", name);
506
507   Py_INCREF (Py_None);
508   return Py_None;
509 }
510
511
512 PyObject *
513 Bone_setRoll (BPy_Bone * self, PyObject * args)
514 {
515   float roll;
516
517   if (!self->bone)
518     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
519                             "couldn't get attribute from a NULL bone"));
520
521   if (!PyArg_ParseTuple (args, "f", &roll))
522     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
523                                    "expected float argument"));
524
525   self->bone->roll = roll;
526
527   Py_INCREF (Py_None);
528   return Py_None;
529 }
530
531 static PyObject *
532 Bone_setHead (BPy_Bone * self, PyObject * args)
533 {
534   float f1, f2, f3;
535   int status;
536
537   if (!self->bone)
538     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
539                             "couldn't get attribute from a NULL bone"));
540
541   if (PyObject_Length (args) == 3)
542     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
543   else
544     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
545
546   if (!status)
547     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
548                                    "expected 3 (or a list of 3) float arguments"));
549
550   self->bone->head[0] = f1;
551   self->bone->head[1] = f2;
552   self->bone->head[2] = f3;
553
554   Py_INCREF (Py_None);
555   return Py_None;
556 }
557
558
559 static PyObject *
560 Bone_setTail (BPy_Bone * self, PyObject * args)
561 {
562   float f1, f2, f3;
563   int status;
564
565   if (!self->bone)
566     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
567                             "couldn't get attribute from a NULL bone"));
568
569   if (PyObject_Length (args) == 3)
570     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
571   else
572     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
573
574   if (!status)
575     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
576                                    "expected 3 (or a list of 3) float arguments"));
577
578   self->bone->tail[0] = f1;
579   self->bone->tail[1] = f2;
580   self->bone->tail[2] = f3;
581
582   Py_INCREF (Py_None);
583   return Py_None;
584 }
585
586
587 static PyObject *
588 Bone_setLoc (BPy_Bone * self, PyObject * args)
589 {
590   float f1, f2, f3;
591   int status;
592
593   if (!self->bone)
594     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
595                             "couldn't get attribute from a NULL bone"));
596
597   if (PyObject_Length (args) == 3)
598     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
599   else
600     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
601
602   if (!status)
603     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
604                                    "expected 3 (or a list of 3) float arguments"));
605
606   self->bone->loc[0] = f1;
607   self->bone->loc[1] = f2;
608   self->bone->loc[2] = f3;
609
610   Py_INCREF (Py_None);
611   return Py_None;
612 }
613
614
615 static PyObject *
616 Bone_setSize (BPy_Bone * self, PyObject * args)
617 {
618   float f1, f2, f3;
619   int status;
620
621   if (!self->bone)
622     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
623                             "couldn't get attribute from a NULL bone"));
624
625   if (PyObject_Length (args) == 3)
626     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
627   else
628     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
629
630   if (!status)
631     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
632                                    "expected 3 (or a list of 3) float arguments"));
633
634   self->bone->size[0] = f1;
635   self->bone->size[1] = f2;
636   self->bone->size[2] = f3;
637
638   Py_INCREF (Py_None);
639   return Py_None;
640 }
641
642
643 static PyObject *
644 Bone_setQuat (BPy_Bone * self, PyObject * args)
645 {
646   float f1, f2, f3, f4;
647   PyObject *argument;
648   QuaternionObject *quatOb;
649   int status;
650
651   if (!self->bone)
652     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
653                             "couldn't get attribute from a NULL bone"));
654
655    if (!PyArg_ParseTuple(args, "O", &argument))
656         return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected quaternion or float list"));
657
658    if(QuaternionObject_Check(argument)){
659                 status = PyArg_ParseTuple(args, "O!", &quaternion_Type, &quatOb);
660                 f1 = quatOb->quat[0];
661                 f2 = quatOb->quat[1];
662                 f3 = quatOb->quat[2];
663                 f4 = quatOb->quat[3];
664    }else{
665                 status = PyArg_ParseTuple (args, "(ffff)", &f1, &f2, &f3, &f4);
666    }
667
668   if (!status)
669     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
670                                    "unable to parse argument"));
671
672   self->bone->quat[0] = f1;
673   self->bone->quat[1] = f2;
674   self->bone->quat[2] = f3;
675   self->bone->quat[3] = f4;
676
677   Py_INCREF (Py_None);
678   return Py_None;
679 }
680
681 static int
682 testChildbase(Bone *bone, Bone *test)
683 {
684         Bone *child;
685
686         for(child = bone->childbase.first; child; child = child->next){
687                 if(child == test){
688                         return 1;
689                 }
690                 if(child->childbase.first != NULL)
691                         testChildbase(child, test);
692         }
693
694         return 0;
695 }
696
697 static PyObject *
698 Bone_setParent(BPy_Bone *self, PyObject *args)
699 {
700   BPy_Bone* py_bone;
701
702   if (!self->bone) 
703           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
704
705   if (!PyArg_ParseTuple(args, "O", &py_bone))
706         return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected bone object argument"));
707
708   if(!py_bone->bone)
709         return (EXPP_ReturnPyObjError (PyExc_TypeError, "bone contains no data!"));
710
711   if(py_bone->bone == self->bone)
712           return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to self"));
713
714   //test to see if were creating an illegal loop by parenting to child
715   if(testChildbase(self->bone, py_bone->bone))
716           return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to child"));
717
718   //set the parent of self
719   self->bone->parent = py_bone->bone;
720
721   Py_INCREF(Py_None);
722   return Py_None;
723 }
724
725 static PyObject *
726 Bone_setWeight(BPy_Bone *self, PyObject *args)
727 {
728   float weight;
729
730   if (!self->bone)
731     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
732                             "couldn't get attribute from a NULL bone"));
733
734   if (!PyArg_ParseTuple (args, "f", &weight))
735     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
736                                    "expected float argument"));
737
738   self->bone->weight = weight;
739
740   Py_INCREF (Py_None);
741   return Py_None;
742 }
743
744 static PyObject *
745 Bone_clearParent(BPy_Bone *self)
746 {
747   bArmature *arm = NULL;
748   Bone *bone = NULL;
749   Bone *parent = NULL;
750   Bone *child = NULL;
751   Bone *childPrev = NULL;
752   int firstChild;
753   float M_boneObjectspace[4][4];
754
755   if (!self->bone) 
756           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
757
758   if(self->bone->parent == NULL)
759           return EXPP_incr_ret(Py_None);
760
761   //get parent and remove link
762   parent = self->bone->parent;
763   self->bone->parent = NULL;
764
765   //remove the childbase link from the parent bone
766   firstChild = 1;
767   for(child = parent->childbase.first; child; child = child->next){     
768           if(child == self->bone && firstChild){
769                         parent->childbase.first = child->next;
770                         child->next = NULL;
771                         break;
772           }
773           if(child == self->bone && !firstChild){
774                   childPrev->next = child->next;
775                   child->next = NULL;
776                   break;
777           }
778           firstChild = 0;
779           childPrev = child;
780   }
781
782   //now get rid of the parent transformation
783   get_objectspace_bone_matrix(parent, M_boneObjectspace, 0,0);
784
785   //transformation of local bone
786   Mat4MulVecfl(M_boneObjectspace, self->bone->head);
787   Mat4MulVecfl(M_boneObjectspace, self->bone->tail);
788
789
790   //get the root bone
791   while(parent->parent != NULL){
792           parent = parent->parent;
793   }
794
795   //add unlinked bone to the bonebase of the armature
796   for (arm = G.main->armature.first; arm; arm= arm->id.next) {
797           for(bone = arm->bonebase.first; bone; bone = bone->next){
798                   if(parent == bone){
799                           //we found the correct armature - now add it as root bone
800                           BLI_addtail (&arm->bonebase, self->bone);
801                           break;
802                   }
803           }                     
804   }
805   
806   Py_INCREF(Py_None);
807   return Py_None;
808 }
809
810 static PyObject *
811 Bone_clearChildren(BPy_Bone *self)
812
813   Bone *child = NULL;
814   bArmature *arm = NULL;
815   Bone *bone = NULL;
816   Bone *parent = NULL;
817   Bone *prev = NULL;
818   Bone *next = NULL;
819   float M_boneObjectspace[4][4];
820   int first;
821
822   if (!self->bone) 
823           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
824
825   if(self->bone->childbase.first == NULL)
826           return EXPP_incr_ret(Py_None);
827
828   //get the root bone
829   parent = bone->parent;
830
831   if(parent != NULL){
832           while(parent->parent != NULL){
833                   parent = parent->parent;
834           }
835   }else{
836           parent = bone;
837   }
838
839   //get the armature
840   for (arm = G.main->armature.first; arm; arm = arm->id.next) {
841           for(bone = arm->bonebase.first; bone; bone = bone->next){
842                   if(parent == bone){
843                           //we found the correct armature          
844                           goto gotArmature;
845                   }
846           }                     
847   }
848
849 gotArmature:
850
851   if(arm == NULL)
852          (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't find armature that contains this bone"));
853
854   //now get rid of the parent transformation
855   get_objectspace_bone_matrix(self->bone, M_boneObjectspace, 0,0);
856
857   //set children as root
858   first = 1;
859   for(child = self->bone->childbase.first; child; child = next){
860       //undo transformation of local bone
861       Mat4MulVecfl(M_boneObjectspace, child->head);
862           Mat4MulVecfl(M_boneObjectspace, child->tail);
863
864           //set next pointers to NULL
865           if(first){
866                 prev = child;
867                 first = 0;
868           }else{
869                 prev->next = NULL;
870             prev = child;
871           }
872           next = child->next;
873
874           //remove parenting and linking
875           child->parent = NULL;
876           BLI_remlink(&self->bone->childbase, child);
877
878           //add as root
879           BLI_addtail (&arm->bonebase, child);
880   }
881
882   Py_INCREF(Py_None);
883   return Py_None;
884
885 }
886
887 static PyObject *
888 Bone_hide(BPy_Bone *self)
889 {
890   if (!self->bone) 
891           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
892
893   if(!(self->bone->flag & BONE_HIDDEN))
894         self->bone->flag |= BONE_HIDDEN;
895
896   Py_INCREF(Py_None);
897   return Py_None;
898 }
899
900
901 static PyObject *
902 Bone_unhide(BPy_Bone *self)
903 {
904   if (!self->bone) 
905           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
906
907   if(self->bone->flag & BONE_HIDDEN)
908         self->bone->flag &= ~BONE_HIDDEN;
909
910   Py_INCREF(Py_None);
911   return Py_None;
912 }
913
914
915
916 /*****************************************************************************/
917 /* Function:    Bone_dealloc                                                                                            */
918 /* Description: This is a callback function for the BPy_Bone type. It is     */
919 /*              the destructor function.                                                                                        */
920 /*****************************************************************************/
921 static void
922 Bone_dealloc (BPy_Bone * self)
923 {
924         MEM_freeN(self->bone);
925     PyObject_DEL (self);
926 }
927
928 /*****************************************************************************/
929 /* Function:    Bone_getAttr                                                                                            */
930 /* Description: This is a callback function for the BPy_Bone type. It is    */
931 /*              the function that accesses BPy_Bone member variables and         */
932 /*              methods.                                                         */
933 /*****************************************************************************/
934 static PyObject *
935 Bone_getAttr (BPy_Bone * self, char *name)
936 {
937   PyObject *attr = Py_None;
938
939   if (strcmp (name, "name") == 0)
940     attr = Bone_getName (self);
941   else if (strcmp (name, "roll") == 0)
942     attr = Bone_getRoll (self);
943   else if (strcmp (name, "head") == 0)
944     attr = Bone_getHead (self);
945   else if (strcmp (name, "tail") == 0)
946     attr = Bone_getTail (self);
947   else if (strcmp (name, "size") == 0)
948     attr = Bone_getSize (self);
949   else if (strcmp (name, "loc") == 0)
950     attr = Bone_getLoc (self);
951   else if (strcmp (name, "quat") == 0)
952     attr = Bone_getQuat (self);
953   else if (strcmp (name, "parent") == 0)
954     /*  Skip the checks for Py_None as its a valid result to this call. */
955     return Bone_getParent (self);
956   else if (strcmp (name, "children") == 0)
957     attr = Bone_getChildren (self);
958   else if (strcmp (name, "weight") == 0)
959     attr = Bone_getWeight (self);
960   else if (strcmp (name, "__members__") == 0)
961     {
962       /* 9 entries */
963       attr = Py_BuildValue ("[s,s,s,s,s,s,s,s,s]",
964                             "name", "roll", "head", "tail", "loc", "size",
965                             "quat", "parent", "children", "weight");
966     }
967
968   if (!attr)
969     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
970                                    "couldn't create PyObject"));
971
972   if (attr != Py_None)
973     return attr;                /* member attribute found, return it */
974
975   /* not an attribute, search the methods table */
976   return Py_FindMethod (BPy_Bone_methods, (PyObject *) self, name);
977 }
978
979 /*****************************************************************************/
980 /* Function:            Bone_setAttr                                                                                    */
981 /* Description: This is a callback function for the BPy_Bone type. It is the */
982 /*              function that changes Bone Data members values. If this      */
983 /*              data is linked to a Blender Bone, it also gets updated.      */
984 /*****************************************************************************/
985 static int
986 Bone_setAttr (BPy_Bone * self, char *name, PyObject * value)
987 {
988   PyObject *valtuple;
989   PyObject *error = NULL;
990
991   valtuple = Py_BuildValue ("(O)", value);      /* the set* functions expect a tuple */
992
993   if (!valtuple)
994     return EXPP_ReturnIntError (PyExc_MemoryError,
995                                 "BoneSetAttr: couldn't create tuple");
996
997   if (strcmp (name, "name") == 0)
998     error = Bone_setName (self, valtuple);
999   else
1000     {                           /* Error */
1001       Py_DECREF (valtuple);
1002
1003       /* ... member with the given name was found */
1004       return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found"));
1005     }
1006
1007   Py_DECREF (valtuple);
1008
1009   if (error != Py_None)
1010     return -1;
1011
1012   Py_DECREF (Py_None);          /* was incref'ed by the called Bone_set* function */
1013   return 0;                     /* normal exit */
1014 }
1015
1016 /*****************************************************************************/
1017 /* Function:    Bone_repr                                                                                                       */
1018 /* Description: This is a callback function for the BPy_Bone type. It    */
1019 /*              builds a meaninful string to represent bone objects.     */
1020 /*****************************************************************************/
1021 static PyObject *
1022 Bone_repr (BPy_Bone * self)
1023 {
1024   if (self->bone)
1025     return PyString_FromFormat ("[Bone \"%s\"]", self->bone->name);
1026   else
1027     return PyString_FromString ("NULL");
1028 }
1029
1030 /**************************************************************************/
1031 /* Function:    Bone_compare                                                                                    */
1032 /* Description: This is a callback function for the BPy_Bone type. It   */
1033 /*              compares the two bones: translate comparison to the     */
1034 /*              C pointers.                                                                                                             */
1035 /**************************************************************************/
1036 static int
1037 Bone_compare (BPy_Bone * a, BPy_Bone * b)
1038 {
1039   Bone *pa = a->bone, *pb = b->bone;
1040   return (pa == pb) ? 0 : -1;
1041 }
1042
1043 /*****************************************************************************/
1044 /* Function:    Bone_CreatePyObject                                                                             */
1045 /* Description: This function will create a new BlenBone from an existing    */
1046 /*              Bone structure.                                                                                                         */
1047 /*****************************************************************************/
1048 PyObject *
1049 Bone_CreatePyObject (struct Bone * obj)
1050 {
1051   BPy_Bone *blen_bone;
1052
1053   blen_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type);
1054
1055   if (blen_bone == NULL)
1056     {
1057       return (NULL);
1058     }
1059   blen_bone->bone = obj;
1060   return ((PyObject *) blen_bone);
1061 }
1062
1063 /*****************************************************************************/
1064 /* Function:    Bone_CheckPyObject                                                                                      */
1065 /* Description: This function returns true when the given PyObject is of the */
1066 /*              type Bone. Otherwise it will return false.                                                      */
1067 /*****************************************************************************/
1068 int
1069 Bone_CheckPyObject (PyObject * py_obj)
1070 {
1071   return (py_obj->ob_type == &Bone_Type);
1072 }
1073
1074 /*****************************************************************************/
1075 /* Function:    Bone_FromPyObject                                                                                       */
1076 /* Description: This function returns the Blender bone from the given    */
1077 /*              PyObject.                                                                                                               */
1078 /*****************************************************************************/
1079 struct Bone *
1080 Bone_FromPyObject (PyObject * py_obj)
1081 {
1082   BPy_Bone *blen_obj;
1083
1084   blen_obj = (BPy_Bone *) py_obj;
1085   return (blen_obj->bone);
1086 }