-NLA module added
[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 #include <DNA_action_types.h>
42 #include <BIF_poseobject.h>
43 #include <BKE_action.h>
44 #include <BSE_editaction.h>
45 #include <BKE_constraint.h>
46
47 #include "constant.h"
48 #include "gen_utils.h"
49 #include "modules.h"
50 #include "quat.h"
51 #include "NLA.h"
52
53 /*****************************************************************************/
54 /* Python API function prototypes for the Bone module.                   */
55 /*****************************************************************************/
56 static PyObject *M_Bone_New (PyObject * self, PyObject * args,
57                              PyObject * keywords);
58
59
60 /*****************************************************************************/
61 /* The following string definitions are used for documentation strings.          */
62 /* In Python these will be written to the console when doing a           */
63 /* Blender.Armature.Bone.__doc__                                         */
64 /*****************************************************************************/
65 char M_Bone_doc[] = "The Blender Bone module\n\n\
66 This module provides control over **Bone Data** objects in Blender.\n\n\
67 Example::\n\n\
68         from Blender import Armature.Bone\n\
69         l = Armature.Bone.New()\n";
70
71 char M_Bone_New_doc[] = "(name) - return a new Bone of name 'name'.";
72
73
74 /*****************************************************************************/
75 /* Python method structure definition for Blender.Armature.Bone module:                  */
76 /*****************************************************************************/
77 struct PyMethodDef M_Bone_methods[] = {
78   {"New", (PyCFunction) M_Bone_New, METH_VARARGS | METH_KEYWORDS,
79    M_Bone_New_doc},
80   {NULL, NULL, 0, NULL}
81 };
82
83 /*****************************************************************************/
84 /* Python BPy_Bone methods declarations:                                                                                                                                                 */
85 /*****************************************************************************/
86 static PyObject *Bone_getName (BPy_Bone * self);
87 static PyObject *Bone_getRoll (BPy_Bone * self);
88 static PyObject *Bone_getHead (BPy_Bone * self);
89 static PyObject *Bone_getTail (BPy_Bone * self);
90 static PyObject *Bone_getLoc (BPy_Bone * self);
91 static PyObject *Bone_getSize (BPy_Bone * self);
92 static PyObject *Bone_getQuat (BPy_Bone * self);
93 static PyObject *Bone_getParent (BPy_Bone * self);
94 static PyObject *Bone_hasParent (BPy_Bone * self);
95 static PyObject *Bone_getWeight (BPy_Bone * self);
96 static PyObject *Bone_getChildren (BPy_Bone * self);
97 static PyObject *Bone_clearParent (BPy_Bone * self);
98 static PyObject *Bone_clearChildren (BPy_Bone * self);
99 static PyObject *Bone_hide (BPy_Bone * self);
100 static PyObject *Bone_unhide (BPy_Bone * self);
101 static PyObject *Bone_setName (BPy_Bone * self, PyObject * args);
102 static PyObject *Bone_setRoll (BPy_Bone * self, PyObject * args);
103 static PyObject *Bone_setHead (BPy_Bone * self, PyObject * args);
104 static PyObject *Bone_setTail (BPy_Bone * self, PyObject * args);
105 static PyObject *Bone_setLoc (BPy_Bone * self, PyObject * args);
106 static PyObject *Bone_setSize (BPy_Bone * self, PyObject * args);
107 static PyObject *Bone_setQuat (BPy_Bone * self, PyObject * args);
108 static PyObject *Bone_setParent(BPy_Bone *self, PyObject *args);
109 static PyObject *Bone_setWeight(BPy_Bone *self, PyObject *args);
110 static PyObject *Bone_setPose (BPy_Bone *self, PyObject *args);
111
112 /*****************************************************************************/
113 /* Python BPy_Bone methods table:                                        */
114 /*****************************************************************************/
115 static PyMethodDef BPy_Bone_methods[] = {
116   /* name, method, flags, doc */
117   {"getName", (PyCFunction) Bone_getName, METH_NOARGS,
118    "() - return Bone name"},
119   {"getRoll", (PyCFunction) Bone_getRoll, METH_NOARGS,
120    "() - return Bone roll"},
121   {"getHead", (PyCFunction) Bone_getHead, METH_NOARGS,
122    "() - return Bone head"},
123   {"getTail", (PyCFunction) Bone_getTail, METH_NOARGS,
124    "() - return Bone tail"},
125   {"getLoc", (PyCFunction) Bone_getLoc, METH_NOARGS, "() - return Bone loc"},
126   {"getSize", (PyCFunction) Bone_getSize, METH_NOARGS,
127    "() - return Bone size"},
128   {"getQuat", (PyCFunction) Bone_getQuat, METH_NOARGS,
129    "() - return Bone quat"},
130   {"hide", (PyCFunction) Bone_hide, METH_NOARGS,
131    "() - hides the bone"},
132   {"unhide", (PyCFunction) Bone_unhide, METH_NOARGS,
133    "() - unhides the bone"},
134   {"getWeight", (PyCFunction) Bone_getWeight, METH_NOARGS,
135    "() - return Bone weight"},
136   {"getParent", (PyCFunction) Bone_getParent, METH_NOARGS,
137    "() - return the parent bone of this one if it exists."
138    " None if not found. You can check this condition with the "
139    "hasParent() method."},
140   {"hasParent", (PyCFunction) Bone_hasParent, METH_NOARGS,
141    "() - return true if bone has a parent"},
142   {"getChildren", (PyCFunction) Bone_getChildren, METH_NOARGS,
143    "() - return Bone children list"},
144   {"clearParent", (PyCFunction) Bone_clearParent, METH_NOARGS,
145    "() - clears the bone's parent in the armature and makes it root"},
146   {"clearChildren", (PyCFunction) Bone_clearChildren, METH_NOARGS,
147    "() - remove the children associated with this bone"},
148   {"setName", (PyCFunction) Bone_setName, METH_VARARGS,
149    "(str) - rename Bone"},
150   {"setRoll", (PyCFunction) Bone_setRoll, METH_VARARGS,
151    "(float) - set Bone roll"},
152   {"setHead", (PyCFunction) Bone_setHead, METH_VARARGS,
153    "(float,float,float) - set Bone head pos"},
154   {"setTail", (PyCFunction) Bone_setTail, METH_VARARGS,
155    "(float,float,float) - set Bone tail pos"},
156   {"setLoc", (PyCFunction) Bone_setLoc, METH_VARARGS,
157    "(float,float,float) - set Bone loc"},
158   {"setSize", (PyCFunction) Bone_setSize, METH_VARARGS,
159    "(float,float,float) - set Bone size"},
160   {"setQuat", (PyCFunction) Bone_setQuat, METH_VARARGS,
161    "(float,float,float,float) - set Bone quat"},
162   {"setParent", (PyCFunction)Bone_setParent, METH_VARARGS,  
163    "() - set the Bone parent of this one."},
164   {"setWeight", (PyCFunction)Bone_setWeight, METH_VARARGS,  
165    "() - set the Bone weight."},
166   {"setPose", (PyCFunction)Bone_setPose, METH_VARARGS,  
167    "() - set a pose for this bone at a frame."},
168   {NULL, NULL, 0, NULL}
169 };
170
171 /*****************************************************************************/
172 /* Python TypeBone callback function prototypes:                                 */
173 /*****************************************************************************/
174 static void Bone_dealloc (BPy_Bone * bone);
175 static PyObject *Bone_getAttr (BPy_Bone * bone, char *name);
176 static int Bone_setAttr (BPy_Bone * bone, char *name, PyObject * v);
177 static int Bone_compare (BPy_Bone * a1, BPy_Bone * a2);
178 static PyObject *Bone_repr (BPy_Bone * bone);
179
180 /*****************************************************************************/
181 /* Python TypeBone structure definition:                                 */
182 /*****************************************************************************/
183 PyTypeObject Bone_Type = {
184   PyObject_HEAD_INIT (NULL) 0,  /* ob_size */
185   "Blender Bone",               /* tp_name */
186   sizeof (BPy_Bone),            /* tp_basicsize */
187   0,                            /* tp_itemsize */
188   /* methods */
189   (destructor) Bone_dealloc,    /* tp_dealloc */
190   0,                            /* tp_print */
191   (getattrfunc) Bone_getAttr,   /* tp_getattr */
192   (setattrfunc) Bone_setAttr,   /* tp_setattr */
193   (cmpfunc) Bone_compare,       /* tp_compare */
194   (reprfunc) Bone_repr,         /* tp_repr */
195   0,                            /* tp_as_number */
196   0,                            /* tp_as_sequence */
197   0,                            /* tp_as_mapping */
198   0,                            /* tp_as_hash */
199   0, 0, 0, 0, 0, 0,
200   0,                            /* tp_doc */
201   0, 0, 0, 0, 0, 0,
202   BPy_Bone_methods,             /* tp_methods */
203   0,                            /* tp_members */
204 };
205
206
207 /*****************************************************************************/
208 /* Function:    M_Bone_New                                               */
209 /* Python equivalent:   Blender.Armature.Bone.New                        */
210 /*****************************************************************************/
211
212 static PyObject *
213 M_Bone_New (PyObject * self, PyObject * args, PyObject * keywords)
214 {
215   char *name_str = "BoneName";
216   BPy_Bone *py_bone = NULL;     /* for Bone Data object wrapper in Python */
217   Bone *bl_bone = NULL;         /* for actual Bone Data we create in Blender */
218
219   if (!PyArg_ParseTuple (args, "|s", &name_str))
220     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
221                                    "expected string or empty argument"));
222
223   /*  Create the C structure for the newq bone */
224   bl_bone = (Bone *) MEM_callocN(sizeof (Bone), "bone");
225   strncpy (bl_bone->name, name_str, sizeof (bl_bone->name));
226
227   bl_bone->dist=1.0;
228   bl_bone->weight=1.0;
229   bl_bone->flag=32;
230   bl_bone->parent = NULL;
231   bl_bone->roll = 0.0;
232   bl_bone->boneclass = BONE_SKINNABLE;
233
234   // now create the wrapper obj in Python
235   if (bl_bone)                          
236     py_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type);
237   else
238     return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
239                                    "couldn't create Bone Data in Blender"));
240
241   if (py_bone == NULL)
242     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
243                                    "couldn't create Bone Data object"));
244
245   py_bone->bone = bl_bone;      // link Python bone wrapper with Blender Bone
246  
247   Py_INCREF(py_bone);
248   return (PyObject *) py_bone;
249 }
250
251
252 /*****************************************************************************/
253 /* Function:    Bone_Init                                                */
254 /*****************************************************************************/
255 PyObject *
256 Bone_Init (void)
257 {
258   PyObject *submodule;
259
260   Bone_Type.ob_type = &PyType_Type;
261
262   submodule = Py_InitModule3 ("Blender.Armature.Bone",
263                               M_Bone_methods, M_Bone_doc);
264
265   PyModule_AddIntConstant(submodule, "ROT",  POSE_ROT);
266   PyModule_AddIntConstant(submodule, "LOC",  POSE_LOC);
267   PyModule_AddIntConstant(submodule, "SIZE", POSE_SIZE);
268
269   return (submodule);
270 }
271
272 /*****************************************************************************/
273 /* Python BPy_Bone methods:                                              */
274 /*****************************************************************************/
275 static PyObject *
276 Bone_getName (BPy_Bone * self)
277 {
278   PyObject *attr = NULL;
279
280   if (!self->bone)
281     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
282                             "couldn't get attribute from a NULL bone"));
283
284   attr = PyString_FromString (self->bone->name);
285
286   if (attr)
287     return attr;
288
289   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
290                                  "couldn't get Bone.name attribute"));
291 }
292
293
294 static PyObject *
295 Bone_getRoll (BPy_Bone * self)
296 {
297   PyObject *attr = NULL;
298
299   if (!self->bone)
300     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
301                             "couldn't get attribute from a NULL bone"));
302
303   attr = Py_BuildValue ("f", self->bone->roll);
304
305   if (attr)
306     return attr;
307
308   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
309                                  "couldn't get Bone.roll attribute"));
310 }
311
312 static PyObject *
313 Bone_getWeight (BPy_Bone * self)
314 {
315   PyObject *attr = NULL;
316
317   if (!self->bone)
318     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
319                             "couldn't get attribute from a NULL bone"));
320
321   attr = Py_BuildValue ("f", self->bone->weight);
322
323   if (attr)
324     return attr;
325
326   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
327                                  "couldn't get Bone.weight attribute"));
328 }
329
330 static PyObject *
331 Bone_getHead (BPy_Bone * self)
332 {
333   PyObject *attr = NULL;
334
335   if (!self->bone)
336     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
337                             "couldn't get attribute from a NULL bone"));
338
339   attr = Py_BuildValue ("[fff]", self->bone->head[0], self->bone->head[1],
340                         self->bone->head[2]);
341
342   if (attr)
343     return attr;
344
345   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
346                                  "couldn't get Bone.head attribute"));
347 }
348
349
350 static PyObject *
351 Bone_getTail (BPy_Bone * self)
352 {
353   PyObject *attr = NULL;
354
355   if (!self->bone)
356     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
357                             "couldn't get attribute from a NULL bone"));
358
359   attr = Py_BuildValue ("[fff]", self->bone->tail[0], self->bone->tail[1],
360                         self->bone->tail[2]);
361
362   if (attr)
363     return attr;
364
365   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
366                                  "couldn't get Bone.tail attribute"));
367 }
368
369
370 static PyObject *
371 Bone_getLoc (BPy_Bone * self)
372 {
373   PyObject *attr = NULL;
374
375   if (!self->bone)
376     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
377                             "couldn't get attribute from a NULL bone"));
378
379   attr = Py_BuildValue ("[fff]", self->bone->loc[0], self->bone->loc[1],
380                         self->bone->loc[2]);
381
382   if (attr)
383     return attr;
384
385   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
386                                  "couldn't get Bone.loc attribute"));
387 }
388
389
390 static PyObject *
391 Bone_getSize (BPy_Bone * self)
392 {
393   PyObject *attr = NULL;
394
395   if (!self->bone)
396     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
397                             "couldn't get attribute from a NULL bone"));
398
399   attr = Py_BuildValue ("[fff]", self->bone->size[0], self->bone->size[1],
400                         self->bone->size[2]);
401
402   if (attr)
403     return attr;
404
405   return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
406                                  "couldn't get Bone.size attribute"));
407 }
408
409
410 static PyObject *
411 Bone_getQuat (BPy_Bone * self)
412 {
413   float *quat;
414
415   if (!self->bone)
416     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
417                             "couldn't get attribute from a NULL bone"));
418
419   quat = PyMem_Malloc (4*sizeof (float));
420   quat[0] = self->bone->quat[0];
421   quat[1] = self->bone->quat[1];
422   quat[2] = self->bone->quat[2];
423   quat[3] = self->bone->quat[3];
424
425   return (PyObject*)newQuaternionObject(quat);
426 }
427
428 static PyObject *
429 Bone_hasParent (BPy_Bone * self)
430 {
431
432   if (!self->bone)
433     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
434                             "couldn't get attribute from a NULL bone"));
435
436   /*
437      return Bone_CreatePyObject(self->bone->parent);
438    */
439   if (self->bone->parent)
440     {
441       Py_INCREF (Py_True);
442       return Py_True;
443     }
444   else
445     {
446       Py_INCREF (Py_False);
447       return Py_False;
448     }
449
450 }
451
452
453 static PyObject *
454 Bone_getParent (BPy_Bone * self)
455 {
456
457   if (!self->bone)
458     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
459                             "couldn't get attribute from a NULL bone"));
460
461   if (self->bone->parent)
462     return Bone_CreatePyObject (self->bone->parent);
463   else                          /*(EXPP_ReturnPyObjError (PyExc_RuntimeError,
464                                    "couldn't get parent bone, because bone hasn't got a parent.")); */
465     {
466       Py_INCREF (Py_None);
467       return Py_None;
468     }
469
470 }
471
472
473 static PyObject *
474 Bone_getChildren (BPy_Bone * self)
475 {
476   int totbones = 0;
477   Bone *current = NULL;
478   PyObject *listbones = NULL;
479   int i;
480
481   if (!self->bone)
482     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
483                             "couldn't get attribute from a NULL bone"));
484
485   /* Count the number of bones to create the list */
486   current = self->bone->childbase.first;
487   for (; current; current = current->next)
488     totbones++;
489
490   /* Create a list with a bone wrapper for each bone */
491   current = self->bone->childbase.first;
492   listbones = PyList_New (totbones);
493   for (i = 0; i < totbones; i++)
494     {
495       assert (current);
496       PyList_SetItem (listbones, i, Bone_CreatePyObject (current));
497       current = current->next;
498     }
499
500   return listbones;
501 }
502
503
504 static PyObject *
505 Bone_setName (BPy_Bone * self, PyObject * args)
506 {
507   char *name;
508
509   if (!self->bone)
510     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
511                             "couldn't get attribute from a NULL bone"));
512
513   if (!PyArg_ParseTuple (args, "s", &name))
514     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
515                                    "expected string argument"));
516
517   PyOS_snprintf (self->bone->name, sizeof (self->bone->name), "%s", name);
518
519   Py_INCREF (Py_None);
520   return Py_None;
521 }
522
523
524 PyObject *
525 Bone_setRoll (BPy_Bone * self, PyObject * args)
526 {
527   float roll;
528
529   if (!self->bone)
530     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
531                             "couldn't get attribute from a NULL bone"));
532
533   if (!PyArg_ParseTuple (args, "f", &roll))
534     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
535                                    "expected float argument"));
536
537   self->bone->roll = roll;
538
539   Py_INCREF (Py_None);
540   return Py_None;
541 }
542
543 static PyObject *
544 Bone_setHead (BPy_Bone * self, PyObject * args)
545 {
546   float f1, f2, f3;
547   int status;
548
549   if (!self->bone)
550     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
551                             "couldn't get attribute from a NULL bone"));
552
553   if (PyObject_Length (args) == 3)
554     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
555   else
556     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
557
558   if (!status)
559     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
560                                    "expected 3 (or a list of 3) float arguments"));
561
562   self->bone->head[0] = f1;
563   self->bone->head[1] = f2;
564   self->bone->head[2] = f3;
565
566   Py_INCREF (Py_None);
567   return Py_None;
568 }
569
570
571 static PyObject *
572 Bone_setTail (BPy_Bone * self, PyObject * args)
573 {
574   float f1, f2, f3;
575   int status;
576
577   if (!self->bone)
578     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
579                             "couldn't get attribute from a NULL bone"));
580
581   if (PyObject_Length (args) == 3)
582     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
583   else
584     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
585
586   if (!status)
587     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
588                                    "expected 3 (or a list of 3) float arguments"));
589
590   self->bone->tail[0] = f1;
591   self->bone->tail[1] = f2;
592   self->bone->tail[2] = f3;
593
594   Py_INCREF (Py_None);
595   return Py_None;
596 }
597
598
599 static PyObject *
600 Bone_setLoc (BPy_Bone * self, PyObject * args)
601 {
602   float f1, f2, f3;
603   int status;
604
605   if (!self->bone)
606     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
607                             "couldn't get attribute from a NULL bone"));
608
609   if (PyObject_Length (args) == 3)
610     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
611   else
612     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
613
614   if (!status)
615     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
616                                    "expected 3 (or a list of 3) float arguments"));
617
618   self->bone->loc[0] = f1;
619   self->bone->loc[1] = f2;
620   self->bone->loc[2] = f3;
621
622   Py_INCREF (Py_None);
623   return Py_None;
624 }
625
626
627 static PyObject *
628 Bone_setSize (BPy_Bone * self, PyObject * args)
629 {
630   float f1, f2, f3;
631   int status;
632
633   if (!self->bone)
634     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
635                             "couldn't get attribute from a NULL bone"));
636
637   if (PyObject_Length (args) == 3)
638     status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3);
639   else
640     status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3);
641
642   if (!status)
643     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
644                                    "expected 3 (or a list of 3) float arguments"));
645
646   self->bone->size[0] = f1;
647   self->bone->size[1] = f2;
648   self->bone->size[2] = f3;
649
650   Py_INCREF (Py_None);
651   return Py_None;
652 }
653
654
655 static PyObject *
656 Bone_setQuat (BPy_Bone * self, PyObject * args)
657 {
658   float f1, f2, f3, f4;
659   PyObject *argument;
660   QuaternionObject *quatOb;
661   int status;
662
663   if (!self->bone)
664     (EXPP_ReturnPyObjError (PyExc_RuntimeError,
665                             "couldn't get attribute from a NULL bone"));
666
667    if (!PyArg_ParseTuple(args, "O", &argument))
668         return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected quaternion or float list"));
669
670    if(QuaternionObject_Check(argument)){
671                 status = PyArg_ParseTuple(args, "O!", &quaternion_Type, &quatOb);
672                 f1 = quatOb->quat[0];
673                 f2 = quatOb->quat[1];
674                 f3 = quatOb->quat[2];
675                 f4 = quatOb->quat[3];
676    }else{
677                 status = PyArg_ParseTuple (args, "(ffff)", &f1, &f2, &f3, &f4);
678    }
679
680   if (!status)
681     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
682                                    "unable to parse argument"));
683
684   self->bone->quat[0] = f1;
685   self->bone->quat[1] = f2;
686   self->bone->quat[2] = f3;
687   self->bone->quat[3] = f4;
688
689   Py_INCREF (Py_None);
690   return Py_None;
691 }
692
693 static int
694 testChildbase(Bone *bone, Bone *test)
695 {
696         Bone *child;
697
698         for(child = bone->childbase.first; child; child = child->next){
699                 if(child == test){
700                         return 1;
701                 }
702                 if(child->childbase.first != NULL)
703                         testChildbase(child, test);
704         }
705
706         return 0;
707 }
708
709 static PyObject *
710 Bone_setParent(BPy_Bone *self, PyObject *args)
711 {
712   BPy_Bone* py_bone;
713
714   if (!self->bone) 
715           (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
716
717   if (!PyArg_ParseTuple(args, "O", &py_bone))
718         return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected bone object argument"));
719
720   if(!py_bone->bone)
721         return (EXPP_ReturnPyObjError (PyExc_TypeError, "bone contains no data!"));
722
723   if(py_bone->bone == self->bone)
724           return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to self"));
725
726   //test to see if were creating an illegal loop by parenting to child
727   if(testChildbase(self->bone, py_bone->bone))
728           return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to child"));
729
730   //set the parent of self
731   self->bone->parent = py_bone->bone;
732
733   Py_INCREF(Py_None);
734   return Py_None;
735 }
736
737 static PyObject *
738 Bone_setWeight(BPy_Bone *self, PyObject *args)
739 {
740   float weight;
741
742   if (!self->bone)
743     return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
744                             "couldn't get attribute from a NULL bone"));
745
746   if (!PyArg_ParseTuple (args, "f", &weight))
747     return (EXPP_ReturnPyObjError (PyExc_AttributeError,
748                                    "expected float argument"));
749
750   self->bone->weight = weight;
751
752   Py_INCREF (Py_None);
753   return Py_None;
754 }
755
756 static PyObject *
757 Bone_clearParent(BPy_Bone *self)
758 {
759   bArmature *arm = NULL;
760   Bone *bone = NULL;
761   Bone *parent = NULL;
762   Bone *child = NULL;
763   Bone *childPrev = NULL;
764   int firstChild;
765   float M_boneObjectspace[4][4];
766
767   if (!self->bone) 
768           return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
769
770   if(self->bone->parent == NULL)
771           return EXPP_incr_ret(Py_None);
772
773   //get parent and remove link
774   parent = self->bone->parent;
775   self->bone->parent = NULL;
776
777   //remove the childbase link from the parent bone
778   firstChild = 1;
779   for(child = parent->childbase.first; child; child = child->next){     
780           if(child == self->bone && firstChild){
781                         parent->childbase.first = child->next;
782                         child->next = NULL;
783                         break;
784           }
785           if(child == self->bone && !firstChild){
786                   childPrev->next = child->next;
787                   child->next = NULL;
788                   break;
789           }
790           firstChild = 0;
791           childPrev = child;
792   }
793
794   //now get rid of the parent transformation
795   get_objectspace_bone_matrix(parent, M_boneObjectspace, 0,0);
796
797   //transformation of local bone
798   Mat4MulVecfl(M_boneObjectspace, self->bone->head);
799   Mat4MulVecfl(M_boneObjectspace, self->bone->tail);
800
801
802   //get the root bone
803   while(parent->parent != NULL){
804           parent = parent->parent;
805   }
806
807   //add unlinked bone to the bonebase of the armature
808   for (arm = G.main->armature.first; arm; arm= arm->id.next) {
809           for(bone = arm->bonebase.first; bone; bone = bone->next){
810                   if(parent == bone){
811                           //we found the correct armature - now add it as root bone
812                           BLI_addtail (&arm->bonebase, self->bone);
813                           break;
814                   }
815           }                     
816   }
817   
818   Py_INCREF(Py_None);
819   return Py_None;
820 }
821
822 static PyObject *
823 Bone_clearChildren(BPy_Bone *self)
824
825   Bone *root = NULL;
826   Bone *child = NULL;
827   bArmature *arm = NULL;
828   Bone *bone = NULL;
829   Bone *prev = NULL;
830   Bone *next = NULL;
831   float M_boneObjectspace[4][4];
832   int first;
833
834   if (!self->bone) 
835           return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
836
837   if(self->bone->childbase.first == NULL)
838           return EXPP_incr_ret(Py_None);
839
840         //is this bone a part of an armature....
841         //get root bone for testing
842         root = self->bone->parent;
843         if(root != NULL){
844                 while (root->parent != NULL){
845                         root = root->parent;
846                 }
847         }else{
848                 root = self->bone;
849         }
850         //test armatures for root bone
851         for(arm= G.main->armature.first; arm; arm  = arm->id.next){
852                 for(bone = arm->bonebase.first; bone; bone = bone->next){
853                         if(bone == root)
854                                 break;
855                 }
856                 if(bone == root)
857                         break;
858         }
859
860   if(arm == NULL)
861          return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't find armature that contains this bone"));
862
863   //now get rid of the parent transformation
864   get_objectspace_bone_matrix(self->bone, M_boneObjectspace, 0,0);
865
866   //set children as root
867   first = 1;
868   for(child = self->bone->childbase.first; child; child = next){
869       //undo transformation of local bone
870       Mat4MulVecfl(M_boneObjectspace, child->head);
871           Mat4MulVecfl(M_boneObjectspace, child->tail);
872
873           //set next pointers to NULL
874           if(first){
875                 prev = child;
876                 first = 0;
877           }else{
878                 prev->next = NULL;
879             prev = child;
880           }
881           next = child->next;
882
883           //remove parenting and linking
884           child->parent = NULL;
885           BLI_remlink(&self->bone->childbase, child);
886
887           //add as root
888           BLI_addtail (&arm->bonebase, child);
889   }
890
891   Py_INCREF(Py_None);
892   return Py_None;
893
894 }
895
896 static PyObject *
897 Bone_hide(BPy_Bone *self)
898 {
899   if (!self->bone) 
900           return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
901
902   if(!(self->bone->flag & BONE_HIDDEN))
903         self->bone->flag |= BONE_HIDDEN;
904
905   Py_INCREF(Py_None);
906   return Py_None;
907 }
908
909
910 static PyObject *
911 Bone_unhide(BPy_Bone *self)
912 {
913   if (!self->bone) 
914           return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "bone contains no data!"));
915
916   if(self->bone->flag & BONE_HIDDEN)
917         self->bone->flag &= ~BONE_HIDDEN;
918
919   Py_INCREF(Py_None);
920   return Py_None;
921 }
922
923
924 static PyObject *
925 Bone_setPose (BPy_Bone *self, PyObject *args)
926 {
927         Bone *root = NULL;
928         bPoseChannel *chan = NULL;
929         bPoseChannel *setChan = NULL;
930         bPoseChannel *test = NULL;
931         Object *object =NULL;
932         bArmature *arm = NULL;
933         Bone *bone = NULL;
934         PyObject *flaglist = NULL;
935         PyObject *item = NULL;
936         BPy_Action *py_action = NULL;
937         int x;
938         int flagValue = 0;
939         int makeCurve = 1;
940
941         if (!PyArg_ParseTuple (args, "O!|O!", &PyList_Type, &flaglist, &Action_Type, &py_action))
942                         return (EXPP_ReturnPyObjError (PyExc_AttributeError,
943                                                                                                                         "expected list of flags and optional action"));
944
945         for(x = 0; x <  PyList_Size(flaglist); x++){
946                  item = PyList_GetItem(flaglist, x); 
947                  if(PyInt_Check(item)){
948                          flagValue |= PyInt_AsLong(item);
949                  }else{
950                         return (EXPP_ReturnPyObjError (PyExc_AttributeError,
951                                                         "expected list of flags (ints)"));
952                 }
953         }
954
955         //is this bone a part of an armature....
956         //get root bone for testing
957         root = self->bone->parent;
958         if(root != NULL){
959                 while (root->parent != NULL){
960                         root = root->parent;
961                 }
962         }else{
963                 root = self->bone;
964         }
965         //test armatures for root bone
966         for(arm= G.main->armature.first; arm; arm  = arm->id.next){
967                 for(bone = arm->bonebase.first; bone; bone = bone->next){
968                         if(bone == root)
969                                 break;
970                 }
971                 if(bone == root)
972                         break;
973         }
974
975         if(arm == NULL)
976                 return (EXPP_ReturnPyObjError (PyExc_RuntimeError, 
977                         "bone must belong to an armature to set it's pose!"));
978
979         //find if armature is object linked....
980         for(object = G.main->object.first; object; object  = object->id.next){
981                 if(object->data == arm){
982                         break;
983                 }
984         }
985
986         if(object == NULL)
987                 return (EXPP_ReturnPyObjError (PyExc_RuntimeError, 
988                         "armature must be linked to an object to set a pose!"));
989
990         //set the active action as this one
991         if(py_action !=NULL){
992                 if(py_action->action != NULL){
993             object->action = py_action->action;
994                 }
995         }
996
997         //if object doesn't have a pose create one
998         if (!object->pose) 
999                 object->pose = MEM_callocN(sizeof(bPose), "Pose");
1000
1001         //if bone does have a channel create one
1002         verify_pose_channel(object->pose, self->bone->name);
1003
1004         //create temp Pose Channel
1005         chan = MEM_callocN(sizeof(bPoseChannel), "PoseChannel");
1006         //set the variables for this pose
1007         memcpy (chan->loc, self->bone->loc, sizeof (chan->loc));
1008         memcpy (chan->quat, self->bone->quat, sizeof (chan->quat));
1009         memcpy (chan->size, self->bone->size, sizeof (chan->size));
1010         strcpy (chan->name, self->bone->name);
1011         chan->flag |= flagValue;
1012
1013         //set it to the channel
1014         setChan = set_pose_channel(object->pose, chan);
1015
1016         //frees unlinked pose/bone channels from object
1017         collect_pose_garbage(object);
1018
1019         //create an action if one not already assigned to object
1020         if (!py_action && !object->action){
1021                 object->action = (bAction*)add_empty_action();
1022                 object->ipowin= ID_AC;
1023         }else{
1024                   //test if posechannel is already in action
1025                 for(test = object->action->chanbase.first; test; test = test->next){
1026                         if(test == setChan)
1027                                 makeCurve = 0; //already there
1028                 }
1029         }
1030
1031    //set posekey flag
1032    filter_pose_keys ();
1033
1034         //set action keys
1035         if (setChan->flag & POSE_ROT){
1036                 set_action_key(object->action, setChan, AC_QUAT_X, makeCurve);
1037                 set_action_key(object->action, setChan, AC_QUAT_Y, makeCurve);
1038                 set_action_key(object->action, setChan, AC_QUAT_Z, makeCurve);
1039                 set_action_key(object->action, setChan, AC_QUAT_W, makeCurve);
1040         }
1041         if (setChan->flag & POSE_SIZE){
1042                 set_action_key(object->action, setChan, AC_SIZE_X, makeCurve);
1043                 set_action_key(object->action, setChan, AC_SIZE_Y, makeCurve);
1044                 set_action_key(object->action, setChan, AC_SIZE_Z, makeCurve);
1045         }
1046         if (setChan->flag & POSE_LOC){
1047                 set_action_key(object->action, setChan, AC_LOC_X, makeCurve);
1048                 set_action_key(object->action, setChan, AC_LOC_Y, makeCurve);
1049                 set_action_key(object->action, setChan, AC_LOC_Z, makeCurve);
1050         }
1051
1052         //rebuild ipos
1053         remake_action_ipos(object->action);
1054
1055         //rebuild displists
1056         rebuild_all_armature_displists();
1057
1058         Py_INCREF(Py_None);
1059     return Py_None;
1060 }
1061    
1062 /*****************************************************************************/
1063 /* Function:    Bone_dealloc                                                                                            */
1064 /* Description: This is a callback function for the BPy_Bone type. It is     */
1065 /*              the destructor function.                                                                                        */
1066 /*****************************************************************************/
1067 static void
1068 Bone_dealloc (BPy_Bone * self)
1069 {
1070         MEM_freeN(self->bone);
1071     PyObject_DEL (self);
1072 }
1073
1074 /*****************************************************************************/
1075 /* Function:    Bone_getAttr                                                                                            */
1076 /* Description: This is a callback function for the BPy_Bone type. It is    */
1077 /*              the function that accesses BPy_Bone member variables and         */
1078 /*              methods.                                                         */
1079 /*****************************************************************************/
1080 static PyObject *
1081 Bone_getAttr (BPy_Bone * self, char *name)
1082 {
1083   PyObject *attr = Py_None;
1084
1085   if (strcmp (name, "name") == 0)
1086     attr = Bone_getName (self);
1087   else if (strcmp (name, "roll") == 0)
1088     attr = Bone_getRoll (self);
1089   else if (strcmp (name, "head") == 0)
1090     attr = Bone_getHead (self);
1091   else if (strcmp (name, "tail") == 0)
1092     attr = Bone_getTail (self);
1093   else if (strcmp (name, "size") == 0)
1094     attr = Bone_getSize (self);
1095   else if (strcmp (name, "loc") == 0)
1096     attr = Bone_getLoc (self);
1097   else if (strcmp (name, "quat") == 0)
1098     attr = Bone_getQuat (self);
1099   else if (strcmp (name, "parent") == 0)
1100     /*  Skip the checks for Py_None as its a valid result to this call. */
1101     return Bone_getParent (self);
1102   else if (strcmp (name, "children") == 0)
1103     attr = Bone_getChildren (self);
1104   else if (strcmp (name, "weight") == 0)
1105     attr = Bone_getWeight (self);
1106   else if (strcmp (name, "__members__") == 0)
1107     {
1108       /* 9 entries */
1109       attr = Py_BuildValue ("[s,s,s,s,s,s,s,s,s]",
1110                             "name", "roll", "head", "tail", "loc", "size",
1111                             "quat", "parent", "children", "weight");
1112     }
1113
1114   if (!attr)
1115     return (EXPP_ReturnPyObjError (PyExc_MemoryError,
1116                                    "couldn't create PyObject"));
1117
1118   if (attr != Py_None)
1119     return attr;                /* member attribute found, return it */
1120
1121   /* not an attribute, search the methods table */
1122   return Py_FindMethod (BPy_Bone_methods, (PyObject *) self, name);
1123 }
1124
1125 /*****************************************************************************/
1126 /* Function:            Bone_setAttr                                                                                    */
1127 /* Description: This is a callback function for the BPy_Bone type. It is the */
1128 /*              function that changes Bone Data members values. If this      */
1129 /*              data is linked to a Blender Bone, it also gets updated.      */
1130 /*****************************************************************************/
1131 static int
1132 Bone_setAttr (BPy_Bone * self, char *name, PyObject * value)
1133 {
1134   PyObject *valtuple;
1135   PyObject *error = NULL;
1136
1137   valtuple = Py_BuildValue ("(O)", value);      /* the set* functions expect a tuple */
1138
1139   if (!valtuple)
1140     return EXPP_ReturnIntError (PyExc_MemoryError,
1141                                 "BoneSetAttr: couldn't create tuple");
1142
1143   if (strcmp (name, "name") == 0)
1144     error = Bone_setName (self, valtuple);
1145   else
1146     {                           /* Error */
1147       Py_DECREF (valtuple);
1148
1149       /* ... member with the given name was found */
1150       return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found"));
1151     }
1152
1153   Py_DECREF (valtuple);
1154
1155   if (error != Py_None)
1156     return -1;
1157
1158   Py_DECREF (Py_None);          /* was incref'ed by the called Bone_set* function */
1159   return 0;                     /* normal exit */
1160 }
1161
1162 /*****************************************************************************/
1163 /* Function:    Bone_repr                                                                                                       */
1164 /* Description: This is a callback function for the BPy_Bone type. It    */
1165 /*              builds a meaninful string to represent bone objects.     */
1166 /*****************************************************************************/
1167 static PyObject *
1168 Bone_repr (BPy_Bone * self)
1169 {
1170   if (self->bone)
1171     return PyString_FromFormat ("[Bone \"%s\"]", self->bone->name);
1172   else
1173     return PyString_FromString ("NULL");
1174 }
1175
1176 /**************************************************************************/
1177 /* Function:    Bone_compare                                                                                    */
1178 /* Description: This is a callback function for the BPy_Bone type. It   */
1179 /*              compares the two bones: translate comparison to the     */
1180 /*              C pointers.                                                                                                             */
1181 /**************************************************************************/
1182 static int
1183 Bone_compare (BPy_Bone * a, BPy_Bone * b)
1184 {
1185   Bone *pa = a->bone, *pb = b->bone;
1186   return (pa == pb) ? 0 : -1;
1187 }
1188
1189 /*****************************************************************************/
1190 /* Function:    Bone_CreatePyObject                                                                             */
1191 /* Description: This function will create a new BlenBone from an existing    */
1192 /*              Bone structure.                                                                                                         */
1193 /*****************************************************************************/
1194 PyObject *
1195 Bone_CreatePyObject (struct Bone * obj)
1196 {
1197   BPy_Bone *blen_bone;
1198
1199   blen_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type);
1200
1201   if (blen_bone == NULL)
1202     {
1203       return (NULL);
1204     }
1205   blen_bone->bone = obj;
1206   return ((PyObject *) blen_bone);
1207 }
1208
1209 /*****************************************************************************/
1210 /* Function:    Bone_CheckPyObject                                                                                      */
1211 /* Description: This function returns true when the given PyObject is of the */
1212 /*              type Bone. Otherwise it will return false.                                                      */
1213 /*****************************************************************************/
1214 int
1215 Bone_CheckPyObject (PyObject * py_obj)
1216 {
1217   return (py_obj->ob_type == &Bone_Type);
1218 }
1219
1220 /*****************************************************************************/
1221 /* Function:    Bone_FromPyObject                                                                                       */
1222 /* Description: This function returns the Blender bone from the given    */
1223 /*              PyObject.                                                                                                               */
1224 /*****************************************************************************/
1225 struct Bone *
1226 Bone_FromPyObject (PyObject * py_obj)
1227 {
1228   BPy_Bone *blen_obj;
1229
1230   blen_obj = (BPy_Bone *) py_obj;
1231   return (blen_obj->bone);
1232 }