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