merge with trunk at r31523
[blender.git] / source / blender / makesrna / intern / rna_nla.c
1 /**
2  * $Id: rna_nla.c 21537 2009-07-11 22:22:53Z gsrb3d $
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Blender Foundation (2009), Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28
29 #include "rna_internal.h"
30
31 #include "DNA_anim_types.h"
32 #include "DNA_action_types.h"
33 #include "DNA_scene_types.h"
34
35 #include "MEM_guardedalloc.h"
36
37 #ifdef RNA_RUNTIME
38
39 #include <stdio.h>
40 #include <math.h>
41
42 /* needed for some of the validation stuff... */
43 #include "BKE_animsys.h"
44 #include "BKE_nla.h"
45
46 /* temp constant defined for these funcs only... */
47 #define NLASTRIP_MIN_LEN_THRESH         0.1f
48
49 static void rna_NlaStrip_name_set(PointerRNA *ptr, const char *value)
50 {
51         NlaStrip *data= (NlaStrip *)ptr->data;
52         
53         /* copy the name first */
54         BLI_strncpy(data->name, value, sizeof(data->name));
55         
56         /* validate if there's enough info to do so */
57         if (ptr->id.data) {
58                 AnimData *adt= BKE_animdata_from_id(ptr->id.data);
59                 BKE_nlastrip_validate_name(adt, data);
60         }
61 }
62
63 static char *rna_NlaStrip_path(PointerRNA *ptr)
64 {
65         NlaStrip *strip= (NlaStrip *)ptr->data;
66         AnimData *adt= BKE_animdata_from_id(ptr->id.data);
67         
68         /* if we're attached to AnimData, try to resolve path back to AnimData */
69         if (adt) {
70                 NlaTrack *nlt;
71                 NlaStrip *nls;
72                 
73                 for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) {
74                         for (nls = nlt->strips.first; nls; nls = nls->next) {
75                                 if (nls == strip) {
76                                         // XXX but if we animate like this, the control will never work...
77                                         return BLI_sprintfN("animation_data.nla_tracks[\"%s\"].strips[\"%s\"]", nlt->name, strip->name);
78                                 }
79                         }
80                 }
81         }
82         
83         /* no path */
84         return "";
85 }
86
87 static void rna_NlaStrip_transform_update(Main *bmain, Scene *scene, PointerRNA *ptr)
88 {
89         NlaStrip *strip= (NlaStrip*)ptr->data;
90
91         BKE_nlameta_flush_transforms(strip);
92 }
93
94 static void rna_NlaStrip_start_frame_set(PointerRNA *ptr, float value)
95 {
96         NlaStrip *data= (NlaStrip*)ptr->data;
97         
98         /* clamp value to lie within valid limits 
99          *      - cannot start past the end of the strip + some flexibility threshold
100          *      - cannot start before the previous strip (if present) ends
101          *              -> but if it was a transition, we could go up to the start of the strip + some flexibility threshold
102          *              as long as we re-adjust the transition afterwards
103          *      - minimum frame is -MAXFRAME so that we don't get clipping on frame 0
104          */
105         if (data->prev) {
106                 if (data->prev->type == NLASTRIP_TYPE_TRANSITION) {
107                         CLAMP(value, data->prev->start+NLASTRIP_MIN_LEN_THRESH, data->end-NLASTRIP_MIN_LEN_THRESH);
108                         
109                         /* readjust the transition to stick to the endpoints of the action-clips */
110                         data->prev->end= value;
111                 }
112                 else {
113                         CLAMP(value, data->prev->end, data->end-NLASTRIP_MIN_LEN_THRESH);
114                 }
115         }
116         else {
117                 CLAMP(value, MINAFRAME, data->end);
118         }
119         data->start= value;
120 }
121
122 static void rna_NlaStrip_end_frame_set(PointerRNA *ptr, float value)
123 {
124         NlaStrip *data= (NlaStrip*)ptr->data;
125         
126         /* clamp value to lie within valid limits
127          *      - must not have zero or negative length strip, so cannot start before the first frame 
128          *        + some minimum-strip-length threshold
129          *      - cannot end later than the start of the next strip (if present)
130          *              -> but if it was a transition, we could go up to the start of the end - some flexibility threshold
131          *              as long as we re-adjust the transition afterwards
132          */
133         if (data->next) {
134                 if (data->next->type == NLASTRIP_TYPE_TRANSITION) {
135                         CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->end-NLASTRIP_MIN_LEN_THRESH);
136                         
137                         /* readjust the transition to stick to the endpoints of the action-clips */
138                         data->next->start= value;
139                 }
140                 else {
141                         CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->start);
142                 }
143         }
144         else {
145                 CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, MAXFRAME);
146         }
147         data->end= value;
148         
149         
150         /* calculate the lengths the strip and its action (if applicable) */
151         if (data->type == NLASTRIP_TYPE_CLIP) {
152                 float len, actlen;
153                 
154                 len= data->end - data->start;
155                 actlen= data->actend - data->actstart;
156                 if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
157                 
158                 /* now, adjust the 'scale' setting to reflect this (so that this change can be valid) */
159                 data->scale= len / ((actlen) * data->repeat);
160         }
161 }
162
163 static void rna_NlaStrip_scale_set(PointerRNA *ptr, float value)
164 {
165         NlaStrip *data= (NlaStrip*)ptr->data;
166         
167         /* set scale value */
168         CLAMP(value, 0.0001f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
169         data->scale= value;
170         
171         /* adjust the strip extents in response to this */
172         BKE_nlastrip_recalculate_bounds(data);
173 }
174
175 static void rna_NlaStrip_repeat_set(PointerRNA *ptr, float value)
176 {
177         NlaStrip *data= (NlaStrip*)ptr->data;
178         
179         /* set repeat value */
180         CLAMP(value, 0.01f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
181         data->repeat= value;
182         
183         /* adjust the strip extents in response to this */
184         BKE_nlastrip_recalculate_bounds(data);
185 }
186
187 static void rna_NlaStrip_blend_in_set(PointerRNA *ptr, float value)
188 {
189         NlaStrip *data= (NlaStrip*)ptr->data;
190         float len;
191         
192         /* blend-in is limited to the length of the strip, and also cannot overlap with blendout */
193         len= (data->end - data->start) - data->blendout;
194         CLAMP(value, 0, len);
195         
196         data->blendin= value;
197 }
198
199 static void rna_NlaStrip_blend_out_set(PointerRNA *ptr, float value)
200 {
201         NlaStrip *data= (NlaStrip*)ptr->data;
202         float len;
203         
204         /* blend-out is limited to the length of the strip */
205         len= (data->end - data->start);
206         CLAMP(value, 0, len);
207         
208         /* it also cannot overlap with blendin */
209         if ((len - value) < data->blendin)
210                 value= len - data->blendin;
211         
212         data->blendout= value;
213 }
214
215 static void rna_NlaStrip_action_start_frame_set(PointerRNA *ptr, float value)
216 {
217         NlaStrip *data= (NlaStrip*)ptr->data;
218         
219         /* prevent start frame from occurring after end of action */
220         CLAMP(value, MINAFRAME, data->actend);
221         data->actstart= value;
222         
223         /* adjust the strip extents in response to this */
224         // TODO: should the strip be moved backwards instead as a special case?
225         BKE_nlastrip_recalculate_bounds(data);
226 }
227
228 static void rna_NlaStrip_action_end_frame_set(PointerRNA *ptr, float value)
229 {
230         NlaStrip *data= (NlaStrip*)ptr->data;
231         
232         /* prevent end frame from starting before start of action */
233         CLAMP(value, data->actstart, MAXFRAME);
234         data->actend= value;
235         
236         /* adjust the strip extents in response to this */
237         BKE_nlastrip_recalculate_bounds(data);
238 }
239
240 static void rna_NlaStrip_animated_influence_set(PointerRNA *ptr, int value)
241 {
242         NlaStrip *data= (NlaStrip*)ptr->data;
243         
244         if (value) {
245                 /* set the flag, then make sure a curve for this exists */
246                 data->flag |= NLASTRIP_FLAG_USR_INFLUENCE;
247                 BKE_nlastrip_validate_fcurves(data);
248         }
249         else
250                 data->flag &= ~NLASTRIP_FLAG_USR_INFLUENCE;
251 }
252
253 static void rna_NlaStrip_animated_time_set(PointerRNA *ptr, int value)
254 {
255         NlaStrip *data= (NlaStrip*)ptr->data;
256         
257         if (value) {
258                 /* set the flag, then make sure a curve for this exists */
259                 data->flag |= NLASTRIP_FLAG_USR_TIME;
260                 BKE_nlastrip_validate_fcurves(data);
261         }
262         else
263                 data->flag &= ~NLASTRIP_FLAG_USR_TIME;
264 }
265
266 #else
267
268 /* enum defines exported for rna_animation.c */
269 EnumPropertyItem nla_mode_blend_items[] = {
270         {NLASTRIP_MODE_REPLACE, "REPLACE", 0, "Replace", "Result strip replaces the accumulated results by amount specified by influence"},
271         {NLASTRIP_MODE_ADD, "ADD", 0, "Add", "Weighted result of strip is added to the accumlated results"},
272         {NLASTRIP_MODE_SUBTRACT, "SUBTRACT", 0, "Subtract", "Weighted result of strip is removed from the accumlated results"},
273         {NLASTRIP_MODE_MULTIPLY, "MULITPLY", 0, "Multiply", "Weighted result of strip is multiplied with the accumlated results"},
274         {0, NULL, 0, NULL, NULL}};
275 EnumPropertyItem nla_mode_extend_items[] = {
276         {NLASTRIP_EXTEND_NOTHING, "NOTHING", 0, "Nothing", "Strip has no influence past its extents"},
277         {NLASTRIP_EXTEND_HOLD, "HOLD", 0, "Hold", "Hold the first frame if no previous strips in track, and always hold last frame"},
278         {NLASTRIP_EXTEND_HOLD_FORWARD, "HOLD_FORWARD", 0, "Hold Forward", "Only hold last frame"},
279         {0, NULL, 0, NULL, NULL}};
280
281 static void rna_def_nlastrip(BlenderRNA *brna)
282 {
283         StructRNA *srna;
284         PropertyRNA *prop;
285         
286                 /* enum defs */
287         static EnumPropertyItem prop_type_items[] = {
288                 {NLASTRIP_TYPE_CLIP, "CLIP", 0, "Action Clip", "NLA Strip references some Action"},
289                 {NLASTRIP_TYPE_TRANSITION, "TRANSITION", 0, "Transition", "NLA Strip 'transitions' between adjacent strips"},
290                 {NLASTRIP_TYPE_META, "META", 0, "Meta", "NLA Strip acts as a container for adjacent strips"},
291                 {0, NULL, 0, NULL, NULL}};
292         
293         /* struct definition */
294         srna= RNA_def_struct(brna, "NlaStrip", NULL);
295         RNA_def_struct_ui_text(srna, "NLA Strip", "A container referencing an existing Action");
296         RNA_def_struct_path_func(srna, "rna_NlaStrip_path");
297         RNA_def_struct_ui_icon(srna, ICON_NLA); // XXX
298         
299         /* name property */
300         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
301         RNA_def_property_ui_text(prop, "Name", "");
302         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NlaStrip_name_set");
303         RNA_def_struct_name_property(srna, prop);
304         
305         /* Enums */
306         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
307         RNA_def_property_enum_sdna(prop, NULL, "type");
308         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX for now, not editable, since this is dangerous
309         RNA_def_property_enum_items(prop, prop_type_items);
310         RNA_def_property_ui_text(prop, "Type", "Type of NLA Strip");
311         
312         prop= RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
313         RNA_def_property_enum_sdna(prop, NULL, "extendmode");
314         RNA_def_property_enum_items(prop, nla_mode_extend_items);
315         RNA_def_property_ui_text(prop, "Extrapolation", "Action to take for gaps past the strip extents");
316         
317         prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
318         RNA_def_property_enum_sdna(prop, NULL, "blendmode");
319         RNA_def_property_enum_items(prop, nla_mode_blend_items);
320         RNA_def_property_ui_text(prop, "Blending", "Method used for combining strip's result with accumulated result");
321         
322         /* Strip extents */
323         prop= RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_TIME);
324         RNA_def_property_float_sdna(prop, NULL, "start");
325         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_start_frame_set", NULL);
326         RNA_def_property_ui_text(prop, "Start Frame", "");
327         RNA_def_property_update(prop, 0, "rna_NlaStrip_transform_update");
328         
329         prop= RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_TIME);
330         RNA_def_property_float_sdna(prop, NULL, "end");
331         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_end_frame_set", NULL);
332         RNA_def_property_ui_text(prop, "End Frame", "");
333         RNA_def_property_update(prop, 0, "rna_NlaStrip_transform_update");
334         
335         /* Blending */
336         prop= RNA_def_property(srna, "blend_in", PROP_FLOAT, PROP_NONE);
337         RNA_def_property_float_sdna(prop, NULL, "blendin");
338         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_in_set", NULL);
339         RNA_def_property_ui_text(prop, "Blend In", "Number of frames at start of strip to fade in influence");
340         
341         prop= RNA_def_property(srna, "blend_out", PROP_FLOAT, PROP_NONE);
342         RNA_def_property_float_sdna(prop, NULL, "blendout");
343         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_out_set", NULL);
344         RNA_def_property_ui_text(prop, "Blend Out", "");
345         
346         prop= RNA_def_property(srna, "use_auto_blend", PROP_BOOLEAN, PROP_NONE);
347         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_AUTO_BLENDS);
348         RNA_def_property_ui_text(prop, "Auto Blend In/Out", "Number of frames for Blending In/Out is automatically determined from overlapping strips");
349         
350         /* Action */
351         prop= RNA_def_property(srna, "action", PROP_POINTER, PROP_NONE);
352         RNA_def_property_pointer_sdna(prop, NULL, "act");
353         RNA_def_property_flag(prop, PROP_EDITABLE); 
354         RNA_def_property_ui_text(prop, "Action", "Action referenced by this strip");
355         
356         /* Action extents */
357         prop= RNA_def_property(srna, "action_frame_start", PROP_FLOAT, PROP_TIME);
358         RNA_def_property_float_sdna(prop, NULL, "actstart");
359         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_start_frame_set", NULL);
360         RNA_def_property_ui_text(prop, "Action Start Frame", "");
361         
362         prop= RNA_def_property(srna, "action_frame_end", PROP_FLOAT, PROP_TIME);
363         RNA_def_property_float_sdna(prop, NULL, "actend");
364         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_end_frame_set", NULL);
365         RNA_def_property_ui_text(prop, "Action End Frame", "");
366         
367         /* Action Reuse */
368         prop= RNA_def_property(srna, "repeat", PROP_FLOAT, PROP_NONE);
369         RNA_def_property_float_sdna(prop, NULL, "repeat"); 
370         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_repeat_set", NULL);
371         RNA_def_property_range(prop, 0.1f, 1000.0f); /* these limits have currently be chosen arbitarily, but could be extended (minimum should still be > 0 though) if needed... */
372         RNA_def_property_ui_text(prop, "Repeat", "Number of times to repeat the action range");
373         
374         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
375         RNA_def_property_float_sdna(prop, NULL, "scale"); 
376         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_scale_set", NULL);
377         RNA_def_property_range(prop, 0.0001f, 1000.0f); /* these limits can be extended, but beyond this, we can get some crazy+annoying bugs due to numeric errors */
378         RNA_def_property_ui_text(prop, "Scale", "Scaling factor for action");
379         
380         /* Strip's F-Curves */
381         prop= RNA_def_property(srna, "fcurves", PROP_COLLECTION, PROP_NONE);
382         RNA_def_property_struct_type(prop, "FCurve");
383         RNA_def_property_ui_text(prop, "F-Curves", "F-Curves for controlling the strip's influence and timing");
384         
385         /* Strip's F-Modifiers */
386         prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
387         RNA_def_property_struct_type(prop, "FModifier");
388         RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting all the F-Curves in the referenced Action");
389         
390         /* Strip's Sub-Strips (for Meta-Strips) */
391         prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
392         RNA_def_property_struct_type(prop, "NlaStrip");
393         RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips that this strip acts as a container for (if it is of type Meta)");
394         
395         /* Settings - Values necessary for evaluation */
396         prop= RNA_def_property(srna, "influence", PROP_FLOAT, PROP_NONE);
397         RNA_def_property_range(prop, 0.0f, 1.0f);
398         RNA_def_property_ui_text(prop, "Influence", "Amount the strip contributes to the current result");
399         
400         prop= RNA_def_property(srna, "strip_time", PROP_FLOAT, PROP_TIME);
401         RNA_def_property_ui_text(prop, "Strip Time", "Frame of referenced Action to evaluate");
402         
403                 // TODO: should the animated_influence/time settings be animatable themselves?
404         prop= RNA_def_property(srna, "use_animated_influence", PROP_BOOLEAN, PROP_NONE);
405         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_INFLUENCE);
406         RNA_def_property_boolean_funcs(prop, NULL, "rna_NlaStrip_animated_influence_set");
407         RNA_def_property_ui_text(prop, "Animated Influence", "Influence setting is controlled by an F-Curve rather than automatically determined");
408         
409         prop= RNA_def_property(srna, "use_animated_time", PROP_BOOLEAN, PROP_NONE);
410         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_TIME);
411         RNA_def_property_boolean_funcs(prop, NULL, "rna_NlaStrip_animated_time_set");
412         RNA_def_property_ui_text(prop, "Animated Strip Time", "Strip time is controlled by an F-Curve rather than automatically determined");
413
414         prop= RNA_def_property(srna, "use_animated_time_cyclic", PROP_BOOLEAN, PROP_NONE);
415         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_TIME_CYCLIC);
416         RNA_def_property_ui_text(prop, "Cyclic Strip Time", "Cycle the animated time within the action start & end");
417         RNA_def_property_update(prop, 0, "rna_NlaStrip_transform_update"); // is there a better update flag?
418         
419         /* settings */
420         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
421         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
422         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_ACTIVE);
423         RNA_def_property_ui_text(prop, "Active", "NLA Strip is active");
424         
425         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
426         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_SELECT);
427         RNA_def_property_ui_text(prop, "Select", "NLA Strip is selected");
428         
429         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
430         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_MUTED);
431         RNA_def_property_ui_text(prop, "Muted", "NLA Strip is not evaluated");
432         
433         prop= RNA_def_property(srna, "use_reverse", PROP_BOOLEAN, PROP_NONE);
434         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_REVERSE);
435         RNA_def_property_ui_text(prop, "Reversed", "NLA Strip is played back in reverse order (only when timing is automatically determined)");
436         
437         // TODO: 
438         // - sync length
439 }
440
441 static void rna_def_nlatrack(BlenderRNA *brna)
442 {
443         StructRNA *srna;
444         PropertyRNA *prop;
445         
446         srna= RNA_def_struct(brna, "NlaTrack", NULL);
447         RNA_def_struct_ui_text(srna, "NLA Track", "A animation layer containing Actions referenced as NLA strips");
448         RNA_def_struct_ui_icon(srna, ICON_NLA);
449         
450         /* strips collection */
451         prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
452         RNA_def_property_struct_type(prop, "NlaStrip");
453         RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips on this NLA-track");
454         
455         /* name property */
456         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
457         RNA_def_property_ui_text(prop, "Name", "");
458         RNA_def_struct_name_property(srna, prop);
459         
460         /* settings */
461         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
462         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
463         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_ACTIVE);
464         RNA_def_property_ui_text(prop, "Active", "NLA Track is active");
465         
466         prop= RNA_def_property(srna, "is_solo", PROP_BOOLEAN, PROP_NONE);
467         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
468         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SOLO);
469         RNA_def_property_ui_text(prop, "Solo", "NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)");
470         
471         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
472         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SELECTED);
473         RNA_def_property_ui_text(prop, "Select", "NLA Track is selected");
474         
475         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
476         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_MUTED);
477         RNA_def_property_ui_text(prop, "Muted", "NLA Track is not evaluated");
478
479         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
480         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_PROTECTED);
481         RNA_def_property_ui_text(prop, "Locked", "NLA Track is locked");
482 }
483
484 /* --------- */
485
486 void RNA_def_nla(BlenderRNA *brna)
487 {
488         rna_def_nlatrack(brna);
489         rna_def_nlastrip(brna);
490 }
491
492
493 #endif