Merging r46203 through r46413 from trunk into soc-2011-tomato
[blender.git] / source / blender / makesrna / intern / rna_key.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_key.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29
30 #include "RNA_access.h"
31 #include "RNA_define.h"
32
33 #include "rna_internal.h"
34
35 #include "DNA_ID.h"
36 #include "DNA_scene_types.h"
37 #include "DNA_curve_types.h"
38 #include "DNA_key_types.h"
39 #include "DNA_lattice_types.h"
40 #include "DNA_mesh_types.h"
41
42 #ifdef RNA_RUNTIME
43
44 #include <stddef.h>
45
46 #include "DNA_object_types.h"
47 #include "DNA_scene_types.h"
48
49 #include "BKE_animsys.h"
50 #include "BKE_depsgraph.h"
51 #include "BKE_key.h"
52 #include "BKE_main.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 static Key *rna_ShapeKey_find_key(ID *id)
58 {
59         switch (GS(id->name)) {
60                 case ID_CU: return ((Curve*)id)->key;
61                 case ID_KE: return (Key*)id;
62                 case ID_LT: return ((Lattice*)id)->key;
63                 case ID_ME: return ((Mesh*)id)->key;
64                 case ID_OB: return ob_get_key((Object*)id);
65                 default: return NULL;
66         }
67 }
68
69 void rna_ShapeKey_name_set(PointerRNA *ptr, const char *value)
70 {
71         KeyBlock *kb = ptr->data;
72         char oldname[sizeof(kb->name)];
73         
74         /* make a copy of the old name first */
75         BLI_strncpy(oldname, kb->name, sizeof(kb->name));
76         
77         /* copy the new name into the name slot */
78         BLI_strncpy_utf8(kb->name, value, sizeof(kb->name));
79         
80         /* make sure the name is truly unique */
81         if (ptr->id.data) {
82                 Key *key = rna_ShapeKey_find_key(ptr->id.data);
83                 BLI_uniquename(&key->block, kb, "Key", '.', offsetof(KeyBlock, name), sizeof(kb->name));
84         }
85         
86         /* fix all the animation data which may link to this */
87         BKE_all_animdata_fix_paths_rename(NULL, "key_blocks", oldname, kb->name);
88 }
89
90 static void rna_ShapeKey_value_set(PointerRNA *ptr, float value)
91 {
92         KeyBlock *data = (KeyBlock*)ptr->data;
93         CLAMP(value, data->slidermin, data->slidermax);
94         data->curval = value;
95 }
96
97 static void rna_ShapeKey_value_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
98 {
99         KeyBlock *data = (KeyBlock*)ptr->data;
100
101         *min = data->slidermin;
102         *max = data->slidermax;
103 }
104
105 /* epsilon for how close one end of shapekey range can get to the other */
106 #define SHAPEKEY_SLIDER_TOL 0.001f
107
108 static void rna_ShapeKey_slider_min_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
109 {
110         KeyBlock *data = (KeyBlock*)ptr->data;
111
112         *min = -10.0f;
113         *max = data->slidermax - SHAPEKEY_SLIDER_TOL;
114 }
115
116 static void rna_ShapeKey_slider_min_set(PointerRNA *ptr, float value)
117 {
118         KeyBlock *data = (KeyBlock*)ptr->data;
119         float min, max, softmin, softmax;
120         
121         rna_ShapeKey_slider_min_range(ptr, &min, &max, &softmin, &softmax);
122         CLAMP(value, min, max);
123         data->slidermin = value;
124 }
125
126 static void rna_ShapeKey_slider_max_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
127 {
128         KeyBlock *data = (KeyBlock*)ptr->data;
129
130         *min = data->slidermin + SHAPEKEY_SLIDER_TOL;
131         *max = 10.0f;
132 }
133
134 static void rna_ShapeKey_slider_max_set(PointerRNA *ptr, float value)
135 {
136         KeyBlock *data = (KeyBlock*)ptr->data;
137         float min, max, softmin, softmax;
138         
139         rna_ShapeKey_slider_max_range(ptr, &min, &max, &softmin, &softmax);
140         CLAMP(value, min, max);
141         data->slidermax = value;
142 }
143
144 #undef SHAPEKEY_SLIDER_TOL
145
146 PointerRNA rna_object_shapekey_index_get(ID *id, int value)
147 {
148         Key *key = rna_ShapeKey_find_key(id);
149         KeyBlock *kb = NULL;
150         PointerRNA ptr;
151
152         if (key && value < key->totkey)
153                 kb = BLI_findlink(&key->block, value);
154         
155         RNA_pointer_create(id, &RNA_ShapeKey, kb, &ptr);
156
157         return ptr;
158 }
159
160 int rna_object_shapekey_index_set(ID *id, PointerRNA value, int current)
161 {
162         Key *key = rna_ShapeKey_find_key(id);
163
164         if (key) {
165                 int a = BLI_findindex(&key->block, value.data);
166                 if (a >= 0) return a;
167         }
168         
169         return current;
170 }
171
172 static PointerRNA rna_ShapeKey_relative_key_get(PointerRNA *ptr)
173 {
174         KeyBlock *kb = (KeyBlock*)ptr->data;
175
176         return rna_object_shapekey_index_get(ptr->id.data, kb->relative);
177 }
178
179 static void rna_ShapeKey_relative_key_set(PointerRNA *ptr, PointerRNA value)
180 {
181         KeyBlock *kb = (KeyBlock*)ptr->data;
182
183         kb->relative = rna_object_shapekey_index_set(ptr->id.data, value, kb->relative);
184 }
185
186 static void rna_ShapeKeyPoint_co_get(PointerRNA *ptr, float *values)
187 {
188         float *vec = (float*)ptr->data;
189
190         values[0] = vec[0];
191         values[1] = vec[1];
192         values[2] = vec[2];
193 }
194
195 static void rna_ShapeKeyPoint_co_set(PointerRNA *ptr, const float *values)
196 {
197         float *vec = (float*)ptr->data;
198
199         vec[0] = values[0];
200         vec[1] = values[1];
201         vec[2] = values[2];
202 }
203
204 static float rna_ShapeKeyCurvePoint_tilt_get(PointerRNA *ptr)
205 {
206         float *vec = (float*)ptr->data;
207         return vec[3];
208 }
209
210 static void rna_ShapeKeyCurvePoint_tilt_set(PointerRNA *ptr, float value)
211 {
212         float *vec = (float*)ptr->data;
213         vec[3] = value;
214 }
215
216 static void rna_ShapeKeyBezierPoint_co_get(PointerRNA *ptr, float *values)
217 {
218         float *vec = (float*)ptr->data;
219
220         values[0] = vec[0+3];
221         values[1] = vec[1+3];
222         values[2] = vec[2+3];
223 }
224
225 static void rna_ShapeKeyBezierPoint_co_set(PointerRNA *ptr, const float *values)
226 {
227         float *vec = (float*)ptr->data;
228
229         vec[0+3] = values[0];
230         vec[1+3] = values[1];
231         vec[2+3] = values[2];
232 }
233
234 static void rna_ShapeKeyBezierPoint_handle_1_co_get(PointerRNA *ptr, float *values)
235 {
236         float *vec = (float*)ptr->data;
237
238         values[0] = vec[0];
239         values[1] = vec[1];
240         values[2] = vec[2];
241 }
242
243 static void rna_ShapeKeyBezierPoint_handle_1_co_set(PointerRNA *ptr, const float *values)
244 {
245         float *vec = (float*)ptr->data;
246
247         vec[0] = values[0];
248         vec[1] = values[1];
249         vec[2] = values[2];
250 }
251
252 static void rna_ShapeKeyBezierPoint_handle_2_co_get(PointerRNA *ptr, float *values)
253 {
254         float *vec = (float*)ptr->data;
255
256         values[0] = vec[6+0];
257         values[1] = vec[6+1];
258         values[2] = vec[6+2];
259 }
260
261 static void rna_ShapeKeyBezierPoint_handle_2_co_set(PointerRNA *ptr, const float *values)
262 {
263         float *vec = (float*)ptr->data;
264
265         vec[6+0] = values[0];
266         vec[6+1] = values[1];
267         vec[6+2] = values[2];
268 }
269
270 #if 0
271 static float rna_ShapeKeyBezierPoint_tilt_get(PointerRNA *ptr)
272 {
273         float *vec= (float*)ptr->data;
274         return vec[10];
275 }
276
277 static void rna_ShapeKeyBezierPoint_tilt_set(PointerRNA *ptr, float value)
278 {
279         float *vec= (float*)ptr->data;
280         vec[10]= value;
281 }
282 #endif
283
284 static void rna_ShapeKey_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
285 {
286         Key *key = rna_ShapeKey_find_key(ptr->id.data);
287         KeyBlock *kb = (KeyBlock*)ptr->data;
288         Curve *cu;
289         Nurb *nu;
290         int tot = kb->totelem, size = key->elemsize;
291         
292         if (GS(key->from->name) == ID_CU) {
293                 cu = (Curve*)key->from;
294                 nu = cu->nurb.first;
295                 
296                 if (nu->bezt) {
297                         tot /= 3;
298                         size *= 3;
299                 }
300         }
301         
302         rna_iterator_array_begin(iter, (void*)kb->data, size, tot, 0, NULL);
303 }
304
305 static int rna_ShapeKey_data_length(PointerRNA *ptr)
306 {
307         Key *key = rna_ShapeKey_find_key(ptr->id.data);
308         KeyBlock *kb = (KeyBlock*)ptr->data;
309         Curve *cu;
310         Nurb *nu;
311         int tot = kb->totelem;
312         
313         if (GS(key->from->name) == ID_CU) {
314                 cu = (Curve*)key->from;
315                 nu = cu->nurb.first;
316                 
317                 if (nu->bezt)
318                         tot /= 3;
319         }
320         
321         return tot;
322 }
323
324 static PointerRNA rna_ShapeKey_data_get(CollectionPropertyIterator *iter)
325 {
326         Key *key = rna_ShapeKey_find_key(iter->parent.id.data);
327         StructRNA *type;
328         Curve *cu;
329         Nurb *nu;
330         
331         if (GS(key->from->name) == ID_CU) {
332                 cu = (Curve*)key->from;
333                 nu = cu->nurb.first;
334                 
335                 if (nu->bezt)
336                         type = &RNA_ShapeKeyBezierPoint;
337                 else
338                         type = &RNA_ShapeKeyCurvePoint;
339         }
340         else
341                 type = &RNA_ShapeKeyPoint;
342         
343         return rna_pointer_inherit_refine(&iter->parent, type, rna_iterator_array_get(iter));
344 }
345
346 static char *rna_ShapeKey_path(PointerRNA *ptr)
347 {
348         KeyBlock *kb = (KeyBlock *)ptr->data;
349         ID *id = ptr->id.data;
350         
351         if ((id) && (GS(id->name) != ID_KE))
352                 return BLI_sprintfN("shape_keys.key_blocks[\"%s\"]", kb->name);
353         else
354                 return BLI_sprintfN("key_blocks[\"%s\"]", kb->name);
355 }
356
357 static void rna_Key_update_data(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
358 {
359         Key *key = ptr->id.data;
360         Object *ob;
361
362         for (ob = bmain->object.first; ob; ob = ob->id.next) {
363                 if (ob_get_key(ob) == key) {
364                         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
365                         WM_main_add_notifier(NC_OBJECT|ND_MODIFIER, ob);
366                 }
367         }
368 }
369
370 static KeyBlock *rna_ShapeKeyData_find_keyblock(Key *key, float *point)
371 {
372         KeyBlock *kb;
373         
374         /* sanity checks */
375         if (ELEM(NULL, key, point))
376                 return NULL;
377         
378         /* we'll need to manually search through the keyblocks and check
379          * if the point is somewhere in the middle of each block's data
380          */
381         for (kb = key->block.first; kb; kb = kb->next) {
382                 if (kb->data) {
383                         float *start = (float *)kb->data;
384                         float *end;
385                         
386                         /* easy cases first */
387                         if ((start == NULL) || (start > point)) {
388                                 /* there's no chance point is in array */
389                                 continue;
390                         }
391                         else if (start == point) {
392                                 /* exact match - point is first in array */
393                                 return kb;
394                         }
395                         
396                         /* determine where end of array is
397                          *      - elemsize is in bytes, so use char* cast to get array in terms of bytes
398                          */
399                         end = (float *)((char *)start + (key->elemsize * kb->totelem));
400                         
401                         /* if point's address is less than the end, then it is somewhere between start and end, so in array */
402                         if (end > point) {
403                                 /* we've found the owner of the point data */
404                                 return kb;
405                         }
406                 }
407         }
408         
409         return NULL;
410 }
411
412 static int rna_ShapeKeyPoint_get_index(Key *key, KeyBlock *kb, float *point)
413 {
414         /* if we frame the data array and point pointers as char*, then the difference between
415          * them will be in bytes. Thus, dividing through by key->elemsize (number of bytes per point)
416          * gives us the offset of point from start of array.
417          */
418         char *start = (char *)kb->data;
419         char *pt = (char *)point;
420         
421         return (int)(pt - start) / key->elemsize;
422 }
423
424 static char *rna_ShapeKeyPoint_path(PointerRNA *ptr)
425 {
426         ID *id = (ID *)ptr->id.data;
427         Key *key = rna_ShapeKey_find_key(ptr->id.data);
428         KeyBlock *kb;
429         float *point = (float *)ptr->data;
430         
431         /* if we can get a key block, we can construct a path */
432         kb = rna_ShapeKeyData_find_keyblock(key, point);
433         
434         if (kb) {
435                 int index = rna_ShapeKeyPoint_get_index(key, kb, point);
436                 
437                 if (GS(id->name) == ID_KE)
438                         return BLI_sprintfN("key_blocks[\"%s\"].data[%d]", kb->name, index);
439                 else
440                         return BLI_sprintfN("shape_keys.key_blocks[\"%s\"].data[%d]", kb->name, index);
441         }
442         else
443                 return NULL; /* XXX: there's really no way to resolve this... */
444 }
445
446 #else
447
448 static void rna_def_keydata(BlenderRNA *brna)
449 {
450         StructRNA *srna;
451         PropertyRNA *prop;
452
453         srna = RNA_def_struct(brna, "ShapeKeyPoint", NULL);
454         RNA_def_struct_ui_text(srna, "Shape Key Point", "Point in a shape key");
455         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
456
457         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
458         RNA_def_property_array(prop, 3);
459         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
460         RNA_def_property_ui_text(prop, "Location", "");
461         RNA_def_property_update(prop, 0, "rna_Key_update_data");
462
463         srna = RNA_def_struct(brna, "ShapeKeyCurvePoint", NULL);
464         RNA_def_struct_ui_text(srna, "Shape Key Curve Point", "Point in a shape key for curves");
465                 /* there's nothing type specific here, so this is fine for now */
466         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
467
468         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
469         RNA_def_property_array(prop, 3);
470         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
471         RNA_def_property_ui_text(prop, "Location", "");
472         RNA_def_property_update(prop, 0, "rna_Key_update_data");
473
474         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
475         RNA_def_property_float_funcs(prop, "rna_ShapeKeyCurvePoint_tilt_get", "rna_ShapeKeyCurvePoint_tilt_set", NULL);
476         RNA_def_property_ui_text(prop, "Tilt", "");
477         RNA_def_property_update(prop, 0, "rna_Key_update_data");
478
479         srna = RNA_def_struct(brna, "ShapeKeyBezierPoint", NULL);
480         RNA_def_struct_ui_text(srna, "Shape Key Bezier Point", "Point in a shape key for Bezier curves");
481                 /* there's nothing type specific here, so this is fine for now */
482         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
483
484         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
485         RNA_def_property_array(prop, 3);
486         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_co_get", "rna_ShapeKeyBezierPoint_co_set", NULL);
487         RNA_def_property_ui_text(prop, "Location", "");
488         RNA_def_property_update(prop, 0, "rna_Key_update_data");
489
490         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
491         RNA_def_property_array(prop, 3);
492         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_1_co_get",
493                                      "rna_ShapeKeyBezierPoint_handle_1_co_set", NULL);
494         RNA_def_property_ui_text(prop, "Handle 1 Location", "");
495         RNA_def_property_update(prop, 0, "rna_Key_update_data");
496
497         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
498         RNA_def_property_array(prop, 3);
499         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_2_co_get",
500                                      "rna_ShapeKeyBezierPoint_handle_2_co_set", NULL);
501         RNA_def_property_ui_text(prop, "Handle 2 Location", "");
502         RNA_def_property_update(prop, 0, "rna_Key_update_data");
503
504         /* appears to be unused currently */
505 #if 0
506         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
507         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
508         RNA_def_property_ui_text(prop, "Tilt", "");
509         RNA_def_property_update(prop, 0, "rna_Key_update_data");
510 #endif
511 }
512
513 static void rna_def_keyblock(BlenderRNA *brna)
514 {
515         StructRNA *srna;
516         PropertyRNA *prop;
517
518         static EnumPropertyItem prop_keyblock_type_items[] = {
519                 {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
520                 {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
521                 {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
522                 {0, NULL, 0, NULL, NULL}};
523
524         srna = RNA_def_struct(brna, "ShapeKey", NULL);
525         RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock");
526         RNA_def_struct_sdna(srna, "KeyBlock");
527         RNA_def_struct_path_func(srna, "rna_ShapeKey_path");
528         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
529
530         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
531         RNA_def_property_ui_text(prop, "Name", "Name of Shape Key");
532         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ShapeKey_name_set");
533         RNA_def_struct_name_property(srna, prop);
534
535         /* keys need to be sorted to edit this */
536         prop = RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
537         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
538         RNA_def_property_float_sdna(prop, NULL, "pos");
539         RNA_def_property_ui_text(prop, "Frame", "Frame for absolute keys");
540         RNA_def_property_update(prop, 0, "rna_Key_update_data");
541         
542         /* for now, this is editable directly, as users can set this even if they're not animating them
543          * (to test results) */
544         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_FACTOR);
545         RNA_def_property_float_sdna(prop, NULL, "curval");
546         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_value_set", "rna_ShapeKey_value_range");
547         RNA_def_property_ui_range(prop, -10.0f, 10.0f, 10, 3);
548         RNA_def_property_ui_text(prop, "Value", "Value of shape key at the current frame");
549         RNA_def_property_update(prop, 0, "rna_Key_update_data");
550
551         prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
552         RNA_def_property_enum_sdna(prop, NULL, "type");
553         RNA_def_property_enum_items(prop, prop_keyblock_type_items);
554         RNA_def_property_ui_text(prop, "Interpolation", "Interpolation type");
555         RNA_def_property_update(prop, 0, "rna_Key_update_data");
556
557         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
558         RNA_def_property_string_sdna(prop, NULL, "vgroup");
559         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex weight group, to blend with basis shape");
560         RNA_def_property_update(prop, 0, "rna_Key_update_data");
561
562         prop = RNA_def_property(srna, "relative_key", PROP_POINTER, PROP_NONE);
563         RNA_def_property_struct_type(prop, "ShapeKey");
564         RNA_def_property_flag(prop, PROP_EDITABLE);
565         RNA_def_property_pointer_funcs(prop, "rna_ShapeKey_relative_key_get",
566                                        "rna_ShapeKey_relative_key_set", NULL, NULL);
567         RNA_def_property_ui_text(prop, "Relative Key", "Shape used as a relative key");
568         RNA_def_property_update(prop, 0, "rna_Key_update_data");
569
570         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
571         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYBLOCK_MUTE);
572         RNA_def_property_ui_text(prop, "Mute", "Mute this shape key");
573         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
574         RNA_def_property_update(prop, 0, "rna_Key_update_data");
575
576         prop = RNA_def_property(srna, "slider_min", PROP_FLOAT, PROP_NONE);
577         RNA_def_property_float_sdna(prop, NULL, "slidermin");
578         RNA_def_property_range(prop, -10.0f, 10.0f);
579         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_min_set", "rna_ShapeKey_slider_min_range");
580         RNA_def_property_ui_text(prop, "Slider Min", "Minimum for slider");
581
582         prop = RNA_def_property(srna, "slider_max", PROP_FLOAT, PROP_NONE);
583         RNA_def_property_float_sdna(prop, NULL, "slidermax");
584         RNA_def_property_range(prop, -10.0f, 10.0f);
585         RNA_def_property_float_default(prop, 1.0f);
586         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_max_set", "rna_ShapeKey_slider_max_range");
587         RNA_def_property_ui_text(prop, "Slider Max", "Maximum for slider");
588
589         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
590         RNA_def_property_collection_sdna(prop, NULL, "data", "totelem");
591         RNA_def_property_struct_type(prop, "UnknownType");
592         RNA_def_property_ui_text(prop, "Data", "");
593         RNA_def_property_collection_funcs(prop, "rna_ShapeKey_data_begin", NULL, NULL, "rna_ShapeKey_data_get",
594                                           "rna_ShapeKey_data_length", NULL, NULL, NULL);
595 }
596
597 static void rna_def_key(BlenderRNA *brna)
598 {
599         StructRNA *srna;
600         PropertyRNA *prop;
601
602         srna = RNA_def_struct(brna, "Key", "ID");
603         RNA_def_struct_ui_text(srna, "Key", "Shape keys datablock containing different shapes of geometric datablocks");
604         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
605
606         prop = RNA_def_property(srna, "reference_key", PROP_POINTER, PROP_NONE);
607         RNA_def_property_flag(prop, PROP_NEVER_NULL);
608         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
609         RNA_def_property_pointer_sdna(prop, NULL, "refkey");
610         RNA_def_property_ui_text(prop, "Reference Key", "");
611
612         prop = RNA_def_property(srna, "key_blocks", PROP_COLLECTION, PROP_NONE);
613         RNA_def_property_collection_sdna(prop, NULL, "block", NULL);
614         RNA_def_property_struct_type(prop, "ShapeKey");
615         RNA_def_property_ui_text(prop, "Key Blocks", "Shape keys");
616
617         rna_def_animdata_common(srna);
618
619         prop = RNA_def_property(srna, "user", PROP_POINTER, PROP_NONE);
620         RNA_def_property_flag(prop, PROP_NEVER_NULL);
621         RNA_def_property_pointer_sdna(prop, NULL, "from");
622         RNA_def_property_ui_text(prop, "User", "Datablock using these shape keys");
623
624         prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
625         RNA_def_property_boolean_sdna(prop, NULL, "type", KEY_RELATIVE);
626         RNA_def_property_ui_text(prop, "Relative",
627                                  "Make shape keys relative, "
628                                  "otherwise play through shapes as a sequence using the evaluation time");
629         RNA_def_property_update(prop, 0, "rna_Key_update_data");
630
631         prop = RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
632         RNA_def_property_float_sdna(prop, NULL, "ctime");
633         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
634         RNA_def_property_ui_text(prop, "Evaluation Time", "Evaluation time for absolute shape keys");
635         RNA_def_property_update(prop, 0, "rna_Key_update_data");
636
637         prop = RNA_def_property(srna, "slurph", PROP_INT, PROP_UNSIGNED);
638         RNA_def_property_int_sdna(prop, NULL, "slurph");
639         RNA_def_property_range(prop, -500, 500);
640         RNA_def_property_ui_text(prop, "Slurph",
641                                  "Create a delay (in frames) in applying keypositions, first vertex goes first");
642         RNA_def_property_update(prop, 0, "rna_Key_update_data");
643 }
644
645 void RNA_def_key(BlenderRNA *brna)
646 {
647         rna_def_key(brna);
648         rna_def_keyblock(brna);
649         rna_def_keydata(brna);
650 }
651
652 #endif