0f36ebda70e001ce855d3e08cb387115138e1f61
[blender-staging.git] / source / blender / makesrna / intern / rna_armature.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28 #include "RNA_types.h"
29
30 #include "rna_internal.h"
31
32 #include "DNA_armature_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "WM_api.h"
37 #include "WM_types.h"
38
39 #ifdef RNA_RUNTIME
40
41 #include "BLI_math.h"
42
43 #include "BKE_context.h"
44 #include "BKE_depsgraph.h"
45 #include "BKE_idprop.h"
46 #include "BKE_main.h"
47
48 #include "ED_armature.h"
49 #include "BKE_armature.h"
50
51 static void rna_Armature_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
52 {
53         ID *id= ptr->id.data;
54
55         DAG_id_flush_update(id, OB_RECALC_DATA);
56         WM_main_add_notifier(NC_GEOM|ND_DATA, id);
57         //WM_main_add_notifier(NC_OBJECT|ND_POSE, NULL);
58 }
59
60
61 static void rna_Armature_act_bone_set(PointerRNA *ptr, PointerRNA value)
62 {
63         bArmature *arm= (bArmature*)ptr->data;
64
65         if(value.id.data==NULL && value.data==NULL) {
66                 arm->act_bone= NULL;
67         }
68         else {
69                 if(value.id.data != arm) {
70                         /* raise an error! */
71                 }
72                 else {
73                         arm->act_bone= value.data;
74                         arm->act_bone->flag |= BONE_SELECTED;
75                 }
76         }
77 }
78
79 static void rna_Armature_act_edit_bone_set(PointerRNA *ptr, PointerRNA value)
80 {
81         bArmature *arm= (bArmature*)ptr->data;
82
83         if(value.id.data==NULL && value.data==NULL) {
84                 arm->act_edbone= NULL;
85         }
86         else {
87                 if(value.id.data != arm) {
88                         /* raise an error! */
89                 }
90                 else {
91                         arm->act_edbone= value.data;
92                         ((EditBone *)arm->act_edbone)->flag |= BONE_SELECTED;
93                 }
94         }
95 }
96
97 EditBone *rna_Armature_edit_bone_new(bArmature *arm, ReportList *reports, char *name)
98 {
99         if(arm->edbo==NULL) {
100                 BKE_reportf(reports, RPT_ERROR, "Armature '%s' not in editmode, cant add an editbone.", arm->id.name+2);
101                 return NULL;
102         }
103         return ED_armature_edit_bone_add(arm, name);
104 }
105
106 void rna_Armature_edit_bone_remove(bArmature *arm, ReportList *reports, EditBone *ebone)
107 {
108         if(arm->edbo==NULL) {
109                 BKE_reportf(reports, RPT_ERROR, "Armature '%s' not in editmode, cant remove an editbone.", arm->id.name+2);
110                 return;
111         }
112         ED_armature_edit_bone_remove(arm, ebone);
113 }
114
115 static void rna_Armature_redraw_data(Main *bmain, Scene *scene, PointerRNA *ptr)
116 {
117         ID *id= ptr->id.data;
118
119         WM_main_add_notifier(NC_GEOM|ND_DATA, id);
120 }
121
122 static char *rna_Bone_path(PointerRNA *ptr)
123 {
124         return BLI_sprintfN("bones[\"%s\"]", ((Bone*)ptr->data)->name);
125 }
126
127 static IDProperty *rna_Bone_idproperties(PointerRNA *ptr, int create)
128 {
129         Bone *bone= ptr->data;
130
131         if(create && !bone->prop) {
132                 IDPropertyTemplate val = {0};
133                 bone->prop= IDP_New(IDP_GROUP, val, "RNA_Bone ID properties");
134         }
135
136         return bone->prop;
137 }
138
139 static IDProperty *rna_EditBone_idproperties(PointerRNA *ptr, int create)
140 {
141         EditBone *ebone= ptr->data;
142
143         if(create && !ebone->prop) {
144                 IDPropertyTemplate val = {0};
145                 ebone->prop= IDP_New(IDP_GROUP, val, "RNA_EditBone ID properties");
146         }
147
148         return ebone->prop;
149 }
150
151 static void rna_bone_layer_set(int *layer, const int *values)
152 {
153         int i, tot= 0;
154
155         /* ensure we always have some layer selected */
156         for(i=0; i<32; i++)
157                 if(values[i])
158                         tot++;
159         
160         if(tot==0)
161                 return;
162
163         for(i=0; i<32; i++) {
164                 if(values[i]) *layer |= (1<<i);
165                 else *layer &= ~(1<<i);
166         }
167 }
168
169 static void rna_Bone_layer_set(PointerRNA *ptr, const int *values)
170 {
171         Bone *bone= (Bone*)ptr->data;
172         rna_bone_layer_set(&bone->layer, values);
173 }
174
175 static void rna_Armature_layer_set(PointerRNA *ptr, const int *values)
176 {
177         bArmature *arm= (bArmature*)ptr->data;
178         int i, tot= 0;
179
180         /* ensure we always have some layer selected */
181         for(i=0; i<32; i++)
182                 if(values[i])
183                         tot++;
184         
185         if(tot==0)
186                 return;
187
188         for(i=0; i<32; i++) {
189                 if(values[i]) arm->layer |= (1<<i);
190                 else arm->layer &= ~(1<<i);
191         }
192 }
193
194 static void rna_Armature_ghost_start_frame_set(PointerRNA *ptr, int value)
195 {
196         bArmature *data= (bArmature*)ptr->data;
197         CLAMP(value, 1, data->ghostef);
198         data->ghostsf= value;
199 }
200
201 static void rna_Armature_ghost_end_frame_set(PointerRNA *ptr, int value)
202 {
203         bArmature *data= (bArmature*)ptr->data;
204         CLAMP(value, data->ghostsf, (int)(MAXFRAMEF/2));
205         data->ghostef= value;
206 }
207
208 static void rna_Armature_path_start_frame_set(PointerRNA *ptr, int value)
209 {
210         bArmature *data= (bArmature*)ptr->data;
211         CLAMP(value, 1, data->pathef);
212         data->pathsf= value;
213 }
214
215 static void rna_Armature_path_end_frame_set(PointerRNA *ptr, int value)
216 {
217         bArmature *data= (bArmature*)ptr->data;
218         CLAMP(value, data->pathsf, (int)(MAXFRAMEF/2));
219         data->pathef= value;
220 }
221
222 static void rna_EditBone_name_set(PointerRNA *ptr, const char *value)
223 {
224         bArmature *arm= (bArmature*)ptr->id.data;
225         EditBone *ebone= (EditBone*)ptr->data;
226         char oldname[32], newname[32];
227         
228         /* need to be on the stack */
229         BLI_strncpy(newname, value, 32);
230         BLI_strncpy(oldname, ebone->name, 32);
231         
232         ED_armature_bone_rename(arm, oldname, newname);
233 }
234
235 static void rna_Bone_name_set(PointerRNA *ptr, const char *value)
236 {
237         bArmature *arm= (bArmature*)ptr->id.data;
238         Bone *bone= (Bone*)ptr->data;
239         char oldname[32], newname[32];
240         
241         /* need to be on the stack */
242         BLI_strncpy(newname, value, 32);
243         BLI_strncpy(oldname, bone->name, 32);
244         
245         ED_armature_bone_rename(arm, oldname, newname);
246 }
247
248 static void rna_EditBone_layer_set(PointerRNA *ptr, const int values[])
249 {
250         EditBone *data= (EditBone*)(ptr->data);
251         rna_bone_layer_set(&data->layer, values);
252 }
253
254 static void rna_EditBone_connected_check(EditBone *ebone)
255 {
256         if(ebone->parent) {
257                 if(ebone->flag & BONE_CONNECTED) {
258                         /* Attach this bone to its parent */
259                         VECCOPY(ebone->head, ebone->parent->tail);
260
261                         if(ebone->flag & BONE_ROOTSEL)
262                                 ebone->parent->flag |= BONE_TIPSEL;
263                 }
264                 else if(!(ebone->parent->flag & BONE_ROOTSEL)) {
265                         ebone->parent->flag &= ~BONE_TIPSEL;
266                 }
267         }
268 }
269
270 static void rna_EditBone_connected_set(PointerRNA *ptr, int value)
271 {
272         EditBone *ebone= (EditBone*)(ptr->data);
273
274         if(value) ebone->flag |= BONE_CONNECTED;
275         else ebone->flag &= ~BONE_CONNECTED;
276
277         rna_EditBone_connected_check(ebone);
278 }
279
280 static PointerRNA rna_EditBone_parent_get(PointerRNA *ptr)
281 {
282         EditBone *data= (EditBone*)(ptr->data);
283         return rna_pointer_inherit_refine(ptr, &RNA_EditBone, data->parent);
284 }
285
286 static void rna_EditBone_parent_set(PointerRNA *ptr, PointerRNA value)
287 {
288         EditBone *ebone= (EditBone*)(ptr->data);
289         EditBone *pbone, *parbone= (EditBone*)value.data;
290
291         if(parbone == NULL) {
292                 if(ebone->parent && !(ebone->parent->flag & BONE_ROOTSEL))
293                         ebone->parent->flag &= ~BONE_TIPSEL;
294
295                 ebone->parent = NULL;
296                 ebone->flag &= ~BONE_CONNECTED;
297         }
298         else {
299                 /* within same armature */
300                 if(value.id.data != ptr->id.data)
301                         return;
302
303                 /* make sure this is a valid child */
304                 if(parbone == ebone)
305                         return;
306                         
307                 for(pbone= parbone->parent; pbone; pbone=pbone->parent)
308                         if(pbone == ebone)
309                                 return;
310
311                 ebone->parent = parbone;
312                 rna_EditBone_connected_check(ebone);
313         }
314 }
315
316 static void rna_EditBone_matrix_get(PointerRNA *ptr, float *values)
317 {
318         EditBone *ebone= (EditBone*)(ptr->data);
319
320         float   delta[3], tmat[3][3], mat[4][4];
321
322         /* Find the current bone matrix */
323         sub_v3_v3v3(delta, ebone->tail, ebone->head);
324         vec_roll_to_mat3(delta, ebone->roll, tmat);
325         copy_m4_m3(mat, tmat);
326         VECCOPY(mat[3], ebone->head);
327
328         memcpy(values, mat, 16 * sizeof(float));
329 }
330
331 static void rna_Armature_editbone_transform_update(Main *bmain, Scene *scene, PointerRNA *ptr)
332 {
333         bArmature *arm= (bArmature*)ptr->id.data;
334         EditBone *ebone= (EditBone*)ptr->data;
335         EditBone *child, *eboflip;
336         
337         /* update our parent */
338         if(ebone->parent && ebone->flag & BONE_CONNECTED)
339                 VECCOPY(ebone->parent->tail, ebone->head)
340
341         /* update our children if necessary */
342         for(child = arm->edbo->first; child; child=child->next)
343                 if(child->parent == ebone && (child->flag & BONE_CONNECTED))
344                         VECCOPY(child->head, ebone->tail);
345
346         if(arm->flag & ARM_MIRROR_EDIT) {
347                 eboflip= ED_armature_bone_get_mirrored(arm->edbo, ebone);
348
349                 if(eboflip) {
350                         eboflip->roll= -ebone->roll;
351
352                         eboflip->head[0]= -ebone->head[0];
353                         eboflip->tail[0]= -ebone->tail[0];
354                         
355                         /* update our parent */
356                         if(eboflip->parent && eboflip->flag & BONE_CONNECTED)
357                                 VECCOPY(eboflip->parent->tail, eboflip->head);
358                         
359                         /* update our children if necessary */
360                         for(child = arm->edbo->first; child; child=child->next)
361                                 if(child->parent == eboflip && (child->flag & BONE_CONNECTED))
362                                         VECCOPY (child->head, eboflip->tail);
363                 }
364         }
365
366         rna_Armature_update_data(bmain, scene, ptr);
367 }
368
369 static void rna_Armature_bones_next(CollectionPropertyIterator *iter)
370 {
371         ListBaseIterator *internal= iter->internal;
372         Bone *bone= (Bone*)internal->link;
373
374         if(bone->childbase.first)
375                 internal->link= (Link*)bone->childbase.first;
376         else if(bone->next)
377                 internal->link= (Link*)bone->next;
378         else {
379                 internal->link= NULL;
380
381                 do {
382                         bone= bone->parent;
383                         if(bone && bone->next) {
384                                 internal->link= (Link*)bone->next;
385                                 break;
386                         }
387                 } while(bone);
388         }
389
390         iter->valid= (internal->link != NULL);
391 }
392
393 #else
394
395 static void rna_def_bone_common(StructRNA *srna, int editbone)
396 {
397         PropertyRNA *prop;
398
399         /* strings */
400         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
401         RNA_def_property_string_sdna(prop, NULL, "name");
402         RNA_def_property_ui_text(prop, "Name", "");
403         RNA_def_struct_name_property(srna, prop);
404         if(editbone) RNA_def_property_string_funcs(prop, NULL, NULL, "rna_EditBone_name_set");
405         else RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Bone_name_set");
406         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
407
408         /* flags */
409         prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_LAYER_MEMBER);
410         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
411         RNA_def_property_array(prop, 32);
412         if(editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_layer_set");
413         else RNA_def_property_boolean_funcs(prop, NULL, "rna_Bone_layer_set");
414         RNA_def_property_ui_text(prop, "Layers", "Layers bone exists in");
415         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
416
417         prop= RNA_def_property(srna, "connected", PROP_BOOLEAN, PROP_NONE);
418         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_CONNECTED);
419         if(editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_connected_set");
420         else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
421         RNA_def_property_ui_text(prop, "Connected", "When bone has a parent, bone's head is struck to the parent's tail.");
422         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
423         
424         prop= RNA_def_property(srna, "hinge", PROP_BOOLEAN, PROP_NONE);
425         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_HINGE);
426         RNA_def_property_ui_text(prop, "Inherit Rotation", "Bone inherits rotation or scale from parent bone.");
427         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
428         
429         prop= RNA_def_property(srna, "multiply_vertexgroup_with_envelope", PROP_BOOLEAN, PROP_NONE);
430         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_MULT_VG_ENV);
431         RNA_def_property_ui_text(prop, "Multiply Vertex Group with Envelope", "When deforming bone, multiply effects of Vertex Group weights with Envelope influence.");
432         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
433         
434         prop= RNA_def_property(srna, "deform", PROP_BOOLEAN, PROP_NONE);
435         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_DEFORM);
436         RNA_def_property_ui_text(prop, "Deform", "Bone does not deform any geometry.");
437         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
438         
439         prop= RNA_def_property(srna, "inherit_scale", PROP_BOOLEAN, PROP_NONE);
440         RNA_def_property_ui_text(prop, "Inherit Scale", "Bone inherits scaling from parent bone.");
441         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_SCALE);
442         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
443
444         prop= RNA_def_property(srna, "local_location", PROP_BOOLEAN, PROP_NONE);
445         RNA_def_property_ui_text(prop, "Local Location", "Bone location is set in local space.");
446         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_LOCAL_LOCATION);
447         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
448         
449         prop= RNA_def_property(srna, "draw_wire", PROP_BOOLEAN, PROP_NONE);
450         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_DRAWWIRE);
451         RNA_def_property_ui_text(prop, "Draw Wire", "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes.");
452         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
453         
454         prop= RNA_def_property(srna, "cyclic_offset", PROP_BOOLEAN, PROP_NONE);
455         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
456         RNA_def_property_ui_text(prop, "Cyclic Offset", "When bone doesn't have a parent, it receives cyclic offset effects.");
457         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
458         
459         prop= RNA_def_property(srna, "restrict_select", PROP_BOOLEAN, PROP_NONE);
460         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_UNSELECTABLE);
461         RNA_def_property_ui_text(prop, "Selectable", "Bone is able to be selected");
462         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
463
464         /* Number values */
465                 /* envelope deform settings */
466         prop= RNA_def_property(srna, "envelope_distance", PROP_FLOAT, PROP_NONE);
467         RNA_def_property_float_sdna(prop, NULL, "dist");
468         RNA_def_property_range(prop, 0.0f, 1000.0f);
469         RNA_def_property_ui_text(prop, "Envelope Deform Distance", "Bone deformation distance (for Envelope deform only).");
470         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
471         
472         prop= RNA_def_property(srna, "envelope_weight", PROP_FLOAT, PROP_NONE);
473         RNA_def_property_float_sdna(prop, NULL, "weight");
474         RNA_def_property_range(prop, 0.0f, 1000.0f);
475         RNA_def_property_ui_text(prop, "Envelope Deform Weight", "Bone deformation weight (for Envelope deform only).");
476         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
477         
478         prop= RNA_def_property(srna, "head_radius", PROP_FLOAT, PROP_NONE);
479         if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
480         RNA_def_property_float_sdna(prop, NULL, "rad_head");
481         //RNA_def_property_range(prop, 0, 1000);  // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
482         RNA_def_property_ui_text(prop, "Envelope Head Radius", "Radius of head of bone (for Envelope deform only).");
483         
484         prop= RNA_def_property(srna, "tail_radius", PROP_FLOAT, PROP_NONE);
485         if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
486         RNA_def_property_float_sdna(prop, NULL, "rad_tail");
487         //RNA_def_property_range(prop, 0, 1000);  // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
488         RNA_def_property_ui_text(prop, "Envelope Tail Radius", "Radius of tail of bone (for Envelope deform only).");
489         
490                 /* b-bones deform settings */
491         prop= RNA_def_property(srna, "bbone_segments", PROP_INT, PROP_NONE);
492         RNA_def_property_int_sdna(prop, NULL, "segments");
493         RNA_def_property_range(prop, 1, 32);
494         RNA_def_property_ui_text(prop, "B-Bone Segments", "Number of subdivisions of bone (for B-Bones only).");
495         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
496         
497         prop= RNA_def_property(srna, "bbone_in", PROP_FLOAT, PROP_NONE);
498         RNA_def_property_float_sdna(prop, NULL, "ease1");
499         RNA_def_property_range(prop, 0.0f, 2.0f);
500         RNA_def_property_ui_text(prop, "B-Bone Ease In", "Length of first Bezier Handle (for B-Bones only).");
501         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
502         
503         prop= RNA_def_property(srna, "bbone_out", PROP_FLOAT, PROP_NONE);
504         RNA_def_property_float_sdna(prop, NULL, "ease2");
505         RNA_def_property_range(prop, 0.0f, 2.0f);
506         RNA_def_property_ui_text(prop, "B-Bone Ease Out", "Length of second Bezier Handle (for B-Bones only).");
507         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
508 }
509
510 // err... bones should not be directly edited (only editbones should be...)
511 static void rna_def_bone(BlenderRNA *brna)
512 {
513         StructRNA *srna;
514         PropertyRNA *prop;
515         
516         srna= RNA_def_struct(brna, "Bone", NULL);
517         RNA_def_struct_ui_text(srna, "Bone", "Bone in an Armature datablock.");
518         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
519         RNA_def_struct_path_func(srna, "rna_Bone_path");
520         RNA_def_struct_idproperties_func(srna, "rna_Bone_idproperties");
521         
522         /* pointers/collections */
523                 /* parent (pointer) */
524         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
525         RNA_def_property_struct_type(prop, "Bone");
526         RNA_def_property_pointer_sdna(prop, NULL, "parent");
527         RNA_def_property_ui_text(prop, "Parent", "Parent bone (in same Armature).");
528         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
529         
530                 /* children (collection) */
531         prop= RNA_def_property(srna, "children", PROP_COLLECTION, PROP_NONE);
532         RNA_def_property_collection_sdna(prop, NULL, "childbase", NULL);
533         RNA_def_property_struct_type(prop, "Bone");
534         RNA_def_property_ui_text(prop, "Children", "Bones which are children of this bone");
535
536         rna_def_bone_common(srna, 0);
537
538                 // XXX should we define this in PoseChannel wrapping code instead? but PoseChannels directly get some of their flags from here...
539         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
540         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_P);
541         RNA_def_property_ui_text(prop, "Hidden", "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes).");
542         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
543
544         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
545         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
546         RNA_def_property_ui_text(prop, "Selected", "");
547         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
548
549         /* XXX better matrix descriptions possible (Arystan) */
550         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
551         RNA_def_property_float_sdna(prop, NULL, "bone_mat");
552         RNA_def_property_array(prop, 9);
553         RNA_def_property_ui_text(prop, "Bone Matrix", "3x3 bone matrix.");
554
555         prop= RNA_def_property(srna, "matrix_local", PROP_FLOAT, PROP_MATRIX);
556         RNA_def_property_float_sdna(prop, NULL, "arm_mat");
557         RNA_def_property_array(prop, 16);
558         RNA_def_property_ui_text(prop, "Bone Armature-Relative Matrix", "4x4 bone matrix relative to armature.");
559
560         prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
561         RNA_def_property_float_sdna(prop, NULL, "tail");
562         RNA_def_property_array(prop, 3);
563         RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone.");
564
565         prop= RNA_def_property(srna, "tail_local", PROP_FLOAT, PROP_TRANSLATION);
566         RNA_def_property_float_sdna(prop, NULL, "arm_tail");
567         RNA_def_property_array(prop, 3);
568         RNA_def_property_ui_text(prop, "Armature-Relative Tail", "Location of tail end of the bone relative to armature.");
569
570         prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
571         RNA_def_property_float_sdna(prop, NULL, "head");
572         RNA_def_property_array(prop, 3);
573         RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone relative to its parent.");
574
575         prop= RNA_def_property(srna, "head_local", PROP_FLOAT, PROP_TRANSLATION);
576         RNA_def_property_float_sdna(prop, NULL, "arm_head");
577         RNA_def_property_array(prop, 3);
578         RNA_def_property_ui_text(prop, "Armature-Relative Head", "Location of head end of the bone relative to armature.");
579 }
580
581 static void rna_def_edit_bone(BlenderRNA *brna)
582 {
583         StructRNA *srna;
584         PropertyRNA *prop;
585         
586         srna= RNA_def_struct(brna, "EditBone", NULL);
587         RNA_def_struct_sdna(srna, "EditBone");
588         RNA_def_struct_idproperties_func(srna, "rna_EditBone_idproperties");
589         RNA_def_struct_ui_text(srna, "Edit Bone", "Editmode bone in an Armature datablock.");
590         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
591         
592         RNA_define_verify_sdna(0); // not in sdna
593
594         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
595         RNA_def_property_struct_type(prop, "EditBone");
596         RNA_def_property_pointer_funcs(prop, "rna_EditBone_parent_get", "rna_EditBone_parent_set", NULL);
597         RNA_def_property_flag(prop, PROP_EDITABLE);
598         RNA_def_property_ui_text(prop, "Parent", "Parent edit bone (in same Armature).");
599         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
600         
601         prop= RNA_def_property(srna, "roll", PROP_FLOAT, PROP_NONE);
602         RNA_def_property_float_sdna(prop, NULL, "roll");
603         RNA_def_property_ui_text(prop, "Roll", "Bone rotation around head-tail axis.");
604         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
605
606         prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
607         RNA_def_property_float_sdna(prop, NULL, "head");
608         RNA_def_property_array(prop, 3);
609         RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone.");
610         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
611
612         prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
613         RNA_def_property_float_sdna(prop, NULL, "tail");
614         RNA_def_property_array(prop, 3);
615         RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone.");
616         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
617
618         rna_def_bone_common(srna, 1);
619
620         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_A);
622         RNA_def_property_ui_text(prop, "Hidden", "Bone is not visible when in Edit Mode");
623         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
624
625         prop= RNA_def_property(srna, "locked", PROP_BOOLEAN, PROP_NONE);
626         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_EDITMODE_LOCKED);
627         RNA_def_property_ui_text(prop, "Locked", "Bone is not able to be transformed when in Edit Mode.");
628         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
629
630         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
631         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
632         RNA_def_property_ui_text(prop, "Selected", "");
633         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
634
635         prop= RNA_def_property(srna, "selected_head", PROP_BOOLEAN, PROP_NONE);
636         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
637         RNA_def_property_ui_text(prop, "Head Selected", "");
638         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
639         
640         prop= RNA_def_property(srna, "selected_tail", PROP_BOOLEAN, PROP_NONE);
641         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
642         RNA_def_property_ui_text(prop, "Tail Selected", "");
643         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
644
645         /* calculated and read only, not actual data access */
646         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
647         //RNA_def_property_float_sdna(prop, NULL, ""); // doesnt access any real data
648         RNA_def_property_array(prop, 16);
649         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
650         RNA_def_property_ui_text(prop, "Editbone Matrix", "Read-only matrix calculated from the roll (armature space).");
651         RNA_def_property_float_funcs(prop, "rna_EditBone_matrix_get", NULL, NULL); // TODO - this could be made writable also
652
653         RNA_api_armature_edit_bone(srna);
654
655         RNA_define_verify_sdna(1);
656 }
657
658
659 /* armature.bones.* */
660 static void rna_def_armature_bones(BlenderRNA *brna, PropertyRNA *cprop)
661 {
662         StructRNA *srna;
663         PropertyRNA *prop;
664
665 //      FunctionRNA *func;
666 //      PropertyRNA *parm;
667
668         RNA_def_property_srna(cprop, "ArmatureBones");
669         srna= RNA_def_struct(brna, "ArmatureBones", NULL);
670         RNA_def_struct_sdna(srna, "bArmature");
671         RNA_def_struct_ui_text(srna, "Armature Bones", "Collection of armature bones.");
672
673
674         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
675         RNA_def_property_struct_type(prop, "Bone");
676         RNA_def_property_pointer_sdna(prop, NULL, "act_bone");
677         RNA_def_property_flag(prop, PROP_EDITABLE);
678         RNA_def_property_ui_text(prop, "Active Bone", "Armatures active bone.");
679         RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_bone_set", NULL);
680
681         /* todo, redraw */
682 //              RNA_def_property_collection_active(prop, prop_act);
683 }
684
685 /* armature.bones.* */
686 static void rna_def_armature_edit_bones(BlenderRNA *brna, PropertyRNA *cprop)
687 {
688         StructRNA *srna;
689         PropertyRNA *prop;
690
691         FunctionRNA *func;
692         PropertyRNA *parm;
693
694         RNA_def_property_srna(cprop, "ArmatureEditBones");
695         srna= RNA_def_struct(brna, "ArmatureEditBones", NULL);
696         RNA_def_struct_sdna(srna, "bArmature");
697         RNA_def_struct_ui_text(srna, "Armature EditBones", "Collection of armature edit bones.");
698
699         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
700         RNA_def_property_struct_type(prop, "EditBone");
701         RNA_def_property_pointer_sdna(prop, NULL, "act_edbone");
702         RNA_def_property_flag(prop, PROP_EDITABLE);
703         RNA_def_property_ui_text(prop, "Active EditBone", "Armatures active edit bone.");
704         //RNA_def_property_update(prop, 0, "rna_Armature_act_editbone_update");
705         RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_edit_bone_set", NULL);
706
707         /* todo, redraw */
708 //              RNA_def_property_collection_active(prop, prop_act);
709
710         /* add target */
711         func= RNA_def_function(srna, "new", "rna_Armature_edit_bone_new");
712         RNA_def_function_flag(func, FUNC_USE_REPORTS);
713         RNA_def_function_ui_description(func, "Add a new bone.");
714         parm= RNA_def_string(func, "name", "Object", 0, "", "New name for the bone.");
715         RNA_def_property_flag(parm, PROP_REQUIRED);
716
717         /* return type */
718         parm= RNA_def_pointer(func, "bone", "EditBone", "", "Newly created edit bone.");
719         RNA_def_function_return(func, parm);
720
721         /* remove target */
722         func= RNA_def_function(srna, "remove", "rna_Armature_edit_bone_remove");
723         RNA_def_function_flag(func, FUNC_USE_REPORTS);
724         RNA_def_function_ui_description(func, "Remove an existing bone from the armature.");
725         /* target to remove*/
726         parm= RNA_def_pointer(func, "bone", "EditBone", "", "EditBone to remove.");
727         RNA_def_property_flag(parm, PROP_REQUIRED);
728 }
729
730 static void rna_def_armature(BlenderRNA *brna)
731 {
732         StructRNA *srna;
733         PropertyRNA *prop;
734         
735         static EnumPropertyItem prop_drawtype_items[] = {
736                 {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Display bones as octahedral shape (default)."},
737                 {ARM_LINE, "STICK", 0, "Stick", "Display bones as simple 2D lines with dots."},
738                 {ARM_B_BONE, "BBONE", 0, "B-Bone", "Display bones as boxes, showing subdivision and B-Splines"},
739                 {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope", "Display bones as extruded spheres, showing defomation influence volume."},
740                 {0, NULL, 0, NULL, NULL}};
741         static EnumPropertyItem prop_ghost_type_items[] = {
742                 {ARM_GHOST_CUR, "CURRENT_FRAME", 0, "Around Frame", "Display Ghosts of poses within a fixed number of frames around the current frame."},
743                 {ARM_GHOST_RANGE, "RANGE", 0, "In Range", "Display Ghosts of poses within specified range."},
744                 {ARM_GHOST_KEYS, "KEYS", 0, "On Keyframes", "Display Ghosts of poses on Keyframes."},
745                 {0, NULL, 0, NULL, NULL}};
746         static const EnumPropertyItem prop_paths_type_items[]= {
747                 {ARM_PATH_ACFRA, "CURRENT_FRAME", 0, "Around Frame", "Display Paths of poses within a fixed number of frames around the current frame."},
748                 {0, "RANGE", 0, "In Range", "Display Paths of poses within specified range."},
749                 {0, NULL, 0, NULL, NULL}};
750         static const EnumPropertyItem prop_paths_location_items[]= {
751                 {ARM_PATH_HEADS, "HEADS", 0, "Heads", "Calculate bone paths from heads"},
752                 {0, "TAILS", 0, "Tails", "Calculate bone paths from tails"},
753                 {0, NULL, 0, NULL, NULL}};
754         static const EnumPropertyItem prop_pose_position_items[]= {
755                 {0, "POSE", 0, "Pose Position", "Show armature in posed state."},
756                 {ARM_RESTPOS, "REST", 0, "Rest Position", "Show Armature in binding pose state. No posing possible."},
757                 {0, NULL, 0, NULL, NULL}};
758         
759         srna= RNA_def_struct(brna, "Armature", "ID");
760         RNA_def_struct_ui_text(srna, "Armature", "Armature datablock containing a hierarchy of bones, usually used for rigging characters.");
761         RNA_def_struct_ui_icon(srna, ICON_ARMATURE_DATA);
762         RNA_def_struct_sdna(srna, "bArmature");
763         
764         /* Animation Data */
765         rna_def_animdata_common(srna);
766         
767         /* Collections */
768         prop= RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
769         RNA_def_property_collection_sdna(prop, NULL, "bonebase", NULL);
770         RNA_def_property_collection_funcs(prop, 0, "rna_Armature_bones_next", 0, 0, 0, 0, 0);
771         RNA_def_property_struct_type(prop, "Bone");
772         RNA_def_property_ui_text(prop, "Bones", "");
773         rna_def_armature_bones(brna, prop);
774
775         prop= RNA_def_property(srna, "edit_bones", PROP_COLLECTION, PROP_NONE);
776         RNA_def_property_collection_sdna(prop, NULL, "edbo", NULL);
777         RNA_def_property_struct_type(prop, "EditBone");
778         RNA_def_property_ui_text(prop, "Edit Bones", "");
779         rna_def_armature_edit_bones(brna, prop);
780
781         /* Enum values */
782         prop= RNA_def_property(srna, "pose_position", PROP_ENUM, PROP_NONE);
783         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
784         RNA_def_property_enum_items(prop, prop_pose_position_items);
785         RNA_def_property_ui_text(prop, "Pose Position", "Show armature in binding pose or final posed state.");
786         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
787         
788         prop= RNA_def_property(srna, "drawtype", PROP_ENUM, PROP_NONE);
789         RNA_def_property_enum_items(prop, prop_drawtype_items);
790         RNA_def_property_ui_text(prop, "Draw Type", "");
791         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
792         
793         prop= RNA_def_property(srna, "ghost_type", PROP_ENUM, PROP_NONE);
794         RNA_def_property_enum_sdna(prop, NULL, "ghosttype");
795         RNA_def_property_enum_items(prop, prop_ghost_type_items);
796         RNA_def_property_ui_text(prop, "Ghost Type", "Method of Onion-skinning for active Action");
797         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
798         
799         prop= RNA_def_property(srna, "paths_type", PROP_ENUM, PROP_NONE);
800         RNA_def_property_enum_bitflag_sdna(prop, NULL, "pathflag");
801         RNA_def_property_enum_items(prop, prop_paths_type_items);
802         RNA_def_property_ui_text(prop, "Paths Type", "Type of range to show for Bone Paths");
803         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
804         
805         prop= RNA_def_property(srna, "paths_location", PROP_ENUM, PROP_NONE);
806         RNA_def_property_enum_bitflag_sdna(prop, NULL, "pathflag");
807         RNA_def_property_enum_items(prop, prop_paths_location_items);
808         RNA_def_property_ui_text(prop, "Paths Location", "When calculating Bone Paths, use Head or Tips");
809         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
810         
811         /* Boolean values */
812                 /* layer */
813         prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_LAYER_MEMBER);
814         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
815         RNA_def_property_array(prop, 32);
816         RNA_def_property_ui_text(prop, "Visible Layers", "Armature layer visibility.");
817         RNA_def_property_boolean_funcs(prop, NULL, "rna_Armature_layer_set");
818         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Armature_redraw_data");
819         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
820         
821                 /* layer protection */
822         prop= RNA_def_property(srna, "layer_protection", PROP_BOOLEAN, PROP_LAYER);
823         RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
824         RNA_def_property_array(prop, 32);
825         RNA_def_property_ui_text(prop, "Layer Proxy Protection", "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo.");        
826         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
827                 
828                 /* flag */
829         
830         
831         prop= RNA_def_property(srna, "draw_axes", PROP_BOOLEAN, PROP_NONE);
832         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWAXES);
833         RNA_def_property_ui_text(prop, "Draw Axes", "Draw bone axes.");
834         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
835         
836         prop= RNA_def_property(srna, "draw_names", PROP_BOOLEAN, PROP_NONE);
837         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWNAMES);
838         RNA_def_property_ui_text(prop, "Draw Names", "Draw bone names.");
839         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
840         
841         prop= RNA_def_property(srna, "delay_deform", PROP_BOOLEAN, PROP_NONE);
842         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DELAYDEFORM);
843         RNA_def_property_ui_text(prop, "Delay Deform", "Don't deform children when manipulating bones in Pose Mode");
844         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
845         
846         prop= RNA_def_property(srna, "x_axis_mirror", PROP_BOOLEAN, PROP_NONE);
847         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_MIRROR_EDIT);
848         RNA_def_property_ui_text(prop, "X-Axis Mirror", "Apply changes to matching bone on opposite side of X-Axis.");
849         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
850         
851         prop= RNA_def_property(srna, "auto_ik", PROP_BOOLEAN, PROP_NONE);
852         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_AUTO_IK);
853         RNA_def_property_ui_text(prop, "Auto IK", "Add temporaral IK constraints while grabbing bones in Pose Mode.");
854         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
855         
856         prop= RNA_def_property(srna, "draw_custom_bone_shapes", PROP_BOOLEAN, PROP_NONE);
857         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ARM_NO_CUSTOM);
858         RNA_def_property_ui_text(prop, "Draw Custom Bone Shapes", "Draw bones with their custom shapes.");
859         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
860         
861         prop= RNA_def_property(srna, "draw_group_colors", PROP_BOOLEAN, PROP_NONE);
862         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_COL_CUSTOM);
863         RNA_def_property_ui_text(prop, "Draw Bone Group Colors", "Draw bone group colors.");
864         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
865         
866         prop= RNA_def_property(srna, "ghost_only_selected", PROP_BOOLEAN, PROP_NONE);
867         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_GHOST_ONLYSEL);
868         RNA_def_property_ui_text(prop, "Draw Ghosts on Selected Bones Only", "");
869         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
870         
871                 /* deformflag */
872         prop= RNA_def_property(srna, "deform_vertexgroups", PROP_BOOLEAN, PROP_NONE);
873         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_VGROUP);
874         RNA_def_property_ui_text(prop, "Deform Vertex Groups", "Enable Vertex Groups when defining deform");
875         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
876         
877         prop= RNA_def_property(srna, "deform_envelope", PROP_BOOLEAN, PROP_NONE);
878         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_ENVELOPE);
879         RNA_def_property_ui_text(prop, "Deform Envelopes", "Enable Bone Envelopes when defining deform");
880         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
881         
882         prop= RNA_def_property(srna, "deform_quaternion", PROP_BOOLEAN, PROP_NONE);
883         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
884         RNA_def_property_ui_text(prop, "Use Dual Quaternion Deformation", "Enable deform rotation with Quaternions");
885         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
886         
887         prop= RNA_def_property(srna, "deform_bbone_rest", PROP_BOOLEAN, PROP_NONE);
888         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_B_BONE_REST);
889         RNA_def_property_ui_text(prop, "B-Bones Deform in Rest Position", "Make B-Bones deform already in Rest Position");
890         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
891         
892         //prop= RNA_def_property(srna, "deform_invert_vertexgroups", PROP_BOOLEAN, PROP_NONE);
893         //RNA_def_property_boolean_negative_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
894         //RNA_def_property_ui_text(prop, "Invert Vertex Group Influence", "Invert Vertex Group influence (only for Modifiers)");
895         //RNA_def_property_update(prop, 0, "rna_Armature_update_data");
896         
897                 /* pathflag */
898         prop= RNA_def_property(srna, "paths_show_frame_numbers", PROP_BOOLEAN, PROP_NONE);
899         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_FNUMS);
900         RNA_def_property_ui_text(prop, "Paths Show Frame Numbers", "When drawing Armature in Pose Mode, show frame numbers on Bone Paths");
901         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
902         
903         prop= RNA_def_property(srna, "paths_highlight_keyframes", PROP_BOOLEAN, PROP_NONE);
904         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_KFRAS);
905         RNA_def_property_ui_text(prop, "Paths Highlight Keyframes", "When drawing Armature in Pose Mode, emphasize position of keyframes on Bone Paths");
906         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
907         
908         prop= RNA_def_property(srna, "paths_show_keyframe_numbers", PROP_BOOLEAN, PROP_NONE);
909         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_KFNOS);
910         RNA_def_property_ui_text(prop, "Paths Show Keyframe Numbers", "When drawing Armature in Pose Mode, show frame numbers of Keyframes on Bone Paths");
911         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
912         
913         
914         /* Number fields */
915                 /* ghost/onionskining settings */
916         prop= RNA_def_property(srna, "ghost_step", PROP_INT, PROP_NONE);
917         RNA_def_property_int_sdna(prop, NULL, "ghostep");
918         RNA_def_property_range(prop, 0, 30);
919         RNA_def_property_ui_text(prop, "Ghosting Step", "Number of frame steps on either side of current frame to show as ghosts (only for 'Around Current Frame' Onion-skining method).");
920         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
921         
922         prop= RNA_def_property(srna, "ghost_size", PROP_INT, PROP_NONE);
923         RNA_def_property_int_sdna(prop, NULL, "ghostsize");
924         RNA_def_property_range(prop, 1, 20);
925         RNA_def_property_ui_text(prop, "Ghosting Frame Step", "Frame step for Ghosts (not for 'On Keyframes' Onion-skining method).");
926         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
927         
928         prop= RNA_def_property(srna, "ghost_start_frame", PROP_INT, PROP_TIME);
929         RNA_def_property_int_sdna(prop, NULL, "ghostsf");
930         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_start_frame_set", NULL);
931         RNA_def_property_ui_text(prop, "Ghosting Start Frame", "Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method).");
932         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
933         
934         prop= RNA_def_property(srna, "ghost_end_frame", PROP_INT, PROP_TIME);
935         RNA_def_property_int_sdna(prop, NULL, "ghostef");
936         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_end_frame_set", NULL);
937         RNA_def_property_ui_text(prop, "Ghosting End Frame", "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method).");
938         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
939         
940                 /* bone path settings */
941         prop= RNA_def_property(srna, "path_size", PROP_INT, PROP_NONE);
942         RNA_def_property_int_sdna(prop, NULL, "pathsize");
943         RNA_def_property_range(prop, 1, 100);
944         RNA_def_property_ui_text(prop, "Paths Frame Step", "Number of frames between 'dots' on Bone Paths (when drawing).");
945         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
946         
947         prop= RNA_def_property(srna, "path_start_frame", PROP_INT, PROP_TIME);
948         RNA_def_property_int_sdna(prop, NULL, "pathsf");
949         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_path_start_frame_set", NULL);
950         RNA_def_property_ui_text(prop, "Paths Calculation Start Frame", "Starting frame of range of frames to use for Bone Path calculations.");
951         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
952         
953         prop= RNA_def_property(srna, "path_end_frame", PROP_INT, PROP_TIME);
954         RNA_def_property_int_sdna(prop, NULL, "pathef");
955         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_path_end_frame_set", NULL);
956         RNA_def_property_ui_text(prop, "Paths Calculation End Frame", "End frame of range of frames to use for Bone Path calculations.");
957         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
958         
959         prop= RNA_def_property(srna, "path_before_current", PROP_INT, PROP_NONE);
960         RNA_def_property_int_sdna(prop, NULL, "pathbc");
961         RNA_def_property_range(prop, 1, MAXFRAMEF/2);
962         RNA_def_property_ui_text(prop, "Paths Frames Before Current", "Number of frames before current frame to show on Bone Paths (only for 'Around Current' option).");
963         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
964         
965         prop= RNA_def_property(srna, "path_after_current", PROP_INT, PROP_NONE);
966         RNA_def_property_int_sdna(prop, NULL, "pathac");
967         RNA_def_property_range(prop, 1, MAXFRAMEF/2);
968         RNA_def_property_ui_text(prop, "Paths Frames After Current", "Number of frames after current frame to show on Bone Paths (only for 'Around Current' option).");
969         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
970 }
971
972 void RNA_def_armature(BlenderRNA *brna)
973 {
974         rna_def_armature(brna);
975         rna_def_bone(brna);
976         rna_def_edit_bone(brna);
977 }
978
979 #endif